# packages

pkgId: a41254cf1a7e817487c037bfe86af3e80d90895617bf425e4541545d5719138b
name: python-odsbox-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for odsbox
url: https://github.com/peak-solution/odsbox/tree/main#readme
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-odsbox-1.0.3-1.src.rpm
location_href: Packages/python-odsbox-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  The [*ODSBox*](https://peak-solution.github.io/odsbox) is a lightweight Python wrapper on the standardized [ASAM ODS REST API](https://www.asam.net/standards/detail/ods/wiki/).
  Using intuitive JAQuel queries and [pandas.DataFrames](https://pandas.pydata.org/) the *ODSBox* makes dealing with ASAM ODS
  data in Python more fun.

  ``` python
  from odsbox.con_i import ConI

  with ConI(url="https://MY_SERVER/api", auth=("sa", "sa")) as con_i:
      measurements = con_i.query_data(
          {
              "AoMeasurement": {"name": {"$like": "*"}},
              "$attributes": {"name": 1, "id": 1},
              "$options": {"$rowlimit": 50},
          }
      )
      print(measurements)
  ```



  * [*ODSBox* documentation](https://peak-solution.github.io/odsbox)
  * [Work with ASAM ODS server](https://peak-solution.github.io/data_management_learning_path/ods/query-asam-server.html)



  The ASAM ODS server is called using HTTP calls defined by the [ASAM ODS standard](https://www.asam.net/standards/detail/ods/wiki/#TechnicalContent).
  The messages are encode/decoded using ASAM ODS [protobuf](https://protobuf.dev/programming-guides/proto3/) message definitions provided at
  [ASAM-ODS-Interfaces](https://github.com/asam-ev/ASAM-ODS-Interfaces). As content type `application/x-asamods+protobuf` is used.



  JAQuel allows you to query your data in a simple and intuitive way inspired
  by [MongoDB Query Language (MQL)](https://www.mongodb.com/docs/manual/tutorial/query-documents/).
  The definition of query expression as JSON easily integrates with the Python language – a win-win situation.



  *ODSBox* is available on.

  |               |                                                                                      |
  | :------------ | :----------------------------------------------------------------------------------- |
  | github        | [https://github.com/peak-solution/odsbox/](https://github.com/peak-solution/odsbox/) |
  | PyPI          | [https://pypi.org/project/odsbox/](https://pypi.org/project/odsbox/)                 |
  | github docs   | [https://peak-solution.github.io/odsbox](https://peak-solution.github.io/odsbox)     |


  ```shell

  pip install odsbox

  pip install odsbox[exd-data]
  ```


pkgId: 9a0c48cb7298c1f73554e911ae28e18d655234966b7acdbd7dd13fa64d2c8d25
name: python-oemof.thermal-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for oemof.thermal
url: https://pypi.org/project/oemof.thermal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-oemof.thermal-0.0.8-1.src.rpm
location_href: Packages/python-oemof.thermal-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  The aim of oemof.thermal is to create a toolbox for building models of
  thermal energy systems. Modeling thermal energy systems requires specific preprocessing
  and postprocessing steps whose detail exceeds the generic formulation of components in
  oemof.solph. Currently, most of the functions collected here are intended to be used
  together with oemof.solph. However, in some instances they may be useful independently
  of oemof.solph.
  oemof.thermal is under active development. Contributions are welcome.


pkgId: 4b3bf2ce51b11084686119f001921cadea1e11d12abd8dac9e343001be057071
name: python-ofcli-help
arch: noarch
version: 0.6.6
epoch: 0
release: 1
summary: Development documents and examples for ofcli
url: https://gitlab.geant.org/TI_Incubator/oidcfed/ofcli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ofcli-0.6.6-1.src.rpm
location_href: Packages/python-ofcli-help-0.6.6-1.noarch.rpm
checksum_type: sha256
description:
  This work was started in and supported by the
  [Geant Trust & Identity Incubator](https://connect.geant.org/trust-and-identity-incubator).
  <img src="https://wiki.geant.org/download/attachments/120500419/incubator_logo.jpg" alt="Trust & Identity Incubator logo" height="75"/>


pkgId: c68d8bd9919409c44888b5a2f158574b04e6651e3f57d4c5541951e8427701af
name: python-ofsc-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for ofsc
url: https://github.com/btoron/pyOFSC
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ofsc-2.4.0-1.src.rpm
location_href: Packages/python-ofsc-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  20C| 1.7
  21A| 1.8, 1.8,1, 1.9
  21D| 1.15
  22B| 1.16, 1.17
  22D| 1.18
  24C| 2.0

  Starting in OFSC 2.0  all functions are called using the API name (Core or Metadata). See the examples.
  Instead of
      instance = OFSC(..)
      list_of_activities = instance.get_activities(...)
  It will be required to use the right API module:
      instance = OFSC(..)
      list_of_activites = instance.core.get_activities(...)
  During the transition period a DeprecationWarning will be raised if the functions are used in the old way

  - All metadata functions now use models, when available
  - All functions are now using the API name (Core or Metadata)
  - All functions return a python object by default. If there is an available model it will be used, otherwise a dict will be returned (see `response_type` parameter and `auto_model` parameter)
  - Errors during API calls can raise exceptions and will by default when returning an object (see `auto_raise` parameter)
  - OBJ_RESPONS and TEXT_RESPONSE are now deprecated. Use `response_type` parameter to control the response type


pkgId: 996bed9dee6fb8e513283787cd4c76f762383711bcd67a09b0c65774712d960f
name: python-oganesson-help
arch: noarch
version: 0.1.44
epoch: 0
release: 1
summary: Development documents and examples for oganesson
url: https://github.com/oganesson-ai/oganesson
rpm_license: mit
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-oganesson-0.1.44-1.src.rpm
location_href: Packages/python-oganesson-help-0.1.44-1.noarch.rpm
checksum_type: sha256
description:
  <img src="./assets/logo.svg" width="200px">



  `oganesson` (`og` for short) is a python package that enables you to apply artificial intelligence workflows to your material discovery projects.



  `og` requires the installation of the following library:

  - DGL: https://www.dgl.ai/pages/start.html

  After installing the above library, you can install `og` using the `pip` command as follows:

  `pip install oganesson`



  `og` is currently under active development. The following features are currently available.



  `og` will bring together machine learning descriptors for materials and molecules within a unified framework. `og` currently provides the following descriptors:

  - The BACD, ROSA and SymmetryFunctions introduced in this [publication](https://doi.org/10.1186/s13321-022-00658-9)
  - Most of the descriptors from [DScribe](https://github.com/SINGROUP/dscribe)

  Each descriptor has its own class, which extends the `Descriptors` class in the `oganesson.descriptors` module. Here is an example of how to describe a structure using the `BACD` and `SymmetryFunctions` descriptor classes.

  ```python
  from oganesson.descriptors import BACD, SymmetryFunctions
  from oganesson.ogstructure import OgStructure

  bacd = BACD(OgStructure(file_name='examples/structures/Li3PO4_mp-13725.cif'))
  print(bacd.describe())

  sf = SymmetryFunctions(OgStructure(file_name='examples/structures/Li3PO4_mp-13725.cif'))
  print(sf.describe())
  ```



  The main purpose of `og` is to make complex artificial intelligence workflows easy to compose. Here is an example: running a genetic search for structures, where the structure optimization is performed using the M3GNET neural network model.

  ```python
  from oganesson.genetic_algorithms import GA
  ga = GA(species=['Na']*4 + ['H']*4)
  for i in range(10):
      ga.evolve()
  ```



  The most painful part of doing transition state calculations in VASP is in building the images. The following code makes this happen in 2 lines of code. You only need to specify the structure file, and the atomic species you want to diffuse, and OgStructure will generate a folder for each path, and then write the POSCAR image files in each of these folders.

  In the following example, we explore the possible Li diffusion paths in Li3PO4, given there are 6 Li atoms in the cell.

  ```python
  from oganesson.ogstructure import OgStructure
  og = OgStructure(file_name='examples/structures/Li3PO4_mp-13725.cif')
  og.generate_neb('Li')
  ```
  Note that the default value of `r`, which is 3, is sufficient for lithium systems. However, for the case of larger atoms such as Na, a larger value of `r` would be required.



  ```python
  from oganesson.ogstructure import OgStructure
  og=OgStructure(file_name='examples/structures/MoS2.vasp')
  og.add_atom_to_surface('Li').structure.to('MoS2_Li.vasp','poscar')
  ```


pkgId: ab725fee4c3c007bcb627594a2f218fef5bb8dd74cc75151169083d37c853de2
name: python-oglio-help
arch: noarch
version: 2.3.3
epoch: 0
release: 1
summary: Development documents and examples for oglio
url: https://pypi.org/project/oglio/
rpm_license: GNU AFFERO GENERAL PUBLIC LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-oglio-2.3.3-1.src.rpm
location_href: Packages/python-oglio-help-2.3.3-1.noarch.rpm
checksum_type: sha256
description:
  I am concerned with the direction GitHub's Copilot project.
  ![](https://github.com/hasii2011/code-ally-basic/blob/master/developer/SillyGitHub.png)
  I urge you to read about the
  [Give up GitHub](https://GiveUpGitHub.org) campaign from
  [the Software Freedom Conservancy](https://sfconservancy.org).
  While I do not advocate for all the issues listed there, I do not like that
  a company like Microsoft may profit from open source projects.
  I continue to use GitHub because it offers the services I need for free.
  But I continue to monitor their terms of service.
  I do not consent to any use of this project's code by the GitHub Copilot project it is done without my permission.


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

  [![GitHub Activity][commits-shield]][commits-url]
  [![PyPi Downloads][downloads-shield]][downloads-url]
  [![GitHub Last Commit][last-commit-shield]][commits-url]
  [![Stargazers][stars-shield]][stars-url]
  [![Issues][issues-shield]][issues-url]

  [![Maintainability][maintainability-shield]][maintainability-url]
  [![Code Coverage][codecov-shield]][codecov-url]

  [![Build Status][build-shield]][build-url]
  [![Typing Status][typing-shield]][typing-url]

  Asynchronous Python client for communicating with a OJ Microline Thermostat.



  A Python package to control OJ Microline thermostats. It currently supports the WD5 series (OWD5, MWD5) and WG4 series (UWG4, AWG4).



  ```bash
  pip install ojmicroline-thermostat
  ```





  This object represents the current state of a thermostat.

  | Variable | Type | Description |
  | :------- | :--- | :---------- |
  | `model` | string | The model name for this thermostat. |
  | `serial_number` | string | The serial number for this thermostat. |
  | `software_version` | string | The currently installed software version. |
  | `zone_name` | string | The name of the zone this thermostat belongs to. |
  | `zone_id` | integer | The ID of the zone this thermostat belongs to. |
  | `name` | string | The name of the thermostat. |
  | `online` | boolean | Indicates if the thermostat is connected to the network. |
  | `heating` | boolean | Indicates if the thermostat is currently heating/is on. |
  | `regulation_mode` | integer | The currently set regulation mode of the thermostat, see below. |
  | `supported_regulation_modes` | list | The regulation modes this thermostat supports. |
  | `min_temperature` | integer | The lowest temperature the thermostat can be set to. |
  | `max_temperature` | integer | The highest temperature the thermostat can be set to. |
  | `manual_temperature` | integer | If the regulation mode is set to manual mode, the thermostat will target this temperature. |
  | `comfort_temperature` | integer | If the regulation mode is set to comfort mode, the thermostat will target this temperature. |
  | `comfort_end_time` | datetime | If the regulation mode is set to comfort mode, it will end at this time. |
  | `vacation_mode` | boolean | If true then the thermostat is set to `vacation_temperature` from `vacation_begin_time` to `vacation_end_time`. If false, then no vacation is in progress or scheduled. |
  | `vacation_temperature` | integer | If the regulation mode is VACATION, the thermostat will target this temperature. |
  | `vacation_begin_time` | datetime | The vacation regulation mode will begin at this time. Note that vacations may be scheduled to begin in the future. |
  | `vacation_end_time` | datetime | If in vacation mode, the thermostat will return to schedule mode at this time. |
  | `last_primary_mode_is_auto` | boolean | Unknown |

  These fields are only available on WD5-series thermostats; for others, they may be `None`:

  | Variable | Type | Description |
  | :------- | :--- | :---------- |
  | `thermostat_id` | int | The unique identifier for this thermostat. |
  | `adaptive_mode` | boolean | If on then then the thermostat automatically changes heating start times to ensure that the required temperature has been reached at the beginning of any specific event. |
  | `open_window_detection` | boolean | If on then the thermostat shuts off the heating for 30 minutes if an open window is detected. |
  | `daylight_saving_active` | boolean | If on, the "Daylight Saving Time" function of the thermostat will automatically adjust the clock to the daylight saving time for the "Region" chosen. |
  | `sensor_mode` | integer | The currently set sensor mode of the thermostat, see below. |
  | `temperature_floor` | integer | The temperature measured by the floor sensor. |
  | `temperature_room` | integer | The temperature measured by the room sensor. |
  | `boost_temperature` | integer | If the regulation mode is set to boost mode, the thermostat will target this temperature. |
  | `boost_end_time` | datetime | If the regulation mode is set to boost mode, it will end at this time. |
  | `frost_protection_temperature` | integer | If the regulation mode is set to frost protection mode, the thermostat will target this temperature. |
  | `schedule` | Schedule | The schedule the thermostat currently uses. (This *could* be supported by WG4-series thermostats, it simply isn't implemented.) |

  These fields are only available on WG4-series thermostats; for others, they may be `None`:

  | Variable | Type | Description |
  | :------- | :--- | :---------- |
  | `temperature` | integer | The current temperature; the thermostat uses the room sensor or floor sensor based on its configuration. Avoid using this directly; instead, call the `get_current_temperature()` method which also works for WD5-series thermostats. |
  | `set_point_temperature` | integer | The temperature the thermostat is targeting. Avoid using this directly; instead, call the `get_target_temperature()` method which also works for WD5-series thermostats. |



  | Integer | Constant | Description |
  | :------- | :--- | :---------- |
  | `1` | `REGULATION_SCHEDULE` | The thermostat follows the configured schedule. |
  | `2` | `REGULATION_COMFORT` | The thermostat is in comfort mode until `comfort_end_time`. |
  | `3` | `REGULATION_MANUAL` | The thermostat is in manual mode, will not resume schedule unless changed. |
  | `4` | `REGULATION_VACATION` | The thermostat is in vacation mode, it started at `vacation_begin_time` and ends at `vacation_end_time`. |
  | `6` | `REGULATION_FROST_PROTECTION` | The thermostat is set to frost protection, preventing the floor from freezing. |
  | `8` | `REGULATION_BOOST` | The thermostat is in boost mode for 1 hour, using the `max_temperature` as target temperature. |
  | `9` | `REGULATION_ECO` | The thermostat is in eco mode, using the lowest temperature of the `schedule`. |

  Keep in mind that certain thermostats only support a subset of these modes; be sure to check the `Thermostat.supported_regulation_modes` field.



  | Integer | Constant | Description |
  | :------- | :--- | :---------- |
  | `1` | `SENSOR_ROOM_FLOOR` | The thermostat takes the average of the room and floor temperature |
  | `3` | `SENSOR_FLOOR` | The thermostat is using the floor sensor for target temperature. |
  | `4` | `SENSOR_ROOM` | The thermostat is using the room sensor for target temperature. |




  | Method | Params | Description |
  | :------- | :--- | :---------- |
  | `login` | `None` | Create a new session at the OJ Microline API. |
  | `get_thermostats` | `None` | Get all thermostats from the OJ Microline API. |
  | `set_regulation_mode` | `resource: Thermostat`, `regulation_mode: int`, `temperature: int \| None = None`, `duration: int = COMFORT_DURATION` | Set the regulation mode based on the input.<br> - `resource`: An instance of a Thermostat model returned by `get_thermostats()`<br> - `regulation_mode`: An integer representing the regulation mode, see "Regulation modes"<br> - `temperature`: An integer representing the temperature, eg: 2500. Only useful when setting the regulation mode to manual or comfort.<br> - `duration`: The duration in minutes to set the temperature for; only applies to comfort mode. |



  ```python
  import asyncio
  from time import sleep

  from ojmicroline_thermostat import OJMicroline, Thermostat, WD5API
  from ojmicroline_thermostat.const import (
      REGULATION_BOOST,
      REGULATION_COMFORT,
      REGULATION_ECO,
      REGULATION_FROST_PROTECTION,
      REGULATION_MANUAL,
      REGULATION_SCHEDULE,
      REGULATION_VACATION,
  )

  REGULATION_MODES = {
      REGULATION_SCHEDULE: "Schedule",
      REGULATION_ECO: "Eco",
      REGULATION_MANUAL: "None (Manual)",
      REGULATION_FROST_PROTECTION: "Frost Protection",
      REGULATION_BOOST: "Boost",
      REGULATION_COMFORT: "Comfort",
      REGULATION_VACATION: "Vacation",
  }


  async def main():
      """Show example on using the OJMicroline client."""
      async with OJMicroline(
          api=WD5API(
              customer_id=1234,
              api_key="<app-api-key>",
              username="<your-username>",
              password="<your-password>",
          ),
      ) as client:
          
          thermostats: list[Thermostat] = await client.get_thermostats()

          for resource in thermostats:
              print("####################")
              print(f"# {resource.name}")
              print("####################")
              print("- Details:")
              print(f"   Serial Number: {resource.serial_number}")
              print(f"   Mode: {REGULATION_MODES[resource.regulation_mode]}")
              print(f"   Temperature: {resource.get_current_temperature()}")
              print(f"   Target temperature: {resource.get_target_temperature()}")
              print("")

              print(f"- Setting to boost mode")
              await client.set_regulation_mode(resource, REGULATION_BOOST)
              print("Sleeping for 5 seconds..")
              sleep(5)
              print(f"- Setting to schedule")  # noqa: E501
              await client.set_regulation_mode(resource, REGULATION_SCHEDULE)


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



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

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

  Thank you for being involved! :heart_eyes:



  This Python project is fully managed using the [Poetry][poetry] dependency
  manager.

  You need at least:

  - Python 3.11+
  - [Poetry][poetry-install]

  Install all packages, including all development requirements:

  ```bash
  poetry install
  ```

  Poetry creates by default an virtual environment where it installs all
  necessary pip packages, to enter or exit the venv run the following commands:

  ```bash
  poetry shell
  exit
  ```

  Setup the pre-commit check, you must run this inside the virtual environment:

  ```bash
  pre-commit install
  ```

  *Now you're all set to get started!*

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

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

  To run just the Python tests:

  ```bash
  poetry run pytest
  ```



  MIT License

  Copyright (c) 2020-2024 Robbin Janssen

  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.

  <!-- MARKDOWN LINKS & IMAGES -->
  [build-shield]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/actions/workflows/tests.yaml/badge.svg
  [build-url]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/actions/workflows/tests.yaml
  [commits-shield]: https://img.shields.io/github/commit-activity/y/robbinjanssen/python-ojmicroline-thermostat.svg
  [commits-url]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/commits/main
  [codecov-shield]: https://codecov.io/gh/robbinjanssen/python-ojmicroline-thermostat/branch/main/graph/badge.svg?token=F6CE1S25NV
  [codecov-url]: https://codecov.io/gh/robbinjanssen/python-ojmicroline-thermostat
  [downloads-shield]: https://img.shields.io/pypi/dm/ojmicroline-thermostat
  [downloads-url]: https://pypistats.org/packages/ojmicroline-thermostat
  [issues-shield]: https://img.shields.io/github/issues/robbinjanssen/python-ojmicroline-thermostat.svg
  [issues-url]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/issues
  [license-shield]: https://img.shields.io/github/license/robbinjanssen/python-ojmicroline-thermostat.svg
  [last-commit-shield]: https://img.shields.io/github/last-commit/robbinjanssen/python-ojmicroline-thermostat.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2024.svg
  [maintainability-shield]: https://api.codeclimate.com/v1/badges/d77f7409eb02e331261b/maintainability
  [maintainability-url]: https://codeclimate.com/github/robbinjanssen/python-ojmicroline-thermostat/maintainability
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-experimental-yellow.svg
  [pypi]: https://pypi.org/project/ojmicroline-thermostat/
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/ojmicroline-thermostat
  [typing-shield]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/actions/workflows/typing.yaml/badge.svg
  [typing-url]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/actions/workflows/typing.yaml
  [releases-shield]: https://img.shields.io/github/release/robbinjanssen/python-ojmicroline-thermostat.svg
  [releases]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/releases
  [stars-shield]: https://img.shields.io/github/stars/robbinjanssen/python-ojmicroline-thermostat.svg
  [stars-url]: https://github.com/robbinjanssen/python-ojmicroline-thermostat/stargazers

  [poetry-install]: https://python-poetry.org/docs/#installation
  [poetry]: https://python-poetry.org
  [pre-commit]: https://pre-commit.com


pkgId: 3188f9468dfecd5619c2cf3a0df5e2f78b5514d1dd5a0d09e9c1b80cdd010cb5
name: python-okerrupdate-help
arch: noarch
version: 2.0.14
epoch: 0
release: 1
summary: Development documents and examples for okerrupdate
url: https://github.com/yaroslaff/okerrupdate
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-okerrupdate-2.0.14-1.src.rpm
location_href: Packages/python-okerrupdate-help-2.0.14-1.noarch.rpm
checksum_type: sha256
description:
  ```shell

  sudo pipx install okerrupdate


  sudo pip3 install okerrupdate


  sudo okerrmod --init # enable few basic modules, create /etc/cron.d/ job, create okerrupdate config template
  sudo vim /etc/okerr/okerrupdate
  ```

  and modify okerrupdate file:
  ~~~

  PREFIX=braconnier:
  OKERR_TEXTID=
  OKERR_SECRET=
  OKERR_URL=
  OKERR_DIRECT=0

  OKERR_MOD_AVAIL=
  ~~~
  or provide values to `okerrmod --init` as option values (e.g. `okerrmod --init --textid MyTextid`).






  okerrupdate is small script which updates/creates indicators in okerr project.

  This will create simplest indicator 'myindicator' with all default settings (type 'heartbeat', policy 'Default').
  Indicator will send alert if it will be updated to 'ERR' or if will not be updated for some time
  (Default policy period+patience).
  ```shell
  $ okerrupdate myindicator OK
  okerr updated (200 OK) myindicator@okerr = OK
  ```

  This will create numerical indicator 'temp' with current value 36.6, and policy 'Daily'. Will send alert if not updated
  for a day or if value will be over maxlim (37).
  ```shell
  $ okerrupdate -p Daily -m 'numerical|maxlim=37' temp 36.6
  okerr updated (200 OK) temp@okerr = 36.6
  ```

  Project TextID and secret is read from `/etc/okerr/okerrupdate` file or `OKERR_TEXTID` and `OKERR_SECRET` environment
  variables.



  okerrmod is script to perform different local checks (such as free disk space, mysql running, load average, etc.). After initial `okerrmod --init`, few basic check modules
  are enabled.

  List all available check modules (`+` - module enabled, `-` - module disabled ):
  ```shell
  $ okerrmod --list
  + backups 0.1 Check freshness for backup files
  + df 0.1 Free disk space
  ...
  ```

  To run enabled checks just run `okerrmod` without any other commands:
  ```shell
  xenon@braconnier:~$ sudo okerrmod
  okerr updated (200 OK) braconnier:maxfilesz@okerr = 9077814
  okerr updated (200 OK) braconnier:apache@okerr = 0
  okerr updated (200 OK) braconnier:nonempty@okerr = 0
  okerr updated (200 OK) braconnier:empty@okerr = 0
  ...
  ```

  To run just one check:
  ```shell
  $ sudo okerrmod --run ok
  okerr updated (200 OK) braconnier:ok@okerr = OK
  ```

  To enable new check:
  ```shell
  $ sudo okerrmod --enable runstatus
  2020/01/17 16:12:30 enable /usr/local/lib/python3.7/dist-packages/okerrupdate/mods-available/runstatus
  2020/01/17 16:12:30 make default config file: /etc/okerr/mods-env/runstatus

  ```

  After this, you may want to edit default configuration for this check
  ```shell
  sudo vim /etc/okerr/mods-env/runstatus
  ```

  After this, `okerrmod` will run this check.

  To create your own very basic check 'my' create dir `/etc/okerr/mods-available/my` and edit `/etc/okerr/mods-available/my/check`:
  ```shell

  print("STATUS: OK")
  ```
  or if you prefer shell (check is any executable file):
  ```shell

  echo STATUS: OK
  ```

  Now you can run it manually `okerrmod --run my`, enable `okerrmod --enable my`, make/edit config file for it
  `/etc/okerr/mods-env/my`.


  Simplest case:
  ```python

  import okerrupdate

  op = okerrupdate.OkerrProject('MyTextID', secret='MySecret')
  i = op.indicator('temp', method='numerical|maxlim=37', policy='Daily')
  i.update('36.6')
  ```


  More info in [okerrupdate documentation](https://okerrupdate.readthedocs.io/).


  - [Okerr main website](https://okerr.com/)
  - [Okerr-server source code repository](https://github.com/yaroslaff/okerr-dev/)
  - [Okerr client (okerrupdate) repositoty](https://github.com/yaroslaff/okerrupdate) and [okerrupdate documentation](https://okerrupdate.readthedocs.io/)
  - [Okerrbench network server benchmark](https://github.com/yaroslaff/okerrbench)
  - [Okerr custom status page](https://github.com/yaroslaff/okerr-status)
  - [Okerr JS-powered static status page](https://github.com/yaroslaff/okerrstatusjs)
  - [Okerr network sensor](https://github.com/yaroslaff/sensor)


pkgId: 34d3a94a5a53095d3f68189d9359036f03e4436cfb8b98e56f3107c9cd9375f7
name: python-okmodule-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for okmodule
url: https://github.com/lawley0316/okmodule
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-okmodule-1.1.0-1.src.rpm
location_href: Packages/python-okmodule-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ```shell
  pip install okmodule
  ```





  ```python
  from okmodule import Module


  class MyModule(Module):
      def __init__(self, x, y):
          self.x = x
          self.y = y

      def main(self):
          self.log(f'Calculating, x = {self.x}, y = {self.y}')
          return self.x + self.y


  result1 = MyModule(1, 2)()  # invoke directly
  my_module = MyModule(3, 4)  # create Module object
  result2 = my_module()  # invoke module
  ```



  ```python
  from okmodule import Option, Flag, Command


  class Blastn(Command):
      query = Option('-query')
      db = Option('-db')
      outfmt = Option('-outfmt')
      num_threads = Option('-num_threads')
      out = Option('-out')
      help = Flag('-help')


  Blastn(help=True)()


  blastn = Blastn(query='test/query.fa', db='test/db/test', outfmt=6, num_threads=6, out='test/result.txt')
  blastn()
  ```


pkgId: 541ac2b07bc953fb934179cbde6dd8a00f42c3cb37c7d21a464b056d47344d73
name: python-okmodule-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for okmodule
url: https://github.com/lawley0316/okmodule
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-okmodule-1.2.0-1.src.rpm
location_href: Packages/python-okmodule-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ```shell
  pip install okmodule
  ```





  ```python
  from okmodule import Module


  class MyModule(Module):
      def __init__(self, x, y):
          self.x = x
          self.y = y

      def main(self):
          self.log(f'Calculating, x = {self.x}, y = {self.y}')
          return self.x + self.y


  result1 = MyModule(1, 2)()  # invoke directly
  my_module = MyModule(3, 4)  # create Module object
  result2 = my_module()  # invoke module
  ```



  ```python
  from okmodule import Argument, Option, Flag, Command



  class Fastqc(Command):
      outdir = Option('--outdir')
      threads = Option('--threads')
      extract = Flag('--extract')
      seqfile = Argument()



  class SamtoolsView(Command):
      bam = Flag('-b')
      min_mq = Option('-q')
      threads = Option('-@')
      output = Option('-o')
      input = Argument()



  fastqc = Fastqc(
      outdir='xxx',
      threads=4,
      extract=True,
      seqfile='xxx',
  )
  fastqc()


  samtools_view = SamtoolsView(
      bam=True,
      min_mq=60,
      threads=4,
      output='xxx',
      input='xxx'
  )
  samtools_view()
  ```


pkgId: 3022a648c5d1bb28ee201e7877f0edebe54a1c269c780253cd0e1c94f30b9835
name: python-olca-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for olca
url: https://github.com/jgwill/olca
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-olca-0.2.5-1.src.rpm
location_href: Packages/python-olca-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  oLCa is a Python package that provides a CLI tool for Experimenting Langchain with OpenAI wrapper around interacting thru the human-in-the-loop tool.






  To install the package, you can use pip:

  ```bash
  pip install olca
  ```








  To see the available commands and options, use the `--help` flag:

  ```bash
  olca --help
  ```

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


pkgId: c0f62bde1751fc4104e6326b636b38f70e43331333cc78c49b6c0cdf6159064c
name: python-olevester-transform-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for olevester-transform
url: https://github.com/ANTHONY-OLEVESTER/Olevester-Transformer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-olevester-transform-0.1.0-1.src.rpm
location_href: Packages/python-olevester-transform-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The Olevester Transform is a Python library for dimensional navigation, normalization, and stabilization. It provides tools to handle multidimensional fields and analyze contributions across dimensions.


  - Normalize multidimensional fields.
  - Navigate dimensions with expansion and reduction.
  - Apply Fourier-based normalization for periodic systems.


  pip install olevester-transform


  ```python
  from olevester_transform import OlevesterTransform
  ```



  Use a license like MIT:
  ```text
  MIT License
  Copyright (c) 2024 Anthony Olevester

  \x00
  \x00


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

  ```console
  pip install ollama-haystack
  ```

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

  To run tests first start a Docker container running Ollama and pull a model for integration testing
  It's recommended to use the smallest model possible for testing purposes - see https://ollama.ai/library for a list that Ollama supportd
  ```console
  docker run -d -p 11434:11434 --name ollama ollama/ollama:latest
  docker exec ollama ollama pull <your model here>
  ```
  Then run tests:
  ```console
  hatch run test
  ```
  The default model used here is ``orca-mini`` for generation and ``nomic-embed-text`` for embeddings


pkgId: cb71293c2ebd82048fd53bcdc2aa69eba0d8b9e7566639912a122593e5e206f0
name: python-ollama-manager-help
arch: noarch
version: 0.0.11
epoch: 0
release: 1
summary: Development documents and examples for ollama-manager
url: https://pypi.org/project/ollama-manager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ollama-manager-0.0.11-1.src.rpm
location_href: Packages/python-ollama-manager-help-0.0.11-1.noarch.rpm
checksum_type: sha256
description:
  **Run models in a Streamlit UI:**
  <details>
  <summary>Ollama Manager UI</summary>
  <img src="https://i.imgur.com/UqQLjXx.gif" width="800" />
  </details>
  You need to install optional dependencies for this:
  ```sh
  pip install ollama-manager[ui]
  ```
  then use the following command to select the model:
  ```sh

  olm run -ui text

  olm run -ui vision
  ```

  ```sh
  olm --help
  olm <sub-command> --help
  ```


pkgId: 42ce45b83fe0037a03225e059f7a5fd6a8d92813e5bb694a14b93cf0b06de6b9
name: python-omegavit-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for omegavit
url: https://github.com/Agora-Lab-AI/OmegaViT
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omegavit-0.0.1-1.src.rpm
location_href: Packages/python-omegavit-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Join our Discord](https://img.shields.io/badge/Discord-Join%20our%20server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/agora-999382051935506503) [![Subscribe on YouTube](https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/@kyegomez3242) [![Connect on LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/kye-g-38759a207/) [![Follow on X.com](https://img.shields.io/badge/X.com-Follow-1DA1F2?style=for-the-badge&logo=x&logoColor=white)](https://x.com/kyegomezb)




  [![PyPI version](https://badge.fury.io/py/omegavit.svg)](https://badge.fury.io/py/omegavit)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Build Status](https://github.com/Agora-Lab-AI/OmegaViT/workflows/build/badge.svg)](https://github.com/Agora-Lab-AI/OmegaViT/actions)
  [![Documentation Status](https://readthedocs.org/projects/omegavit/badge/?version=latest)](https://omegavit.readthedocs.io/en/latest/?badge=latest)

  OmegaViT (ΩViT) is a cutting-edge vision transformer architecture that combines multi-query attention, rotary embeddings, state space modeling, and mixture of experts to achieve superior performance across various computer vision tasks. The model can process images of any resolution while maintaining computational efficiency.



  - **Flexible Resolution Processing**: Handles arbitrary input image sizes through adaptive patch embedding
  - **Multi-Query Attention (MQA)**: Reduces computational complexity while maintaining model expressiveness
  - **Rotary Embeddings**: Enables better modeling of relative positions and spatial relationships
  - **State Space Models (SSM)**: Integrates efficient sequence modeling every third layer
  - **Mixture of Experts (MoE)**: Implements conditional computation for enhanced model capacity
  - **Comprehensive Logging**: Built-in loguru integration for detailed execution tracking
  - **Shape-Aware Design**: Continuous tensor shape tracking for reliable processing



  ```mermaid
  flowchart TB
      subgraph Input
          img[Input Image]
      end

      subgraph PatchEmbed[Flexible Patch Embedding]
          conv[Convolution]
          norm1[LayerNorm]
          conv --> norm1
      end

      subgraph TransformerBlocks[Transformer Blocks x12]
          subgraph Block1[Block n]
              direction TB
              mqa[Multi-Query Attention]
              ln1[LayerNorm]
              moe1[Mixture of Experts]
              ln2[LayerNorm]
              ln1 --> mqa --> ln2 --> moe1
          end

          subgraph Block2[Block n+1]
              direction TB
              mqa2[Multi-Query Attention]
              ln3[LayerNorm]
              moe2[Mixture of Experts]
              ln4[LayerNorm]
              ln3 --> mqa2 --> ln4 --> moe2
          end

          subgraph Block3[Block n+2 SSM]
              direction TB
              ssm[State Space Model]
              ln5[LayerNorm]
              moe3[Mixture of Experts]
              ln6[LayerNorm]
              ln5 --> ssm --> ln6 --> moe3
          end
      end

      subgraph Output
          gap[Global Average Pooling]
          classifier[Classification Head]
      end

      img --> PatchEmbed --> TransformerBlocks --> gap --> classifier
  ```



  ```mermaid
  flowchart LR
      input[Input Features]

      subgraph MQA[Multi-Query Attention]
          direction TB
          q[Q Linear]
          k[K Linear]
          v[V Linear]
          rotary[Rotary Embeddings]
          attn[Attention Weights]

          input --> q & k & v
          q & k --> rotary
          rotary --> attn
          attn --> v
      end

      MQA --> output[Output Features]

  ```



  ```bash
  pip install omegavit
  ```



  ```python
  import torch
  from omegavit import create_advanced_vit


  model = create_advanced_vit(num_classes=1000)


  batch_size = 8
  x = torch.randn(batch_size, 3, 224, 224)
  output = model(x)
  print(f"Output shape: {output.shape}")  # [8, 1000]
  ```



  | Parameter | Default | Description |
  |-----------|---------|-------------|
  | hidden_size | 768 | Dimension of transformer layers |
  | num_attention_heads | 12 | Number of attention heads |
  | num_experts | 8 | Number of expert networks in MoE |
  | expert_capacity | 32 | Tokens per expert in MoE |
  | num_layers | 12 | Number of transformer blocks |
  | patch_size | 16 | Size of image patches |
  | ssm_state_size | 16 | Hidden state size in SSM |



  *Note: Benchmarks coming soon*



  If you use OmegaViT in your research, please cite:

  ```bibtex
  @article{omegavit2024,
    title={OmegaViT: A State-of-the-Art Vision Transformer with Multi-Query Attention, State Space Modeling, and Mixture of Experts},
    author={Agora Lab},
    journal={arXiv preprint arXiv:XXXX.XXXXX},
    year={2024}
  }
  ```



  We welcome contributions! Please see our [contributing guidelines](CONTRIBUTING.md) for details.



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



  Special thanks to the Agora Lab AI team and the open-source community for their valuable contributions and feedback.


pkgId: 1a2d455fbabb569bd2c82b2c1163efab4a4b56710c3ae9bff607f60b267b4320
name: python-omero-figure-help
arch: noarch
version: 7.2.0
epoch: 0
release: 1
summary: Development documents and examples for omero-figure
url: https://github.com/ome/omero-figure
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omero-figure-7.2.0-1.src.rpm
location_href: Packages/python-omero-figure-help-7.2.0-1.noarch.rpm
checksum_type: sha256
description:
  An OMERO.web app for creating figures from images in OMERO.
  For full details see `SUPPORT.md <https://github.com/ome/omero-figure/blob/master/SUPPORT.md>`_.


pkgId: 5f3a75a20542c5a12425b57822328b2756b9cee60f35b1f6c77e091e7cd5449a
name: python-omero-scripts-help
arch: noarch
version: 5.9.0
epoch: 0
release: 1
summary: Development documents and examples for omero-scripts
url: https://github.com/ome/omero-scripts/
rpm_license: GPL-2.0+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omero-scripts-5.9.0-1.src.rpm
location_href: Packages/python-omero-scripts-help-5.9.0-1.noarch.rpm
checksum_type: sha256
description:
  This directory contains OMERO scripts which use the
  OMERO.scripts API. All scripts (e.g. ``*.py``) present in the
  directory will be automatically distributed with all binary
  builds. Which file-endings will be detected and how they
  will be launched are both configured centrally in the server.
  ``.py``, ``.jy``, and ``.m`` (MATLAB) files should all be detected
  by default starting with OMERO 5.


pkgId: b8745487d90840da9836cb639bc514529252aa76eb11547faa6bd13d7a9dad78
name: python-omicverse-help
arch: noarch
version: 1.6.9
epoch: 0
release: 1
summary: Development documents and examples for omicverse
url: https://pypi.org/project/omicverse/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omicverse-1.6.9-1.src.rpm
location_href: Packages/python-omicverse-help-1.6.9-1.noarch.rpm
checksum_type: sha256
description:
  The table contains the tools have been published
  <div align="center">
  <table>
    <tr>
      <td align="center">Scanpy<br><a href="https://github.com/scverse/scanpy">📦</a> <a href="https://link.springer.com/article/10.1186/s13059-017-1382-0">📖</a></td>
      <td align="center">dynamicTreeCut<br><a href="https://github.com/kylessmith/dynamicTreeCut">📦</a> <a href="https://academic.oup.com/bioinformatics/article/24/5/719/200751">📖</a></td>
      <td align="center">scDrug<br><a href="https://github.com/ailabstw/scDrug">📦</a> <a href="https://www.sciencedirect.com/science/article/pii/S2001037022005505">📖</a></td>
      <td align="center">MOFA<br><a href="https://github.com/bioFAM/mofapy2">📦</a> <a href="https://genomebiology.biomedcentral.com/articles/10.1186/s13059-020-02015-1">📖</a></td>
      <td align="center">COSG<br><a href="https://github.com/genecell/COSG">📦</a> <a href="https://academic.oup.com/bib/advance-article-abstract/doi/10.1093/bib/bbab579/6511197?redirectedFrom=fulltext">📖</a></td>
      <td align="center">CellphoneDB<br><a href="https://github.com/ventolab/CellphoneDB">📦</a> <a href="https://www.nature.com/articles/s41586-018-0698-6">📖</a></td>
      </tr>
    <tr>
      <td align="center">AUCell<br><a href="https://github.com/aertslab/AUCell">📦</a> <a href="https://bioconductor.org/packages/AUCell">📖</a></td>
      <td align="center">Bulk2Space<br><a href="https://github.com/ZJUFanLab/bulk2space">📦</a> <a href="https://www.nature.com/articles/s41467-022-34271-z">📖</a></td>
      <td align="center">SCSA<br><a href="https://github.com/bioinfo-ibms-pumc/SCSA">📦</a> <a href="https://doi.org/10.3389/fgene.2020.00490">📖</a></td>
      <td align="center">WGCNA<br><a href="http://www.genetics.ucla.edu/labs/horvath/CoexpressionNetwork/Rpackages/WGCNA">📦</a> <a href="https://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-9-559">📖</a></td>
      <td align="center">VIA<br><a href="https://github.com/ShobiStassen/VIA">📦</a> <a href="https://www.nature.com/articles/s41467-021-25773-3">📖</a></td>
      <td align="center">pyDEseq2<br><a href="https://github.com/owkin/PyDESeq2">📦</a> <a href="https://www.biorxiv.org/content/10.1101/2022.12.14.520412v1">📖</a></td>
  </tr>
    <tr>
      <td align="center">NOCD<br><a href="https://github.com/shchur/overlapping-community-detection">📦</a> <a href="https://arxiv.org/abs/1909.12201">📖</a></td>
      <td align="center">SIMBA<br><a href="https://github.com/pinellolab/simba">📦</a> <a href="https://www.nature.com/articles/s41592-023-01899-8">📖</a></td>
      <td align="center">GLUE<br><a href="https://github.com/gao-lab/GLUE">📦</a> <a href="https://www.nature.com/articles/s41587-022-01284-4">📖</a></td>
      <td align="center">MetaTiME<br><a href="https://github.com/yi-zhang/MetaTiME">📦</a> <a href="https://www.nature.com/articles/s41467-023-38333-8">📖</a></td>
      <td align="center">TOSICA<br><a href="https://github.com/JackieHanLab/TOSICA">📦</a> <a href="https://doi.org/10.1038/s41467-023-35923-4">📖</a></td>
      <td align="center">Harmony<br><a href="https://github.com/slowkow/harmonypy/">📦</a> <a href="https://www.nature.com/articles/s41592-019-0619-0">📖</a></td>
    </tr>
    <tr>
      <td align="center">Scanorama<br><a href="https://github.com/brianhie/scanorama">📦</a> <a href="https://www.nature.com/articles/s41587-019-0113-3">📖</a></td>
      <td align="center">Combat<br><a href="https://github.com/epigenelabs/pyComBat/">📦</a> <a href="https://doi.org/10.1101/2020.03.17.995431">📖</a></td>
      <td align="center">TAPE<br><a href="https://github.com/poseidonchan/TAPE">📦</a> <a href="https://doi.org/10.1038/s41467-022-34550-9">📖</a></td>
      <td align="center">SEACells<br><a href="https://github.com/dpeerlab/SEACells">📦</a> <a href="https://www.nature.com/articles/s41587-023-01716-9">📖</a></td>
      <td align="center">Palantir<br><a href="https://github.com/dpeerlab/Palantir">📦</a> <a href="https://doi.org/10.1038/s41587-019-0068-49">📖</a></td>
      <td align="center">STAGATE<br><a href="https://github.com/QIFEIDKN/STAGATE_pyG">📦</a> <a href="https://www.nature.com/articles/s41467-022-29439-6">📖</a></td>
    </tr>
    <tr>
      <td align="center">scVI<br><a href="https://github.com/scverse/scvi-tools">📦</a> <a href="https://doi.org/10.1038/s41587-021-01206-w">📖</a></td>
      <td align="center">MIRA<br><a href="https://github.com/cistrome/MIRA">📦</a> <a href="https://www.nature.com/articles/s41592-022-01595-z">📖</a></td>
      <td align="center">Tangram<br><a href="https://github.com/broadinstitute/Tangram/">📦</a> <a href="https://www.nature.com/articles/s41592-021-01264-7">📖</a></td>
      <td align="center">STAligner<br><a href="https://github.com/zhoux85/STAligner">📦</a> <a href="https://doi.org/10.1038/s43588-023-00528-w">📖</a></td>
      <td align="center">CEFCON<br><a href="https://github.com/WPZgithub/CEFCON">📦</a> <a href="https://www.nature.com/articles/s41467-023-44103-3">📖</a></td>
      <td align="center">PyComplexHeatmap<br><a href="https://github.com/DingWB/PyComplexHeatmap">📦</a> <a href="https://doi.org/10.1002/imt2.115">📖</a></td>
        </tr>
    <tr>
      <td align="center">STT<br><a href="https://github.com/cliffzhou92/STT/">📦</a> <a href="https://www.nature.com/articles/s41592-024-02266-x#Sec2">📖</a></td>
      <td align="center">SLAT<br><a href="https://github.com/gao-lab/SLAT">📦</a> <a href="https://www.nature.com/articles/s41467-023-43105-5">📖</a></td>
      <td align="center">GPTCelltype<br><a href="https://github.com/Winnie09/GPTCelltype">📦</a> <a href="https://www.nature.com/articles/s41592-024-02235-4">📖</a></td>
      <td align="center">PROST<br><a href="https://github.com/Tang-Lab-super/PROST">📦</a> <a href="https://doi.org/10.1038/s41467-024-44835-w">📖</a></td>
      <td align="center">CytoTrace2<br><a href="https://github.com/digitalcytometry/cytotrace2">📦</a> <a href="https://doi.org/10.1101/2024.03.19.585637">📖</a></td>
      <td align="center">GraphST<br><a href="https://github.com/JinmiaoChenLab/GraphST">📦</a> <a href="https://www.nature.com/articles/s41467-023-36796-3#citeas">📖</a></td>
    </tr>
    <tr>
      <td align="center">COMPOSITE<br><a href="https://github.com/CHPGenetics/COMPOSITE/">📦</a> <a href="https://www.nature.com/articles/s41467-024-49448-x#Abs1">📖</a></td>
      <td align="center">mellon<br><a href="https://github.com/settylab/mellon">📦</a> <a href="https://www.nature.com/articles/s41592-024-02302-w">📖</a></td>
      <td align="center">starfysh<br><a href="https://github.com/azizilab/starfysh">📦</a> <a href="http://dx.doi.org/10.1038/s41587-024-02173-8">📖</a></td>
      <td align="center">COMMOT<br><a href="https://github.com/zcang/COMMOT">📦</a> <a href="https://www.nature.com/articles/s41592-022-01728-4">📖</a></td>
      <td align="center">flowsig<br><a href="https://github.com/axelalmet/flowsig">📦</a> <a href="https://doi.org/10.1038/s41592-024-02380-w">📖</a></td>
      <td align="center">pyWGCNA<br><a href="https://github.com/mortazavilab/PyWGCNA">📦</a> <a href="https://doi.org/10.1093/bioinformatics/btad415">📖</a></td>
    </tr>
    <tr>
      <td align="center">CAST<br><a href="https://github.com/wanglab-broad/CAST">📦</a> <a href="https://www.nature.com/articles/s41592-024-02410-7">📖</a></td>
      <td align="center">scMulan<br><a href="https://github.com/SuperBianC/scMulan">📦</a> <a href="https://link.springer.com/chapter/10.1007/978-1-0716-3989-4_57">📖</a></td>
      <td align="center">cellANOVA<br><a href="https://github.com/Janezjz/cellanova">📦</a> <a href="https://www.nature.com/articles/s41587-024-02463-1">📖</a></td>
    </tr>
  </table>


pkgId: d450fc763fea1683ba787fed04a79ac40f82d1be13d93a4b3a8ad90f84098a2a
name: python-omlt-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for omlt
url: https://pypi.org/project/omlt/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omlt-1.2.1-1.src.rpm
location_href: Packages/python-omlt-help-1.2.1-1.noarch.rpm
checksum_type: sha256
rpm_license:
  ================= Copyright Notice =================  Copyright 2021 National Technology & Engineering Solutions of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights in this software.  Copyright (c) 2021, C⚙G - Imperial College London All rights reserved.  Copyright (c) 2021, Carnegie Mellon University (Author: Carl Laird) All rights reserved.  Revised BSD License -------------------  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Sandia National Laboratories, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 2892c15cbc5bb0c76557fd3f79230ada4fce40d43435d251ce252ece21845f29
name: python-ommx-pyscipopt-adapter-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for ommx-pyscipopt-adapter
url: https://pypi.org/project/ommx-pyscipopt-adapter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ommx-pyscipopt-adapter-1.5.1-1.src.rpm
location_href: Packages/python-ommx-pyscipopt-adapter-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  This package provides an adapter for the [SCIP](https://www.scipopt.org/) from [OMMX](https://github.com/Jij-Inc/ommx)



  `ommx-pyscipopt-adapter` can be installed from PyPI as follows:

  ```bash
  pip install ommx-pyscipopt-adapter
  ```

  SCIP can be used through `ommx-pyscipopt-adapter` by using the following:

  ```python markdown-code-runner
  import ommx_pyscipopt_adapter as adapter
  from ommx.v1 import Instance, DecisionVariable

  x1 = DecisionVariable.integer(1, lower=0, upper=5)
  ommx_instance = Instance.from_components(
      decision_variables=[x1],
      objective=x1,
      constraints=[],
      sense=Instance.MINIMIZE,
  )


  model = adapter.instance_to_model(ommx_instance)
  model.optimize()

  ommx_state = adapter.model_to_state(model, ommx_instance)

  print(ommx_state)
  ```



  TBW


pkgId: 3eb29e1073464a820e5547e54d4cb9d4ee9c47b42865ca9e6a32adff7a4e4bb8
name: python-ommx-python-mip-adapter-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for ommx-python-mip-adapter
url: https://pypi.org/project/ommx-python-mip-adapter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ommx-python-mip-adapter-1.5.1-1.src.rpm
location_href: Packages/python-ommx-python-mip-adapter-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/ommx-python-mip-adapter)](https://pypi.org/project/ommx-python-mip-adapter/)
  This package provides an adapter for the [Python-MIP](https://www.python-mip.com/) from/to [OMMX](https://github.com/Jij-Inc/ommx)


pkgId: 9efee1c71e5ff0b8467b22083e6f4b6862e337cbf1035643d5ca7883fda2785a
name: python-omni-authify-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for omni-authify
url: https://github.com/Omni-Libraries/omni-authify.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omni-authify-0.1.5-1.src.rpm
location_href: Packages/python-omni-authify-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://mukhsin-gitbook.gitbook.io/omni-authify/">
          <img src="https://img.shields.io/static/v1?message=Documented%20on%20GitBook&logo=gitbook&logoColor=ffffff&label=%20&labelColor=5c5c5c&color=3F89A1" alt="Documentation"/>
      </a>
      <a href="https://github.com/Omni-Libraries/omni-authify.git">
          <img src="https://img.shields.io/badge/Open_Source-❤️-FDA599?" alt="Open Source"/>
      </a>
      <a href="https://discord.gg/BQrvDpcw">
          <img src="https://img.shields.io/badge/Community-Join%20Us-blueviolet" alt="Community"/>
      </a>
      <a href="https://pypi.org/project/omni-authify/">
          <img src="https://img.shields.io/pypi/dm/omni-authify" alt="PyPI Downloads"/>
      </a>


pkgId: ee049fbc76923ddacc9c7c0ecbf1e59472addfaf2c13bdb32c38563987e56fec
name: python-omni-photo-lib-help
arch: noarch
version: 0.1.15
epoch: 0
release: 1
summary: Development documents and examples for omni-photo-lib
url: https://pypi.org/project/omni-photo-lib/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omni-photo-lib-0.1.15-1.src.rpm
location_href: Packages/python-omni-photo-lib-help-0.1.15-1.noarch.rpm
checksum_type: sha256
description:
  Omni-Photo-Lib is a Python library for generating images using Together API with Celery.


  - Celery integration for distributed task management.
  - Utilities for handling aspect ratios and runtime parameters.
  - Support for RabbitMQ and Redis.



  ```bash
  pip install omni-photo-lib


pkgId: 4d769f46e339aee14105c7409d49d89d6978fbe3457f4a23d46414da220bff43
name: python-omnipy-help
arch: noarch
version: 0.19.0
epoch: 0
release: 1
summary: Development documents and examples for omnipy
url: https://fairtracks.net/fair/#fair-07-transformation
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omnipy-0.19.0-1.src.rpm
location_href: Packages/python-omnipy-help-0.19.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Omnypy logo](https://fairtracks.net/_nuxt/img/9a84303.webp)

  Omnipy is a high level Python library for type-driven data wrangling and scalable workflow
  orchestration.

  ![Conceptual overview of Omnipy](https://fairtracks.net/materials/images/omnipy-overview.png)



  - **June 22, 2024:** We're not very good at writing updates. Expect a larger update soon on an important
    and potentially groundbreaking new feature of Omnipy: the capability of model objects to automatically
    mimic behaviour of the modelled class – with the addition of snapshots and rollbacks.
    So e.g. `Model[list[int]]()` is not just a run-time typesafe parser that continuously makes sure that the
    elements in the list are, in fact, integers; the object can also be operated as a list using e.g.
    `.append()`, `.insert()` and concatenation with the `+` operator; and furthermore: if you append an
    unparseable element, say `"abc"` instead of `"123"`, it will roll back the contents to the previously
    validated snapshot!
  - **Feb 3, 2023:** Documentation of the Omnipy API is still sparse. However, for examples of running
    code, please check out the [omnipy-examples repo](https://github.com/fairtracks/omnipy_examples).
  - **Dec 22, 2022:** Omnipy is the new name of the Python package formerly known as uniFAIR.
    _We are very grateful to Dr. Jamin Chen, who gracefully transferred ownership of the (mostly
    unused) "omnipy" name in PyPI to us!__





  _(NOTE: Read the
  section [Transformation on the FAIRtracks.net website](https://fairtracks.net/fair/#fair-07-transformation)
  for a more detailed and better formatted version of the following description!)_

  Omnipy is designed primarily to simplify development and deployment of (meta)data transformation
  processes in the context of FAIRification and data brokering efforts. However, the functionality is
  very generic and can also be used to support research data (and metadata) transformations in a range
  of fields and contexts beyond life science, including day-to-day research scenarios:



  Researchers in life science and other data-centric fields
  often need to extract, manipulate and integrate data and/or metadata from different sources, such as
  repositories, databases or flat files. Much research time is spent on trivial and not-so-trivial
  details of such ["data wrangling"](https://en.wikipedia.org/wiki/Data_wrangling):

  - reformat data structures
  - clean up errors
  - remove duplicate data
  - map and integrate dataset fields
  - etc.

  General software for data wrangling and analysis, such as [Pandas](https://pandas.pydata.org/),
  [R](https://www.r-project.org/) or [Frictionless](https://frictionlessdata.io/), are useful, but
  researchers still regularly end up with hard-to-reuse scripts, often with manual steps.



  With the Omnipy Python package, researchers can import (meta)data in almost any shape or form:
  _nested JSON; tabular
  (relational) data; binary streams; or other data structures_. Through a step-by-step process, data
  is continuously parsed and reshaped according to a series of data model transformations.



  Omnipy follows the principles of "Type-driven design" (read
  _Technical note #2: "Parse, don't validate"_ on the
  [FAIRtracks.net website](https://fairtracks.net/fair/#fair-07-transformation) for more info). It
  makes use of cutting-edge [Python type hints](https://peps.python.org/pep-0484/) and the popular
  [pydantic](https://pydantic-docs.helpmanual.io/) package to "pour" data into precisely defined data
  models that can range from very general (e.g. _"any kind of JSON data", "any kind of tabular data"_,
  etc.) to very specific (e.g. _"follow the FAIRtracks JSON Schema for track files with the extra
  restriction of only allowing BigBED files"_).



  Omnipy _tasks_ (single steps) or _flows_ (workflows) are defined as
  transformations from specific _input_ data models to specific _output_ data models.
  [pydantic](https://pydantic-docs.helpmanual.io/)-based parsing guarantees that the input and output
  data always follows the data models (i.e. data types). Thus, the data models defines "contracts"
  that simplifies reuse of tasks and flows in a _mix-and-match_ fashion.



  Omnipy is built from the ground up to be modular. We aim
  to provide a catalog of commonly useful functionality ranging from:

  - data import from REST API endpoints, common flat file formats, database dumps, etc.
  - flattening of complex, nested JSON structures
  - standardization of relational tabular data (i.e. removing redundancy)
  - mapping of tabular data between schemas
  - lookup and mapping of ontology terms
  - semi-automatic data cleaning (through e.g. [Open Refine](https://openrefine.org/))
  - support for common data manipulation software and libraries, such as
    [Pandas](https://pandas.pydata.org/), [R](https://www.r-project.org/),
    [Frictionless](https://frictionlessdata.io/), etc.

  In particular, we will provide a _FAIRtracks_ module that contains data models and processing steps
  to transform metadata to follow the [FAIRtracks standard](/standards/#standards-01-fairtracks).

  ![Catalog of commonly useful processing steps, data modules and tool integrations](https://fairtracks.net/_nuxt/img/7101c5f-1280.png)



  An Omnipy module typically consists of a set of generic _task_ and
  _flow templates_ with related data models, (de)serializers, and utility functions. The user can then
  pick task and flow templates from this extensible, modular catalog, further refine them in the
  context of a custom, use case-specific flow, and apply them to the desired compute engine to carry
  out the transformations needed to wrangle data into the required shape.



  When piecing together a custom flow in Omnipy, the user has persistent
  access to the state of the data at every step of the process. Persistent intermediate data allows
  for caching of tasks based on the input data and parameters. Hence, if the input data and parameters
  of a task does not change between runs, the task is not rerun. This is particularly useful for
  importing from REST API endpoints, as a flow can be continuously rerun without taxing the remote
  server; data import will only carried out in the initial iteration or when the REST API signals that
  the data has changed.



  In the case of large datasets, the researcher can set
  up a flow based on a representative sample of the full dataset, in a size that is suited for running
  locally on, say, a laptop. Once the flow has produced the correct output on the sample data, the
  operation can be seamlessly scaled up to the full dataset and sent off in
  [software containers](https://www.docker.com/resources/what-container/) to run on external compute
  resources, using e.g. [Kubernetes](https://kubernetes.io/). Such offloaded flows
  can be easily monitored using a web GUI.

  ![Working with Omnipy directly from an Integrated Development Environment (IDE)](https://fairtracks.net/_nuxt/img/f9be071-1440.png)



  Offloading of flows to external compute resources is provided by
  the integration of Omnipy with a workflow engine based on the [Prefect](https://www.prefect.io/)
  Python package. Prefect is an industry-leading platform for dataflow automation and orchestration
  that brings a [series of powerful features](https://www.prefect.io/opensource/) to Omnipy:

  - Predefined integrations with a range of compute infrastructure solutions
  - Predefined integration with various services to support extraction, transformation, and loading
    (ETL) of data and metadata
  - Code as workflow ("If Python can write it, Prefect can run it")
  - Dynamic workflows: no predefined Direct Acyclic Graphs (DAGs) needed!
  - Command line and web GUI-based visibility and control of jobs
  - Trigger jobs from external events such as GitHub commits, file uploads, etc.
  - Define continuously running workflows that still respond to external events
  - Run tasks concurrently through support for asynchronous tasks

  ![Overview of the compute and storage infrastructure integrations that comes built-in with Prefect](https://fairtracks.net/_nuxt/img/ccc322a-1440.png)



  It is also possible to integrate Omnipy with other workflow
  backends by implementing new workflow engine plugins. This is relatively easy to do, as the core
  architecture of Omnipy allows the user to easily switch the workflow engine at runtime. Omnipy
  supports both traditional DAG-based and the more _avant garde_ code-based definition of flows. Two
  workflow engines are currently supported: _local_ and _prefect_.


pkgId: 14aa73fdaa2bc18bbb62888f8345ca45cedd6b8af92d8d5a87d3a20744c7440b
name: python-omniwatermask-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for omniwatermask
url: https://github.com/DPIRD-DMA/OmniWaterMask
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omniwatermask-0.1.3-1.src.rpm
location_href: Packages/python-omniwatermask-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  OmniWaterMask is a Python library for high accuracy water segmentation in high to moderate resolution satellite imagery, supporting a wide range of resolutions, sensors, and processing levels.



  -   Process imagery resolutions from 0.2 m to 50 m.
  -   Any imagery processing level
  -   Only requires Red, Green, Blue and NIR bands
  -   Known to work well with Sentinel-2, Landsat 8, PlanetScope, Maxar and NAIP



  [![Colab_Button]][Link]

  [Link]: https://colab.research.google.com/drive/15qgTgk4XiWcSzllNt4CtFU7pDSNrKLHk?usp=sharing 'Try OmniWaterMask In Colab'

  [Colab_Button]: https://img.shields.io/badge/Try%20in%20Colab-grey?style=for-the-badge&logo=google-colab


  OmniWaterMask integrates a sensor agnostic deep learning segmentation model with NDWI and vector datasets to detect water bodies within remote sensing products.

  Paper coming soon...



  To install the package, use one of the following commands:

  Make sure you are running Python 3.9 or above and

  ```bash
  conda create -n owm python=3.12
  conda activate owm

  pip install omniwatermask
  ```

  ```bash
  conda create -n owm python=3.12
  conda activate owm

  pip install git+https://github.com/DPIRD-DMA/OmniWaterMask.git
  ```



  To predict a water mask for a list of scenes simply pass a list of geotiff files to the make_water_mask function along with the band order for the Red, Green, Blue and NIR bands. Predictions are saved to disk along side the input as geotiffs, a list of predictions file paths is returned:

  ```python
  from pathlib import Path
  from omniwatermask import make_water_mask

  scene_paths = [Path("path/to/scene1.tif"), Path("path/to/scene2.tif")]


  water_mask_path = make_water_mask(
      scene_paths=[scene_paths],  # you can pass a list of images
      band_order=[1, 2, 3, 4],  # band order of the input images, expects RGB+NIR
  )
  ```

  - Output classes are:
  - 0 = Non-water
  - 1 = water



  -   OWM requires an active internet connection to function properly, as it needs to download OpenStreetMap (OSM) data.
  -   Hardware acceleration is strongly recommended:
      -   NVIDIA GPU
      -   Apple Silicon Mac
      -   Other PyTorch-compatible accelerators
  -   Consider enabling "bf16" inference_dtype on compatible hardware - this typically results in faster processing speeds.
  -   If experiencing VRAM limitations even with batch_size=1, switching the 'mosaic_device' parameter to 'cpu' can help.
  -   Improve accuracy by providing known water body locations as 'aux_vector_sources' - simply pass a list of file paths pointing to your water polygon datasets.
  -   Reduce false positives by including vector data for common misidentification sources (buildings, roads) through the 'aux_negative_vector_sources' parameter.

  -   When working with scenes containing no-data regions, explicitly set the 'no_data_value' parameter to ensure proper handling of these areas.




  -    `scene_paths`: List of paths or single path (supports both Path and string types) to the input satellite/aerial imagery

  -    `band_order`: List of integers specifying the band order for input imagery (e.g., [1,2,3,4] if your input image is stored with band order red, green, blue then NIR data). This tells OWM which bands correspond to Red, Green, Blue, and Near-Infrared channels

  -    `batch_size`: Number of patches processed simultaneously during inference. Default is 1, increase for better GPU utilization

  -    `version`: Version identifier for the output files. Defaults to current OmniWaterMask version

  -    `output_dir`: Optional path for output files. If not specified, outputs are saved alongside input files

  -    `mosaic_device`: Device for mosaic operations ("cpu", "cuda" or "mps"). Defaults to system's default device

  -    `inference_device`: Device for model inference ("cpu", "cuda" or "mps"). Defaults to system's default device

  -    `aux_vector_sources`: List of paths to supplementary water body vector data to aid detection

  -    `aux_negative_vector_sources`: List of paths to vector data marking areas commonly misidentified as water

  -    `inference_dtype`: Data type for inference operations. Defaults to torch.float32

  -    `no_data_value`: Value indicating no-data regions in the input imagery. Defaults to 0

  -    `inference_patch_size`: Size of image patches for inference. Defaults to 1000 pixels

  -    `inference_overlap_size`: Overlap between adjacent patches during inference. Defaults to 300 pixels

  -    `overwrite`: Whether to overwrite existing output files. Defaults to True

  -    `use_cache`: Whether to cache vector data processing results. Defaults to True

  -    `use_osm_building`: Whether to use OpenStreetMap building data to reduce false positives. Defaults to True

  -    `use_osm_roads`: Whether to use OpenStreetMap road data to reduce false positives. Defaults to True

  -    `cache_dir`: Directory for storing cached vector data. Defaults to "OWM_cache" in current directory




  Contributions are welcome! Please submit a pull request or open an issue to discuss any changes.



  This project is licensed under the MIT License



  Special thanks to the [S1S2-Water dataset authors ](https://github.com/MWieland/s1s2_water) and [The FLAIR #1 dataset authors](https://ignf.github.io/FLAIR/) for providing the valuable training datasets.


pkgId: 207efe3605a546d23aac2960115bcd82f63c46ebefe7dd1d639945b5489e4918
name: python-omotes-simulator-core-help
arch: noarch
version: 0.0.14
epoch: 0
release: 1
summary: Development documents and examples for omotes-simulator-core
url: https://pypi.org/project/omotes-simulator-core/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omotes-simulator-core-0.0.14-1.src.rpm
location_href: Packages/python-omotes-simulator-core-help-0.0.14-1.noarch.rpm
checksum_type: sha256
description:
  This repository is part of the 'Nieuwe Warmte Nu Design Toolkit' project.

  Core library of the OMOTES simulator


pkgId: 359d9e06f3f2a5b3d7c12229e821d509a9df71fed28dbde00d4745d28f360688
name: python-omproxy-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for omproxy
url: https://pypi.org/project/omproxy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omproxy-0.1.7-1.src.rpm
location_href: Packages/python-omproxy-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  An open source proxy for MCP servers.



  Replace the mcp server command with `uvx omproxy` followed by the command.

  For example:

  replace:

  ```json
  {
      "mcpServers":{
          "server1":{
              "command":"uv run python src/example_server.py"
          }
      }
  }
  ```

  with:

  ```json
  {
      "mcpServers":{
          "server1":{
              "command":"uvx omproxy uv runpython src/example_server.py"
          }
      }
  }
  ```


pkgId: e25551da5fbbc233049efe249156732e586b1ab19ea618cb8af222d740d3f64a
name: python-omspy-help
arch: noarch
version: 0.19.1
epoch: 0
release: 1
summary: Development documents and examples for omspy
url: https://github.com/uberdeveloper/omspy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-omspy-0.19.1-1.src.rpm
location_href: Packages/python-omspy-help-0.19.1-1.noarch.rpm
checksum_type: sha256
description:
  omspy is a broker agnostic order management system with a common api, advanced order types and more


pkgId: e984c80ad4b238ead2693d3371fdf040c7b5cc0629d10992c7d5127aba1b9ee4
name: python-oncodriveclustl-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for oncodriveclustl
url: https://pypi.org/project/oncodriveclustl/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-oncodriveclustl-1.2.0-1.src.rpm
location_href: Packages/python-oncodriveclustl-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  OncodriveCLUSTL is a sequence-based clustering method to identify significant
  clustering signals in nucleotide sequence.

  One of the main goals of cancer research is the identification of the genomic
  elements that drive tumorigenesis. OncodriveCLUSTL is a new nucleotide
  sequence-based clustering algorithm to detect significant clustering signals
  across genomic regions. OncodriveCLUSTL is based on a local background model
  derived from the nucleotide context mutational probabilities of the cohort under
  study. Our method is able to identify well-known cancer drivers in coding
  regions and it can be applied to non-coding regions and non-human data.



  OncodriveCLUSTL is available to the general public subject to certain conditions
  described in its [LICENSE](LICENSE).




  OncodriveCLUSTL depends on Python 3.5 or above. We recommend to install it using
  the [Anaconda Python distribution](https://www.anaconda.com/download/):

  ```bash
  conda install -c bbglab oncodriveclustl
  ```

  OncodriveCLUSTL can also be installed using pip:

  ```bash
  pip install oncodriveclustl
  ```

  You can obtain the latest code from the repository and install it for development with pip:

  ```bash
  git clone git@bitbucket.org:bbglab/oncodriveclustl.git
  cd oncodriveclustl
  python -m venv .venv
  .venv/bin/pip install -e .
  source .venv/bin/activate
  oncodriveclustl --help
  ```

  > [!NOTE]
  > The first time that you run OncodriveCLUSTL with a given reference genome, it
  > will download it from our servers. By default the downloaded datasets go to
  > `~/.bgdata`. If you want to move these datasets to another folder you have to
  > define the system environment variable `BGDATA_LOCAL` with an export command.

  > [!NOTE]
  > If you install a modern build tool like [uv](https://github.com/astral-sh/uv),
  > you can simply do this:
  > ```bash
  > git clone https://github.com/bbglab/oncodriveclustl.git
  > cd oncodriveclustl
  > uv run oncodriveclustl --help
  > ```



  OncodriveCLUSTL only requires two main inputs, the mutations file and the
  annotations file.



  TSV file containing SNVs (substitutions) mapped to a reference genome (e.g.,
  human hg19 or mouse c3h). If other mutation types are present (insertions,
  deletions, double base substitutions, etc), they will be filtered out during the
  analysis. This file must contain, at least, the following 5 columns with header:

  1. **CHROMOSOME**: 1, 2,..., X, Y
  2. **POSITION**: Integer indicating the position of the mutation
  3. **REF**: Reference nucleotide
  4. **ALT**: Alternate nucleotide
  5. **SAMPLE**: Identifier of the sample

  Additional columns are:

  6. **CANCER_TYPE**: Type of tumor. When specified, OncodriveCLUSTL will
     calculate one mutational profile for each cancer type and mutations will be
     randomized accordingly.
  7. **SIGNATURE**: User-defined group to compute k-mer nucleotide mutational
     probabilities. When specified, OncodriveCLUSTL will calculate one mutational
     profile for each group and will randomize each mutation accordingly.

  > [!NOTE]
  > OncodriveCLUSTL assumes all SNVs are mapped to the positive strand.

  > [!WARNING]
  > When using the `--signature-group` option, please check that the number of
  > mutations per group is sufficient for an accurate signatures calculation.



  TSV file containing the coordinates of genomic elements (GEs). This file must
  contain, at least, the following 5 columns with header:

  1. **CHROMOSOME**: 1, 2,..., X, Y
  2. **START**: Starting position of the genomic region
  3. **END**: Final position of the genomic region
  4. **ELEMENT**: Identifier of the GE
  5. **SYMBOL**: Symbol of the GE. OncodriveCLUSTL will analyze GEs as **SYMBOL** + **ELEMENT**.

  Additional columns are:

  6. **STRAND**: Strand of the GE coordinates ("+" or "-").

  > [!WARNING]
  > Coordinates of a given GE cannot overlap.

  You can check the input formats in the files provided in the example.

  If you have a VCF file or directory of VCF files containing somatic mutations,
  you can run our VCF parser to obtain a tabular file compatible with
  OncodriveCLUSTL input format::

  ```bash
  parse_vcf -i [INPUT_DIRECTORY] -o [OUTPUT_FILE]
  ```

  Please, check [parsers/vcf.py](oncodriveclustl/parsers/vcf.py) module for more
  details.

  If you would like to run OncodriveCLUSTL using a per-calculated signature or
  mutational profile, you need to provide a dictionary containing the reference
  k-mer to alternate mutational probabilities in JSON format:

  ```json
  {
      "my_dataset": {
          "GCA>G": 0.02424271083094251,
          "AGC>A": 0.023005887103025254,
          "ACG>T": 0.037613802858829135,
          "CGA>C": 0.10691031051670515,
          "GAC>G": 0.017846071811001615,
          "TTC>A": 0.024003748061871697,
          "CTT>G": 0.024149863672267024,
          "GGA>T": 0.011178562948734577,
          "AGG>C": 0.010654720767868876,
          "GGG>C": 0.012031686292218055,
          "CAA>T": 0.014478959792844522,
          "TGA>A": 0.01255651801972085,
          "GGA>A": 0.011178562948734577,
          "CGA>A": 0.03563677017223505,
          "TCC>T": 0.011158347971568658,
          "GCC>A": 0.010952316565906438,
          // ...
      }
  }
  ```

  OncodriveCLUSTL requires non-collapsed k-mer probabilities (192 for
  tri-nucleotides, 3072 for penta-nucleotides).



  OncodriveCLUSTL generates three output files:



  TSV file containing results of the analyzed elements:

  1. **SYMBOL**: GE symbol #. ENSID: GE ID #. CGC: True if GE in the COSMIC Cancer Gene Census (CGC) list (Sondka et al., 2018)
  2. **CHROMOSOME**: 1, 2,..., X, Y
  3. **STRAND**: Strand of the GE ("+" or "-")
  4. **LENGTH**: length (bp) of the GE
  5. **TOTAL_MUT**: total substitutions observed in the GE
  6. **CLUSTERED_MUT**: number of substitutions in a cluster
  7. **CLUSTERS**: number of clusters
  8. **SIM_CLUSTERS**: number of simulated clusters
  9. **SCORE**: GE score
  10. **P_EMPIRICAL**: empirical p-value of the GE
  11. **Q_EMPIRICAL**: empirical q-value of the GE
  12. **P_ANALYTICAL**: analytical p-value of the GE
  13. **Q_ANALYTICAL**: analytical q-value of the GE
  14. **P_TOPCLUSTER**: analytical p-value of the cluster with highest cluster score
  15. **Q_TOPCLUSTER**: analytical q-value of the cluster with highest cluster score



  TSV file containing results of the clusters observed in the analyzed elements:

  1. **RANK**: Position of the GE in the list of
  2. **SYMBOL**: GE symbol
  3. **ENSID**: GE ID
  4. **CGC**: True if GE in the CGC list
  5. **CHROMOSOME**: 1, 2,..., X, Y
  6. **STRAND**: Strand of the GE ("+" or "-")
  7. **COORDINATES**: genomic coordinates of the cluster. It can be 'coord1,coord2'
     for clusters inside a single region or 'coord1,coord2;coord3,coord4' for
     those spanning regions (--concatenate flag)
  8. **MAX_COORD**: genomic position with the highest smoothing score inside the cluster
  9. **WIDTH**: cluster's width (pb)
  10. **N_MUT**: number of substitutions in the cluster
  11. **N_SAMPLES**: number of samples with a mutation in the cluster
  12. **FRA_UNIQ_SAMPLES**: proportion of unique samples mutated in the cluster out of the total of mutations in the cluster
  13. **SCORE**: cluster score
  14. **P**: analytical p-value of the cluster



  TXT file containing OncodriveCLUSTL's run information.



  OncodriveCLUSTL is meant to be used through the command line.

  ```
  Usage: oncodriveclustl [OPTIONS]

  Options:
    -i, --input-file PATH           File containing somatic mutations
                                    [required]
    -r, --regions-file PATH         File with the genomic regions to analyze
                                    [required]
    -o, --output-directory TEXT     Output directory to be created  [required]
    -sig, --input-signature PATH    File containing input context based
                                    mutational probabilities (signature)
    -ef, --elements-file PATH       File with the symbols of the elements to
                                    analyze
    -e, --elements TEXT             Symbol of the element(s) to analyze
    -g, --genome [hg38|hg19|mm10|c3h|car|cast|f344]
                                    Genome to use
    -emut, --element-mutations INTEGER
                                    Cutoff of element mutations. Default is 2
    -cmut, --cluster-mutations INTEGER
                                    Cutoff of cluster mutations. Default is 2
    -sw, --smooth-window INTEGER RANGE
                                    Smoothing window. Default is 11  [3<=x<=101]
    -cw, --cluster-window INTEGER RANGE
                                    Cluster window. Default is 11  [3<=x<=101]
    -kmer, --kmer [3|5]             K-mer nucleotide context
    -n, --n-simulations INTEGER     number of simulations. Default is 1000
    -sim, --simulation-mode [mutation_centered|region_restricted]
                                    Simulation mode
    -simw, --simulation-window INTEGER RANGE
                                    Simulation window. Default is 31
                                    [19<=x<=101]
    -sigcalc, --signature-calculation [frequencies|region_normalized]
                                    Signature calculation: mutation frequencies
                                    (default) or k-mer mutation counts
                                    normalized by k-mer region counts
    -siggroup, --signature-group [SIGNATURE|SAMPLE|CANCER_TYPE]
                                    Header of the column to group signatures
                                    calculation
    -c, --cores INTEGER RANGE       Number of cores to use in the computation.
                                    By default it will use all the available
                                    cores.  [1<=x<=10]
    --seed INTEGER                  Seed to use in the simulations
    --log-level [debug|info|warning|error|critical]
                                    Verbosity of the logger
    --concatenate                   Calculate clustering on concatenated genomic
                                    regions (e.g., exons in coding sequences)
    --clustplot                     Generate a needle plot with clusters for an
                                    element
    --qqplot                        Generate a quantile-quantile (Q-Q) plot for
                                    a dataset
    --gzip                          Gzip compress files
    -h, --help                      Show this message and exit.
  ```

  > [!NOTE]
  > When using simulation mode 'mutation_centered', simulation windows can be
  > simulated outside the GE.

  > [!NOTE]
  > When using `--signature-calculation region_normalized`, k-mer mutation counts
  > will be normalized by k-mer nucleotide counts in the genomic regions
  > provided as input (`--regions-file`).



  If you run OncodriveCLUSTL from the [source code], you can run an example of
  TCGA pancreatic adenocarcinomas (Ellrott et al. 2018) for coding regions
  (Mularoni et al., 2016) using 1000 simulations. First you need to download the
  example folder. Then you run OncodriveCLUSTL with default mode and parameters
  as:

  [source code]: https://github.com/bbglab/oncodriveclustl

  ```bash
  oncodriveclustl -i example/PAAD.tsv.gz -r example/cds.hg19.regions.gz -o example/output
  ```

  The results will be saved in a folder named `output`.

  You can compute a more sophisticated analysis using non-default parameters and
  generate a quantile-quantile plot by typing:

  ```bash
  oncodriveclustl -i example/PAAD.tsv.gz -r example/cds.hg19.regions.gz -o example/output -sw 15 -cw 15 -simw 35 -sim region_restricted --concatenate --qqplot
  ```

  If you want to run a specific GE and generate a plot its observed clusters, you
  can type::

  ```bash
  oncodriveclustl -i example/PAAD.tsv.gz -r example/cds.hg19.regions.gz -o example/output -sw 15 -cw 15 -simw 35 -sim region_restricted --concatenate --clustplot -e KRAS
  ```

rpm_license:
  OncodriveClustl is the property of the Institute for Research in Biomedicine (IRB Barcelona), which hold the copyright thereto. Copyright (C) 2018 Institute for Research in Biomedicine (IRB Barcelona)  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.  You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>


pkgId: 4d3289d3a4dfdc3031b5baf4c71c0d3988ee590d514e756917dc70643b89679b
name: python-one-updater-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for one-updater
url: https://pypi.org/project/one-updater/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-one-updater-0.4.1-1.src.rpm
location_href: Packages/python-one-updater-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  A flexible package manager updater that helps you keep all your development tools up to date.



  - Update multiple package managers with a single command
  - Configure which package managers to update
  - Support for virtual environments and pyenv for Python packages
  - Beautiful command-line interface with rich formatting and logging
  - Cross-platform support
  - Extensible architecture for adding new package managers



  - Homebrew
  - pip (with virtualenv/pyenv support)
  - npm
  - cargo
  - gem
  - pipx
  - pacman
  - dnf
  - flatpak
  - pkgx
  - vagrant-plugins
  - micro editor plugins
  - tldr pages
  - go packages
  - apt
  - More coming soon!



  Install from PyPI:

  ```bash
  pip install one-updater
  ```

  To upgrade to the latest version:

  ```bash
  pip install --upgrade one-updater
  ```





  Update all enabled package managers:

  ```bash
  one-updater update
  ```

  Update specific package managers:

  ```bash
  one-updater update -m homebrew -m pip
  ```

  List configured package managers:

  ```bash
  one-updater list-managers
  ```

  Initialize a new configuration file:

  ```bash
  one-updater init
  ```



  The tool uses a YAML configuration file (default: `~/.config/one-updater/config.yaml`) to specify package manager settings. You can:

  1. Enable/disable specific package managers
  2. Configure virtualenv/pyenv for Python packages
  3. Customize update commands
  4. Configure logging and verbosity

  Example configuration:

  ```yaml
  verbose: true
  logging:
    level: "INFO"
    format: "s"

  package_managers:
    homebrew:
      enabled: true
      commands:
        update: ["brew", "update"]
        upgrade: ["brew", "upgrade"]

    pip:
      enabled: true
      virtualenv: "/path/to/virtualenv" # Optional
      pyenv: "3.11.0" # Optional
      commands:
        update: ["pip", "install", "--upgrade", "pip"]
        upgrade: ["pip", "list", "--outdated", "--format=json"]
  ```



  Contributions are welcome! Feel free to:

  1. Add support for new package managers
  2. Improve error handling and logging
  3. Add new features
  4. Fix bugs
  5. Improve documentation

  Please ensure your changes pass the test suite and code quality checks:

  ```bash

  poetry install


  poetry run pytest


  poetry run black .
  ```



  MIT License


pkgId: 014b0dcdecb1fc8f3a7c23defd1fdf10e0422f4d156373f56c82794d5840131b
name: python-onebusaway-help
arch: noarch
version: 1.4.6
epoch: 0
release: 1
summary: Development documents and examples for onebusaway
url: https://github.com/OneBusAway/python-sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-onebusaway-1.4.6-1.src.rpm
location_href: Packages/python-onebusaway-help-1.4.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/onebusaway.svg)](https://pypi.org/project/onebusaway/)


  The Onebusaway SDK Python library provides convenient access to the Onebusaway SDK REST API from any Python 3.8+

  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [developer.onebusaway.org](https://developer.onebusaway.org). The full API of this library can be found in [api.md](https://github.com/OneBusAway/python-sdk/tree/main/api.md).



  ```sh

  pip install onebusaway
  ```



  The full API of this library can be found in [api.md](https://github.com/OneBusAway/python-sdk/tree/main/api.md).

  ```python
  import os
  from onebusaway import OnebusawaySDK

  client = OnebusawaySDK(
      api_key=os.environ.get("ONEBUSAWAY_API_KEY"),  # This is the default and can be omitted
  )

  current_time = client.current_time.retrieve()
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `ONEBUSAWAY_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncOnebusawaySDK` instead of `OnebusawaySDK` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from onebusaway import AsyncOnebusawaySDK

  client = AsyncOnebusawaySDK(
      api_key=os.environ.get("ONEBUSAWAY_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      current_time = await client.current_time.retrieve()


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `onebusaway.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `onebusaway.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `onebusaway.APIError`.

  ```python
  import onebusaway
  from onebusaway import OnebusawaySDK

  client = OnebusawaySDK()

  try:
      client.current_time.retrieve()
  except onebusaway.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except onebusaway.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except onebusaway.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from onebusaway import OnebusawaySDK


  client = OnebusawaySDK(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).current_time.retrieve()
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from onebusaway import OnebusawaySDK


  client = OnebusawaySDK(
      
      timeout=20.0,
  )


  client = OnebusawaySDK(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).current_time.retrieve()
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/OneBusAway/python-sdk/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `ONEBUSAWAY_SDK_LOG` to `info`.

  ```shell
  $ export ONEBUSAWAY_SDK_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from onebusaway import OnebusawaySDK

  client = OnebusawaySDK()
  response = client.current_time.with_raw_response.retrieve()
  print(response.headers.get('X-My-Header'))

  current_time = response.parse()  # get the object that `current_time.retrieve()` would have returned
  print(current_time)
  ```

  These methods return an [`APIResponse`](https://github.com/OneBusAway/python-sdk/tree/main/src/onebusaway/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/OneBusAway/python-sdk/tree/main/src/onebusaway/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.current_time.with_streaming_response.retrieve() as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from onebusaway import OnebusawaySDK, DefaultHttpxClient

  client = OnebusawaySDK(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/OneBusAway/python-sdk/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import onebusaway
  print(onebusaway.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/OneBusAway/python-sdk/tree/main/./CONTRIBUTING.md).


pkgId: 9818e04cf963cdb72774abc649bb9f0f25511ddb6fc1119aa4cb28c567bf1b53
name: python-onkeypress-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for onkeypress
url: https://github.com/zlliu246/onkeypress
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-onkeypress-0.0.5-1.src.rpm
location_href: Packages/python-onkeypress-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Allows users to make terminal react to keypresses



  ```
  pip install onkeypress
  ```



  ```python
  from onkeypress import while_not_exit, onkeypress, Key

  def print_up():
      print("up is pressed")

  def print_down():
      print("down is pressed")

  while_not_exit(
      onkeypress(Key.UP).call(print_up),
      onkeypress(Key.DOWN).call(print_down),
      exit_key=Key.ENTER,
  )
  ```

  | key pressed | printed text |
  | ----------- | ------------ |
  | Up | up is pressed |
  | Down | down is pressed |

  If you hit Enter (or Control-C), the program exits



  ```python
  from onkeypress import while_not_exit, onkeypress, Key

  def myfunc(*args, **kwargs):
      print(f"{args=} {kwargs=}")

  while_not_exit(
      onkeypress(Key.UP).call(myfunc).args("up"),
      onkeypress(Key.DOWN).call(myfunc).kwargs(key="down"),
      onkeypress("a").call(myfunc).args("a").kwargs(key="a"),
      onkeypress("s").call(myfunc).args("s", "s").kwargs(key="s", val="s"),
      exit_key=Key.ENTER,
  )
  ```

  | key pressed | printed text |
  | ----------- | ------------ |
  | Up | args=('up',) kwargs={} |
  | Down | args=() kwargs={'key': 'down'} |
  | a | args=('a',) kwargs={'key': 'a'} |
  | s | args=('s', 's') kwargs={'key': 's', 'val': 's'} |



  ```python
  from onkeypress import while_not_exit, onkeypress, Key
  import random

  def print_1_to_5_chars(char: str):
      if char.isalnum():
          print(char * random.randrange(1, 5), end="")
      else:
          print(char, end="")

  while_not_exit(
      onkeypress(Key.ALL_OTHERS).call(print_1_to_5_chars),
      exit_key=Key.CONTROL_C,
  )
  ```

  Key.ALL_OTHERS match all other keys which were not declared

  ^ when we type a letter, it randomly repeats itself 1-5 times



  ```python
  from onkeypress import while_not_exit, onkeypress, Key
  from copy import deepcopy
  from unprint import unprint

  BOARD = [["-"]*6 for _ in range(6)]

  def print_board(board: list, user_row: int, user_col: int):
      board = deepcopy(board)
      board[user_row][user_col] = "X"
      [print(*row, sep=" ") for row in board]
      print()

  print_board(BOARD, 0, 0)

  state = {"row":0 , "col": 0}

  def handle_keypress(row_diff: int, col_diff: int, state: dict):
      new_row = state["row"] + row_diff
      new_col = state["col"] + col_diff
      if new_row not in range(6) or new_col not in range(6):
          return
      state["row"], state["col"] = new_row, new_col
      unprint(7)
      print_board(BOARD, new_row, new_col)

  while_not_exit(
      onkeypress(Key.UP).call(handle_keypress).args(-1, 0, state),
      onkeypress(Key.DOWN).call(handle_keypress).args(1, 0, state),
      onkeypress(Key.LEFT).call(handle_keypress).args(0, -1, state),
      onkeypress(Key.RIGHT).call(handle_keypress).args(0, 1, state),
      exit_key=Key.CONTROL_C,
  )
  ```

  Note - try hitting your arrow keys. Notice that your "X" moves around


pkgId: 571bf67af53a63206269eb17c253139922d9dc74f63b91e647485fa1f169bf19
name: python-onnx-shrink-ray-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for onnx-shrink-ray
url: https://github.com/usefulsensors/onnx_shrink_ray
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-onnx-shrink-ray-0.0.3-1.src.rpm
location_href: Packages/python-onnx-shrink-ray-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Shrinks the size of ONNX files by quantizing large float constants into eight bit equivalents, while leaving all calculations in floating point.



  The easiest way to get started is to install this package in Python using pip:

  ```bash
  pip install onnx_shrink_ray
  ```

  You can also download this repository and run the `shrink.py` script directly.





  ```bash
  python -m onnx_shrink_ray.shrink myfile.onnx
  ```

  This will convert all of the weights in the ONNX file from 32-bit floating point to 8-bit integers, followed by a `DequantizeLinear` operation to linearly scale those into approximations of the original values for later calculations. The resulting ONNX file is typically less than 30% of the input's size.



  ```bash
  python -m onnx_shrink_ray.shrink --method "float_weights" --float_levels 256 myfile.onnx
  ```

  A lot of downloads and app bundles are automatically compressed using a standard like `gzip` or `brotli`. Neural network weights often don't compress well when they're stored as floating point numbers, since there is very little repetition in the values, they're usually all slightly different from one another. If we know our model will be compressed for delivery, we can reduce the actual download size by making the weight values (which normally make up the majority of the file) easier to compress.

  This tool does this by rounding all the float values in a weight array to the nearest in a limited number of quantized steps, but then storing the results back into a 32-bit floating point tensor. This means the uncompressed size on disk remains the same, but the compressed version is often several times smaller. This is because there's now only a limited number of values in each weight tensor, so there's a lot more repetition in the byte stream for the compression algorithm to take advantage of.

  By default, each weight tensor is quantized to 256 levels, but since the results are stored as floating point values, you can modify this to trade off compressed file size for accuracy. For example, increasing the `--float_levels` argument to 1,000 can improve accuracy at the cost of a larger compressed file, whereas 100 would shrink the size, but could negatively impact quality.



  Standard ONNX quantization is focused on converting all calculations to eight bit, which can reduce latency dramatically on some platforms. This approach can also cause accuracy problems however, and often requires some manual work to achieve the best results.

  Sometimes though, the biggest problem is not speeding up the execution of a network, but reducing the size of the model data. This can be the case when a model has to be downloaded, where the size determines the loading time before it can be used, or when it's part of a mobile app bundle or other edge device with limited storage space.

  The standard ONNX quantization does offer some file size benefits, but the potential impact on accuracy means it can take time and effort to achieve these savings. As an alternative, this module implements "weight-only quantization", where all calculations and activation layers are left in their initial precision, and only the weights are stored in a lower-fidelity format.

  This approach has the advantage that it is much less likely to significantly impact accuracy, and so can usually be applied quickly, with no manual tweaking or fixups required. It will not speed up latency (and some of the methods may actually slow execution by a small amount) but it can offer significant file size savings.

  Though this method is designed to have a minimal impact on the accuracy of the model, there are networks that may be adversely affected. The heuristic used to identify weights simply searches for constants or initializers that are larger than 16,384 elements, with the assumption that smaller constants are more likely to be non-weight parameters, and won't contribute much to the overall size of the model on disk.



  The initial reason for creating this project was to reduce the download size for the [Moonshine](https://github.com/usefulsensors/moonshine) models on the web, so I've done the most extensive testing on those networks. Here are the size and accuracy results when running against the LibreSpeech clean English-language dataset.



  |                              | WER    | File Size | GZIP Size | Brotli Size | Latency |
  |------------------------------|--------|-----------|-----------|-------------|---------|
  | Original                     | 4.51%  | 272MB	    | 251MB	    | 226MB       | 307ms   |
  | Integer Weights              | 4.69%  | 69MB	    | 53MB	    | 46MB        | 466ms   |
  | Float Weights (100 levels)   | 11.34% | 272MB	    | 60MB	    | 46MB        |         |
  | Float Weights (256 levels)   | 4.69%  | 272MB	    | 75MB	    | 59MB        |         |
  | Float Weights (1,000 levels) | 4.47%  | 272MB     | 108MB	    | 79MB        |         |
  | ONNX Dynamic Quantization	   | 30.99% | 113MB	    | 95MB	    | 71MB        |         |



  |                              | WER    | File Size | GZIP Size | Brotli Size | Latency |
  |------------------------------|--------|-----------|-----------|-------------|---------|
  | Original                     | 3.29%  | 556MB	    | 515MB	    | 469MB       |         |
  | Integer Weights              | 3.28%  | 141MB	    | 105MB	    | 92MB        |         |
  | Float Weights (100 levels)   | 3.55%  | 556MB	    | 120MB	    | 94MB        |         |
  | Float Weights (256 levels)   | 3.28%  | 556MB	    | 155MB	    | 121MB       |         |
  | Float Weights (1,000 levels) | 3.29%  | 556MB     | 217MB		|             |         |
  | ONNX Dynamic Quantization	   | 19.06% | 264MB	    | 225MB	    | 180MB       |         |



  The compressed file sizes were calculated by checking the archive size after running `tar --use-compress-program="<brotli|gzip> --best" -cvf archive.tbz <folder of model files>`. The `--best` flag is used here to ensure the compression is as effective as possible by running multiple passes.

  Latency values were calculated by running a ten second audio clip through each model on a Microsoft Surface Pro with an x86 CPU, using the `moonshine_onnx.benchmark()` function included in the library.

  ONNX dynamic quantization results are included for reference. These are models produced by the [`onnxruntime.quantization.quantize_dynamic()`](https://iot-robotics.github.io/ONNXRuntime/docs/performance/quantization.html#quantization-api) function with default arguments. For convenience you can invoke this through the `--method "integer_activations"` option.

  Some interesting patterns are visible:

   - The float weight quantization has no effect on the uncompressed file size, but dramatically decreases the compressed file size, as expected. It also has makes no statistically significant difference to the latency.

   - The integer weight quantization is a lot slower than float weights. This is a bit surprising, since the only difference is a DequantizeLinear operation for each weight constant, but my best guess is that the op hasn't been optimized, on this platform at least.

   - ONNX quantization produces models that are fast, but much less accurate. In my experience this is a common outcome, and can be fixed with some investigation into exactly where the accuracy loss is occuring, but it tends to be a time-consuming process, hence my desire for something easier when file size is the biggest obstacle.

   - ONNX quantization doesn't shrink the raw files as much as I'd expect. If the weights were being stored as 8-bit integers, I'd expect the file size to be the same as the `integer_weights` version, but they're about twice as large. I wonder if the weights are actually stored as 16-bit in this case, or if there's somehow an extra copy?

   - Different models can tolerate different levels of float quantization. The base model only loses a fraction of a percent at 100 levels, whereas the tiny model loses several points.

   - Brotli does a better job at compressing these files than gzip, though the compression process takes significantly longer in my experience. Since brotli is now widely supported by browsers, it seems like the best method to use overall.


pkgId: 7203a4dcd4ac7e2afdca177fe4a51d5064338a1194314c02831056cc7ec591a8
name: python-onnxmltools-help
arch: noarch
version: 1.13.0
epoch: 0
release: 1
summary: Development documents and examples for onnxmltools
url: https://github.com/onnx/onnxmltools
rpm_license: Apache License v2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-onnxmltools-1.13.0-1.src.rpm
location_href: Packages/python-onnxmltools-help-1.13.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--- SPDX-License-Identifier: Apache-2.0 -->


  ![ONNXMLTools_logo_main](https://github.com/onnx/onnxmltools/blob/main/docs/ONNXMLTools_logo_main.png)

  [![CI](https://github.com/onnx/onnxmltools/actions/workflows/ci.yml/badge.svg)](https://github.com/onnx/onnxmltools/actions/workflows/ci.yml)



  ONNXMLTools enables you to convert models from different machine learning toolkits into [ONNX](https://onnx.ai). Currently the following toolkits are supported:

  * Tensorflow (a wrapper of [tf2onnx converter](https://github.com/onnx/tensorflow-onnx/))
  * scikit-learn (a wrapper of [skl2onnx converter](https://github.com/onnx/sklearn-onnx/))
  * Apple Core ML
  * Spark ML (experimental)
  * LightGBM
  * libsvm
  * XGBoost
  * H2O
  * CatBoost

  Pytorch has its builtin ONNX exporter check [here](https://pytorch.org/docs/stable/onnx.html) for details.



  You can install latest release of ONNXMLTools from [PyPi](https://pypi.org/project/onnxmltools/):

  ```bash
  pip install onnxmltools
  ```

  or install from source:

  ```bash
  pip install git+https://github.com/microsoft/onnxconverter-common
  pip install git+https://github.com/onnx/onnxmltools
  ```

  If you choose to install `onnxmltools` from its source code, you must set the environment variable `ONNX_ML=1` before installing the `onnx` package.



  This package relies on ONNX, NumPy, and ProtoBuf. If you are converting a model from scikit-learn, Core ML, Keras, LightGBM, SparkML, XGBoost, H2O, CatBoost or LibSVM, you will need an environment with the respective package installed from the list below:

  1. scikit-learn
  2. CoreMLTools (version 3.1 or lower)
  3. Keras (version 2.0.8 or higher) with the corresponding Tensorflow version
  4. LightGBM
  5. SparkML
  6. XGBoost
  7. libsvm
  8. H2O
  9. CatBoost

  ONNXMLTools is tested with Python **3.7+**.



  If you want the converted ONNX model to be compatible with a certain ONNX version, please specify the target_opset parameter upon invoking the convert function. The following Keras model conversion example demonstrates this below. You can identify the mapping from ONNX Operator Sets (referred to as opsets) to ONNX releases in the [versioning documentation](https://github.com/onnx/onnx/blob/main/docs/Versioning.md#released-versions).



  Next, we show an example of converting a Keras model into an ONNX model with `target_opset=7`, which corresponds to ONNX release version 1.2.

  ```python
  import onnxmltools
  from keras.layers import Input, Dense, Add
  from keras.models import Model


  N, C, D = 2, 3, 3


  sub_input1 = Input(shape=(C,))
  sub_mapped1 = Dense(D)(sub_input1)
  sub_model1 = Model(inputs=sub_input1, outputs=sub_mapped1)


  sub_input2 = Input(shape=(C,))
  sub_mapped2 = Dense(D)(sub_input2)
  sub_model2 = Model(inputs=sub_input2, outputs=sub_mapped2)


  input1 = Input(shape=(D,))
  input2 = Input(shape=(D,))
  mapped1_2 = sub_model1(input1)
  mapped2_2 = sub_model2(input2)
  sub_sum = Add()([mapped1_2, mapped2_2])
  keras_model = Model(inputs=[input1, input2], outputs=sub_sum)


  onnx_model = onnxmltools.convert_keras(keras_model, target_opset=7)
  ```



  Here is a simple code snippet to convert a Core ML model into an ONNX model.

  ```python
  import onnxmltools
  import coremltools


  coreml_model = coremltools.utils.load_spec('example.mlmodel')


  onnx_model = onnxmltools.convert_coreml(coreml_model, 'Example Model')


  onnxmltools.utils.save_model(onnx_model, 'example.onnx')
  ```



  Below is a code snippet to convert a H2O MOJO model into an ONNX model. The only prerequisite is to have a MOJO model saved on the local file-system.

  ```python
  import onnxmltools


  onnx_model = onnxmltools.convert_h2o('/path/to/h2o/gbm_mojo.zip')


  onnxmltools.utils.save_model(onnx_model, 'h2o_gbm.onnx')
  ```



  *onnxmltools* converts models into the ONNX format which
  can be then used to compute predictions with the
  backend of your choice.



  You can check the operator set of your converted ONNX model using [Netron](https://github.com/lutzroeder/Netron), a viewer for Neural Network models. Alternatively, you could identify your converted model's opset version through the following line of code.

  ```python
  opset_version = onnx_model.opset_import[0].version
  ```

  If the result from checking your ONNX model's opset is smaller than the `target_opset` number you specified in the onnxmltools.convert function, be assured that this is likely intended behavior. The ONNXMLTools converter works by converting each operator to the ONNX format individually and finding the corresponding opset version that it was most recently updated in. Once all of the operators are converted, the resultant ONNX model has the maximal opset version of all of its operators.

  To illustrate this concretely, let's consider a model with two operators, Abs and Add. As of December 2018, [Abs](https://github.com/onnx/onnx/blob/main/docs/Operators.md#abs) was most recently updated in opset 6, and [Add](https://github.com/onnx/onnx/blob/main/docs/Operators.md#add) was most recently updated in opset 7. Therefore, the converted ONNX model's opset will always be 7, even if you request `target_opset=8`. The converter behavior was defined this way to ensure backwards compatibility.

  Documentation for the [ONNX Model format](https://github.com/onnx/onnx) and more examples for converting models from different frameworks can be found in the [ONNX tutorials](https://github.com/onnx/tutorials) repository.



  All converter unit test can generate the original model and converted model to automatically be checked with
  [onnxruntime](https://pypi.org/project/onnxruntime/) or
  [onnxruntime-gpu](https://pypi.org/project/onnxruntime-gpu/).
  The unit test cases are all the normal python unit test cases, you can run it with pytest command line, for example:

  ```bash
  python -m pytest --ignore .\tests\
  ```

  It requires *onnxruntime*, *numpy* for most models,
  *pandas* for transforms related to text features, and
  *scipy* for sparse features. One test also requires
  *keras* to test a custom operator. That means
  *sklearn* or any machine learning library is requested.



  Once the converter is implemented, a unit test is added
  to confirm that it works. At the end of the unit test, function
  *dump_data_and_model* or any equivalent function must be called
  to dump the expected output and the converted model.
  Once these file are generated, a corresponding test must
  be added in *tests_backend* to compute the prediction
  with the runtime.



  [Apache License v2.0](LICENSE)


pkgId: 1b9d47f860370930202272fd71d218393a0fcd2d71966af377b0af7db24638ff
name: python-onnxslim-help
arch: noarch
version: 0.1.44
epoch: 0
release: 1
summary: Development documents and examples for onnxslim
url: https://github.com/inisis/OnnxSlim
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-onnxslim-0.1.44-1.src.rpm
location_href: Packages/python-onnxslim-help-0.1.44-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://pypi.org/project/onnxslim">
          <img src="https://badgen.net/pypi/v/onnxslim?color=blue" />
      </a>
      <a href="https://pypi.org/project/onnxslim">
          <img src="https://static.pepy.tech/badge/onnxslim/week" />
      </a>
      <a href="https://pypi.org/project/onnxslim">
          <img src="https://static.pepy.tech/badge/onnxslim/month" />
      </a>
      <a href="https://pypi.org/project/onnxslim">
          <img src="https://static.pepy.tech/badge/onnxslim" />
      </a>
      <a href="https://github.com/inisis/onnxslim/actions/workflows/ci.yaml">
          <img src="https://github.com/inisis/onnxslim/actions/workflows/ci.yml/badge.svg" />
      </a>
  </p>

  OnnxSlim can help you slim your onnx model, with less operators, but same accuracy, better inference speed.

  - 🚀 OnnxSlim is merged to [mnn-llm](https://github.com/wangzhaode/mnn-llm), performance increased by 5%
  - 🚀 Rank 1st in the [AICAS 2024 LLM inference optimization challenge](https://tianchi.aliyun.com/competition/entrance/532170/customize440) held by Arm and T-head
  - 🚀 OnnxSlim is merged into [ultralytics](https://github.com/ultralytics/ultralytics) ❤️❤️❤️
  - 🚀 OnnxSlim is merged into [transformers.js](https://github.com/xenova/transformers.js) 🤗🤗🤗





  ```bash
  pip install onnxslim
  ```



  ```bash
  pip install git+https://github.com/inisis/OnnxSlim@main
  ```



  ```bash
  git clone https://github.com/inisis/OnnxSlim && cd OnnxSlim/
  pip install .
  ```



  ```
  onnxslim your_onnx_model slimmed_onnx_model
  ```

  <div align=left><img src="https://raw.githubusercontent.com/inisis/onnxslim/main/images/onnxslim.gif"></div>

  For more usage, see onnxslim -h or refer to our [examples](./examples)



  - <img src="https://avatars.githubusercontent.com/u/131524?s=48&v=4" width="22" height="22"/>[Mozilla/smart_autofill](https://github.com/mozilla/smart_autofill)
  - <img src="https://avatars.githubusercontent.com/u/1961952?s=48&v=4" width="22" height="22"/>[alibaba/MNN](https://github.com/alibaba/MNN)
  - <img src="https://avatars.githubusercontent.com/u/23534030?s=48&v=4" width="22" height="22"/>[PaddlePaddle/PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)
  - <img src="https://avatars.githubusercontent.com/u/25720743?s=48&v=4" width="22" height="22"/>[huggingface/transformers.js](https://github.com/huggingface/transformers.js)
  - <img src="https://avatars.githubusercontent.com/u/86091366?s=48&v=4" width="22" height="22"/>[THU-MIG/yolov10](https://github.com/THU-MIG/yolov10)
  - <img src="https://avatars.githubusercontent.com/u/26833451?s=48&v=4" width="22" height="22"/>[ultralytics/ultralytics](https://github.com/ultralytics/ultralytics)
  - <img src="https://avatars.githubusercontent.com/u/1961952?s=48&v=4" width="22" height="22"/>[alibaba/MNN-LLM](https://github.com/wangzhaode/mnn-llm)
  - <img src="https://avatars.githubusercontent.com/u/126587470?s=48&v=4" width="22" height="22"/>[deepghs/imgutils](https://github.com/deepghs/imgutils)



  > - [onnx-graphsurgeon](https://github.com/NVIDIA/TensorRT/tree/main/tools/onnx-graphsurgeon)
  > - [Polygraphy](https://github.com/NVIDIA/TensorRT/tree/main/tools/Polygraphy/polygraphy)
  > - [onnx-simplifier](https://github.com/daquexian/onnx-simplifier)
  > - [tabulate](https://github.com/astanin/python-tabulate)
  > - [onnxruntime](https://github.com/microsoft/onnxruntime)



  Discord: https://discord.gg/nRw2Fd3VUS QQ Group: 873569894


pkgId: f7fbf31933e85336ff21f4f7b275810f2b0a40bda7314cd0f6fee8b16b5da2bc
name: python-onprem-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for onprem
url: https://github.com/amaiya/onprem
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-onprem-0.7.0-1.src.rpm
location_href: Packages/python-onprem-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  *Latest News* 🔥
  - \[2024/12\] v0.7.0 released and now includes support for [structured
    outputs](https://amaiya.github.io/onprem/#structured-and-guided-outputs).
  - \[2024/12\] v0.6.0 released and now includes support for PDF to
    Markdown conversion (which includes Markdown representations of
    tables), as shown
    [here](https://amaiya.github.io/onprem/#extract-text-from-documents).
  - \[2024/11\] v0.5.0 released and now includes support for running LLMs
    with Hugging Face
    [transformers](https://github.com/huggingface/transformers) as the
    backend instead of
    [llama.cpp](https://github.com/abetlen/llama-cpp-python). See [this
    example](https://amaiya.github.io/onprem/#using-hugging-face-transformers-instead-of-llama.cpp).
  - \[2024/11\] v0.4.0 released and now includes a `default_model`
    parameter to more easily use models like **Llama-3.1** and
    **Zephyr-7B-beta**.
  - \[2024/10\] v0.3.0 released and now includes support for
    [concept-focused
    summarization](https://amaiya.github.io/onprem/examples_summarization.html#concept-focused-summarization)
  - \[2024/09\] v0.2.0 released and now includes PDF OCR support and
    better PDF table handling.
  - \[2024/06\] v0.1.0 of **OnPrem.LLM** has been released. Lots of new
    updates!
    - [Ability to use with any OpenAI-compatible
      API](https://amaiya.github.io/onprem/#connecting-to-llms-served-through-rest-apis)
      (e.g., vLLM, Ollama, OpenLLM, etc.).
    - Pipeline for [information
      extraction](https://amaiya.github.io/onprem/examples_information_extraction.html)
      from raw documents.
    - Pipeline for [few-shot text
      classification](https://amaiya.github.io/onprem/examples_classification.html)
      (i.e., training a classifier on a tiny number of labeled examples)
      along with the ability to explain few-shot predictions.
    - Default model changed to
      [Mistral-7B-Instruct-v0.2](https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF)
    - [API augmentations and bug


pkgId: bca8c8e5d8bb7127934fd05d6032bf6c7bd7534ddbb2a9095daea099547ace1e
name: python-ons-metadata-validation-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for ons-metadata-validation
url: https://pypi.org/project/ons-metadata-validation/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ons-metadata-validation-1.0.0-1.src.rpm
location_href: Packages/python-ons-metadata-validation-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This project is for automatically validating metadata templates that accompany IDS data deliveries. The fields in a filled metadata template are each checked against a set of defined conditions.

  For example, many fields are mandatory; many have a maximum number of characters; some fields are not allowed to contain spaces or special characters; and so on.

  A metadata template with missing mandatory values or other issues with its format or content will prevent the accompanying dataset from being ingested. This then requires the back-and-forth of resubmission, and causes delays.



  This tool produces an excel report detailing failed validation checks for a given metadata template. There are also two optional outputs:

  * A commented version of the input file, where cells with validation issues are highlighted and a mouseover note names each check that has failed.

  * An edited version of the input file, where cells with easily-fixed issues such as missing full stops or trailing whitespace have been automatically updated.

  *Note that some metadata requirements cannot be programmatically validated. Some human inspection will always be necessary, for example to sense-check free text fields.*

  The tool is designed to work with metadata templates from v2.0 onwards. When pointed at a later version of the template, it should identify the version and update its expectations of the form's format without requiring specific input from the user.



  This readme is written for the benefit of end users, such as the CMAR team. It aims to make minimal assumptions about previous experience.

  A **recorded demo and tutorial** is available on SharePoint for internal users. If you are unsure where to find it, please contact us using the email address below.

  More technical documentation for future developers and maintainers can be found in the documentation folder.

  Future versions of this tool will increase the supporting information available in the validation output report, for example by listing the exact set of checks run for each variable.



  metadata.validation.tool@ons.gov.uk

  Please contact us if you wish to report any issues or bugs, or to request features. Which tables of the output report were most useful? Did you prefer the aggregated tables, or the commented version with individual cells highlighted?

  Also, we cannot currently guarantee that there will be no false positives or false negatives in the output, so your feedback is very valuable!

  Please also contact us if you are using this tool and haven't yet spoken to us, the developers. We wish to keep in contact with our community of users.





  *The commands below are for use in a command prompt terminal, such as Anaconda Powershell.*

  To install this package:
  `pip3 install ons-metadata-validation`



  Default settings have been set so that a general non-technical user will not often need to specify optional parameters.

  The only parameter that must be specified each time the tool is used is the location of the filled metadata template to validate. This can be specified as an absolute or relative path.

  Thus, to use as CMAR with all default settings:
  `python3 -m ons_metadata_validation "path/to/file.xlsx"`

  This will produce an excel file reporting on failed validation checks. It will be saved in the same folder as the input file.

  Note that the tool will not be able to 'see' files on SharePoint. You will need to either map your sharepoint location to a drive, or download the filled template file first.

  Note that the ability to process all metadata templates in a specified folder is planned for a future release.



  Optional parameters always come after the filename when calling the command.


  This tool is designed for users of at various pipeline stages and in various contexts. Some template variables are populated later, and therefore might not exist yet for upstream users. This parameter is used to select the appropriate set of variables to check.

  * default: "cmar"
  * choices: ["cmar", "full"]

  Example:
      `python3 -m ons_metadata_validation "path/to/file.xlsx" variable_check_set="full"`


  Whether or not to save the output report.

  * default: True
  * choices: True, False

  Example:
      `python3 -m ons_metadata_validation "path/to/file.xlsx" save_report=False`


  Whether or not to save a copy of the metadata template with invalid cells highlighted and commented. Please note that you must then update and resubmit the original file - do not edit and submit this copy!

  * default: True
  * choices: True, False

  Example:
      `python3 -m ons_metadata_validation "path/to/file.xlsx" save_commented_copy=True`


  Some simple validation issues, such as missing full stops, double spaces, or trailing whitespace, can be fixed programmatically. Setting this parameter to True will save an edited copy of the original file.

  * default: True
  * choices: True, False

  Example:
      `python3 -m ons_metadata_validation "path/to/file.xlsx" save_corrected_copy=True`



  By default, all outputs are saved in the same folder as the input file. However, you can specify a different location if you wish. This is only for specifying the output folder; the *names* of individual outputs combine the input file's name with a description indicating the type of output.

  * default: None

  Example:
      `python3 -m ons_metadata_validation "path/to/file.xlsx" destination_folder="some/other/directory"`





  Validation checks are considered to be "hard" or "soft".

  Hard checks are conditions that must be satisfied for the ingest pipeline to work successfully. Failing a hard check means that action must be taken before the metadata form can be submitted.	For example, a hard check may inspect whether a mandatory field contains an expected and machine-readable value, without leading or trailing whitespace.

  Soft checks are checks that require inspection, but not necessarily action, if they fail. Though they are still important for high quality metadata, they won't prevent a minimum successful ingest. For example, a soft check may inspect the format and style of a field to ensure that it is useful and legible to humans.

  In the commented output, cells containing *any* hard check fails are colour coded in orange. They may also contain soft check fails.

  Cells containing *only* soft check fails are highlighted in yellow.



  Most checks only care about single values and thus only need to look at one cell at a time. Others require information from all the cells in a column; multiple columns in a row; or multiple sheets across the template.

  Comparative checks involve more than one cell value at a time. For example, a column of table names might require that each name be unique within that column. Or, for consistency, a table name appearing on one sheet might be required to also appear on a list of tables from a previous sheet.

  Comparative checks are also either hard or soft, as defined above.



  | Sheet                         | Variables          | Checks        | Description                                                                                                                                     |
  |-------------------------------|--------------------|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
  | single_validation_checks      | All                | Hard and Soft | Summarises checks that care only about single cell values at a time. Details the checks employed during this run, pass or fail.             |
  | rowwise_validations           | All                | Comparative   | Summarises comparative checks that look along whole rows of metadata. Details the checks employed during this run, pass or fail.            |
  | comparative_validations       | All                | Comparative   | Summarises comparative checks that look across multiple tabs. Details the checks employed during this run, pass or fail.                    |
  | Short % overview              | Mandatory only     | Hard and Soft | Each row is a tab & variable name combination; columns list the % of records that are missing or failed a) any hard or b) only soft checks. |
  | Long % overview               | Mandatory only     | Hard and Soft | Each row is a tab & variable name combination; columns are fail %s for every check. This tab is still in development.                       |
  | Fails by value                | All                | Hard and Soft | Each row details a value appearing in a variable, all the cells that value appears in, and all the hard and soft checks that value fails.   |
  | Fails by cell - Mandatory     | Mandatory only     | Hard and Soft | Each row details the names of all hard and soft checks failed by a single cell in a mandatory field.                                          |
  | Fails by check - Hard         | All                | Hard          | Each row details the cells of a single variable that have failed a particular hard check.                                                     |
  | Missing values                | All mandatory      | Missingness   | each row details the cells with missing values for a single variable.                                                                         |
  | Comparative check fails       | All                | Comparative   | Each row details one instance of a failed comparative check.                                                                                  |
  | Fails by cell - Non Mandatory | Non-mandatory only | Hard and Soft | Each row details the names of all hard and soft checks failed by a single cell in a non-mandatory (optional or conditional) field.          |
  | Fails by check - Soft         | All                | Soft          | Each row details the cells of a single variable that have failed a particular soft check.                                                     |



  It can be hard to decide where and how to flag comparative check failures. For example, if a column should contain only unique values but contains duplicates, each cell containing a duplicate should be flagged.



  As mentioned above, **the use of this tool is not a substitute for human involvement in the validation process**. Do not solely trust in this tool to detect all and only the validation issues on your metadata form.

  * Many fields, such as descriptions and notes, contain free text. These should be read by a human to ensure that they are intelligible, useful, and appropriate.

  * The tool inspects urls and email addresses provided on the metadata form solely in terms of whether their string format is plausible. It cannot check whether their destinations are active, correct, and publicly accessible.

  * Dataset, table, and file names ought to be concise and meaningfully descriptive of the data contained within. Naming standards for GCP objects are available internally on SharePoint.

  * The tool, and the guidance, discourage acronyms and abbreviations, for the sake of clarity. However, acronyms that are widely understood, such as UK and NHS, are permissible. Judgement may be needed when acronyms and abbreviations are nonetheless needed due to character limits or brevity in free text.

  * In general, the tool focuses on validation limitations where certain responses are 100% unacceptable or impossible, such as a precision of 0. Human assessment is required when values are *implausible* but still *possible*, such as suspiciously large numbers of files / header rows / etc.



  * Expression of cell ranges on some of the tabular output sheets are unintentionally duplicated.

  * Checks that handle short and long date formats do not produce intended results for certain inputs.


pkgId: bd8ab2faef5b9a8a446c6d2c9220823416229125eff74c2c8f6615a93fbfda54
name: python-ontobio-help
arch: noarch
version: 2.9.12
epoch: 0
release: 1
summary: Development documents and examples for ontobio
url: https://github.com/biolink/ontobio
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ontobio-2.9.12-1.src.rpm
location_href: Packages/python-ontobio-help-2.9.12-1.noarch.rpm
checksum_type: sha256
description:
  This module provides objects and utility methods for working with
  ontologies and associations of entities (genes, variants, etc) to
  ontology classes.
  The ontologies and associations can either be local files or provided by
  remote services (currently the OntoBee SPARQL service for ontologies and
  a Monarch or GO Golr service for associations).


pkgId: 5c98c5dab476ffbf306d32e76cbb6bcbd0e70eaff4d3ff2b724c68d1110bd62c
name: python-opcal-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for opcal
url: https://pypi.org/project/opcal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opcal-0.0.0-1.src.rpm
location_href: Packages/python-opcal-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Source code for labs.


  - Lab1 (Solution of Equations)
      - Solution of Linear Equations System.
          - Principle Component Method
          - Jacobi Iteration ALgorithm
          - Gauss-Seidel Iteration Algorithm
      - Solution of Nolinear Equations. (!:TODO: how to define the loss of secant method?)
          - Bisection Method
          - Newton's Method
          - Secant Method
  - Lab2 (Interpolation)
      - 1D Interpolation Methods.
          - Lagrange interpolation
          - Newtonian interpolation
          - cubic spline interpolation
          - Aitken interpolation
          - Hermit interpolation
      - Higher Dimensional Interpolation Methods. (TODO)
          - 2D
          - 3D
  - Lab3 (Optimisation)
      - approximation of functions (TODO)
  - Lab4 (Difference Equations)
      - Solution of Differential Equations (TODO)
      - Solution of Non-Linear Differential Equations (TODO)




  - Lab1 (Gradient Descent)
      - Stochastic Gradient Descent (TODO)
      - Mini-Batch Gradient Descent (TODO)
      - Batch Gradient Descent (TODO)
      - Adaptive Moment Estimation (TODO)
      - Momentum (TODO)
      - Nesterov Accelerated Gradient Descent (TODO)
      - RMSprop (TODO)
      - Adam (TODO)
      - NAG (TODO)
      - Adagrad (TODO)
      - Adadelta (TODO)
  - Lab2 (Heuristic Methods)
      - Genetic Algorithm
      - Particle Swarm Optimization (TODO)
      - Multi-Layer Perceptron (TODO)
      - Ant Colony optimization (TODO)
      - Simulated Annealing (TODO)


pkgId: 4d78e8665b58d726a3ef0498047769fbac261901e8b225fd3f8feec9d277b326
name: python-open-cravat-help
arch: noarch
version: 2.11.0
epoch: 0
release: 1
summary: Development documents and examples for open-cravat
url: https://www.opencravat.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-open-cravat-2.11.0-1.src.rpm
location_href: Packages/python-open-cravat-help-2.11.0-1.noarch.rpm
checksum_type: sha256
description:
  Open-CRAVAT is a python package that performs genomic variant interpretation including variant impact, annotation, and scoring.
  It has a modular architecture with a wide variety of analysis modules that are developed both by
  the CRAVAT team and the broader variant analysis community. Open-CRAVAT is a product of the `Karchin Lab`_
  at Johns Hopkins University with funding provided by the National
  Cancer Institute's `ITCR`_ program.

  .. _Karchin Lab: http://karchinlab.org
  .. _ITCR: https://itcr.cancer.gov

  Please see: `Open-CRAVAT Docs`_ for installation instructions and software documentation.

  .. _Open-CRAVAT Docs: https://open-cravat.readthedocs.io


pkgId: 0828793818d2ee59a27a7e30ba48f3ec60346134df72a052bbf845d838ff1b13
name: python-open-intent-classifier-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for open-intent-classifier
url: https://github.com/SerjSmor/open-intent-classifier
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-open-intent-classifier-0.0.7-1.src.rpm
location_href: Packages/python-open-intent-classifier-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  Closed intent classification uses a set of predefined labels to identify an intent.
  In comparison, open intent classification allows you to define as many labels you want, without fine tuning the model.

  This project implements different components that support open intent classification such as an embedder, a T5 based fine tuned model for intent classification and a verbalizer.
  If you are interested in finer detailes you can read my [blog post](https://medium.com/80-20-hacking-ai/components-that-optimize-n-shot-text-classification-f574184e0b81).

  The goal of this library is to enable you test your assumptions about your data as fast as possible and to be a one stop shop for everything "classification like", similarly to how [Bertopic](https://maartengr.github.io/BERTopic/index.html) is for clustering.


  1. You are researching nlp classification problems and want to test different embeddings, verbalizers and components with plug-and-play feel
  2. You want to detect semantically user intents in text but either don't want to commit to pre-defined classes OR just want to test out the fastest way to classify text other than through an LLM


  [!IMPORTANT]
  > open-intent-classification project is in Alpha stage.
  > 1. Expect API changes
  > 2. Milage may vary. Quality of classifiers have been tested on Atis and Banking77


  `$ pip install open-intent-classifier`


  A full example is under [Atis Notebook](https://github.com/SerjSmor/open-intent-classifier/blob/main/notebooks/atis_example.ipynb)


  ````python
  from open_intent_classifier.model import IntentClassifier
  model = IntentClassifier()
  labels = ["Cancel Subscription", "Refund Requests", "Broken Item", "And More..."]
  text = "I don't want to continue this subscription"
  predicted_label = model.predict(text, labels)
  ````

  By default, the IntentClassifier is loading a small model with 80M parameters.

  For higher accuracy you can initialize the model with:
  ```python
  from open_intent_classifier.model import IntentClassifier
  from open_intent_classifier.consts import INTENT_CLASSIFIER_248M_FLAN_T5_BASE
  model = IntentClassifier(INTENT_CLASSIFIER_248M_FLAN_T5_BASE)
  ```
  This will increase model latency as well.



  ```python
  from open_intent_classifier.embedder import StaticLabelsEmbeddingClassifier
  labels = ["Cancel Subscription", "Refund Requests", "Broken Item", "And More..."]
  text = "I don't want to continue this subscription"
  embeddings_classifier = StaticLabelsEmbeddingClassifier(labels)
  predicted_label = embeddings_classifier.predict(text)

  ```


  Using LLM for classification is a viable option that sometimes provides the highest quality.
  Currently we have implemented Open AI based LLMs.

  ```python
  from open_intent_classifier.model import OpenAiIntentClassifier
  labels = ["Cancel Subscription", "Refund Requests", "Broken Item", "And More..."]
  text = "I don't want to continue this subscription"
  model_name = "gpt-4o-mini"
  classifier = OpenAiIntentClassifier(model_name)
  result = classifier.predict(text=text, labels=labels)
  ```


  Here's an example of using DSPy based classifier for both educational purposes and potential increase in quality.
  ```python
  from open_intent_classifier.model import DSPyClassifier
  classifier = DSPyClassifier()
  labels = ["Cancel subscription", "Refund request"]
  text = "I want to cancel my subscription"
  result = classifier.predict(text, labels)
  ```


  Here's an example of using SmolLM2 based classifier
  ```python
  from open_intent_classifier.model import SmolLm2Classifier
  classifier = SmolLm2Classifier()
  labels = ["Cancel subscription", "Refund request"]
  text = "I want to cancel my subscription"
  result = classifier.predict(text, labels)
  ```




  The details of training of the classifier is in another repository. I have separated training from inference in order to allow each repository to be focused and extended.

  You can read about the training in the training repo: https://github.com/SerjSmor/intent_classification



  - [x] Add LLM based classification
  - [x] Add DSPy based classification
  - [x] Add small language models as classifiers
  - [x] Add few shot interface
  - [ ] Add embeddings filtering stage for classifiers
  - [ ] Add multithreading for LLM based classifiers
  - [ ] Add an option to ensemble embeddings and T5 (and additional models)
  - [ ] Create a recommender for fine-tuning


pkgId: 7244b814e940c5f5fc3e9922dc29c76696e67220d46105be95d6a11842f32cde
name: python-open-quant-data-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for open-quant-data
url: https://github.com/openhe-hub/open-quant-data.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-open-quant-data-0.3.2-1.src.rpm
location_href: Packages/python-open-quant-data-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  This is open source quant framework for local dataset generation
  , third-party dataset api analysis, and quant data statistics



  This feature need support from `open-quant-spider`, by
  reading the data recording by `open-quant-spider` from
  Mysql or Redis. The framework export the dataset as csv
  files

  Sometimes we may have insufficient data from local recording,
  so we plan to support third-party data sources. Currently,
  we support `Akshare` and `Xtquant + MiniQMT`, which includes
  stock, bond, etf, in-market fund history data with multi formats.

  The core statistics module's aim is to do factor statistics and
  dataset utils.


pkgId: 8d7b13322d2397254d83a7f9839b736545a5133b4b834e6d86f406914b684f9b
name: python-open-variant-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for open-variant
url: https://github.com/bbglab/openvariant
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-open-variant-1.0.1-1.src.rpm
location_href: Packages/python-open-variant-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://openvariant.readthedocs.io/">
        <img src="https://github.com/bbglab/openvariant/raw/master/logo.png" width="590" height="350">
      </a>
      <br>
      <br>
    	<a href="https://opensource.org/licenses/BSD-3-Clause">
    		<img alt="License" src="https://img.shields.io/github/license/bbglab/openvariant">
    	</a>
    	<a href="https://pypi.org/project/open-variant/">
    		<img alt="PyPi" src="https://img.shields.io/pypi/v/open-variant">
    	</a>
       <a href="https://github.com/bbglab/openvariant/actions/workflows/openvariant_tester.yml">
           <img alt="Test" src="https://github.com/bbglab/openvariant/actions/workflows/openvariant_tester.yml/badge.svg">
       </a>
      <a href="https://codecov.io/gh/bbglab/openvariant" >
          <img alt="Coverage" src="https://codecov.io/gh/bbglab/openvariant/branch/develop/graph/badge.svg?token=N6HUMWS9U5"/>
      </a>
    	<a href="https://openvariant.readthedocs.io/en/latest/?badge=latest">
    		<img alt="Documentation Status" src="https://readthedocs.org/projects/openvariant/badge/?version=latest">
    	</a>
      <br>
      <br>
  </div>

  OpenVariant is a comprehensive Python package that provides different functionalities to read, parse and operate
  different multiple input file formats (e. g. ``tsv``, ``csv``, ``vcf``, ``maf``, ``bed``), being able to customize the output.

  Its aim is being able to manage a ton of data represented in multiple ways and be able to build an unified output with
  a proper annotation file structure. This package was thought to work with any kind of data that can be represented
  as a table.

  _Documentation_: [https://openvariant.readthedocs.io](https://openvariant.readthedocs.io)



  OpenVariant offers a toolkit to transform and operate the parsed input data. We will be able to apply different
  functionalities on our parsed result some of them are the following ones:

  - Find files
  - Read and save
  - Cat
  - Group by
  - Count
  - Command-line interface (CLI)
  - Plugins

  <div align="center">
    <a href="https://openvariant.readthedocs.io/en/latest/user_guide.html">
      <img src="https://github.com/bbglab/openvariant/raw/master/workflow.gif" width="600" height="352">
    </a>
  </div>

  Check [User guide](https://openvariant.readthedocs.io/en/latest/user_guide.html) in OpenVariant's documentation to find all the information about how it works
  and how can be applied the different functionalities.



  It requires Python 3 or higher and can be installed as [PyPI package](https://pypi.org/project/open-variant/) with:

  ```bash
  pip install open-variant
  ```

  For more details check our [Installation](https://openvariant.readthedocs.io/en/latest/installation.html) section.



  We provide a variety of [examples](https://github.com/bbglab/openvariant/tree/master/examples) to help to understand how OpenVariant can be applied. Explore the
  [Examples](https://openvariant.readthedocs.io/en/latest/examples.html) section in OpenVariant's documentation for more details.

  As well, we present a small dataset for hands-on use with OpenVariant, allowing users to test the tool's functionalities. It may be found at [Zenodo](https://zenodo.org/records/14215914) and it can be downloaded using the following commands:
  ```bash
  pip install zenodo_get
  zenodo_get 14215914
  ```



  You're welcome to contribute to the code as much as you'd like!

  Please review the guidelines outlined in the [Contributing](https://github.com/bbglab/openvariant/blob/master/CONTRIBUTING.md) document and adhere to the standards of conduct detailed in the [Code of Conduct](https://github.com/bbglab/openvariant/blob/master/CODE_OF_CONDUCT.md).



  The software is licensed under [BSD-3-Clause](https://github.com/bbglab/openvariant/blob/master/LICENSE).



  If you use OpenVariant in your research, please cite:

  > David Martínez-Millán, Federica Brando, Miguel L. Grau, Mònica Sánchez-Guixé, Carlos López-Elorduy, Iker Reyes-Salazar, Jordi Deu-Pons, Núria López-Bigas, Abel González-Pérez, OpenVariant: a toolkit to parse and operate multiple input file formats, Bioinformatics, Volume 40, Issue 12, December 2024, btae714, [https://doi.org/10.1093/bioinformatics/btae714](https://doi.org/10.1093/bioinformatics/btae714)

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


pkgId: f9066b80aba9df77b259af377d71f8ea69a2bdf2afe37a6ff981cc55586b6e3c
name: python-open5gsapi-help
arch: noarch
version: 0.15.1
epoch: 0
release: 1
summary: Development documents and examples for open5gsapi
url: https://github.com/ashwinsathish/open5gsapi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-open5gsapi-0.15.1-1.src.rpm
location_href: Packages/python-open5gsapi-help-0.15.1-1.noarch.rpm
checksum_type: sha256
description:
  This package provides a Python API for interacting with Open5GS components and managing PCF configurations.



  First, import the package and set the configuration paths:

  ```python
  from open5gsapi import open5gs


  open5gs.set_config_path('/path/to/pcf.yaml')
  ```
  ```python

  open5gs.set_env_path('/path/to/.env')
  ```

  If the configuration files are edited manually after loading:

  ```python

  open5gs.reload_config()  # Reload PCF configuration
  open5gs.reload_env()     # Reload environment configuration
  ```





  ```python

  current_ues = open5gs.get_num_ues()
  print(f"Current number of UEs: {current_ues}")


  open5gs.set_num_ues(3)
  ```





  ```python

  open5gs.launch_gtp_wireshark()


  open5gs.launch_wireshark(
      ip_address="10.10.0.1",
      display_filter="gtp && ip.addr == 10.10.0.1",
      capture_filter="port 2123 or port 2152"
  )
  ```





  ```python

  UE_API_URL = open5gs.ue("send")



  UPF_API_URL = open5gs.upf("receive/sensor")

  ```



  The API supports sending both JSON data and binary data (like video frames):

  ```python

  data = {
      "sensor_id": 1,
      "temperature": 25.5,
      "humidity": 60
  }
  response = open5gs.send_data(UE_API_URL, data)


  base_port = 8080
  for ue_index in range(num_ues):
      port_offset = ue_index  # Each UE uses a different port (8080 + offset)
      sensor_data = {
          "sensor_id": ue_index,
          "temperature": 25.5
      }
      response = open5gs.send_data(UE_API_URL, sensor_data, port_offset=ue_index)


  ret, buffer = cv2.imencode('.jpg', frame, encode_params)
  frame_data = buffer.tobytes()  # Binary data automatically detected
  response = open5gs.send_data(UE_API_URL, frame_data)



  received_data = open5gs.receive_data(UPF_API_URL)
  if received_data:
      print(f"Received sensor data: {received_data}")


  frame_data = open5gs.receive_data(UPF_STREAM_URL)
  if frame_data:  # Binary data automatically detected by content-type
      return Response(frame_data, mimetype='image/jpeg')
  ```

  The `send_data` and `receive_data` methods automatically:
  - Detect data type (JSON vs binary)
  - Handle appropriate content types
  - Collect network performance metrics
  - Support port offsets for multiple UEs
  - Handle errors with appropriate exceptions



  The API automatically collects and provides network performance metrics based on the type of data transfer:


  For binary data like video frames, use `get_metrics()`:

  ```python

  metrics = open5gs.get_metrics()  # For binary data/video frames
  print(f"Throughput: {metrics['throughput']['total_mbps']} Mbps")
  print(f"Average latency: {metrics['latency']['avg_ms']} ms")


  {
      "throughput": {
          "total_mbps": 2.5,        # Total throughput in Mbps
      },
      "latency": {
          "min_ms": 10.5,           # Minimum latency
          "max_ms": 50.2,           # Maximum latency
          "avg_ms": 25.7,           # Average latency
          "jitter_ms": 5.2          # Latency variation
      },
      "packets": {
          "total": 1000,            # Total packets sent
          "avg_size_bytes": 1024    # Average packet size
      }
  }


  frame_metrics = open5gs.get_frame_metrics()
  if frame_metrics:
      print(f"Current FPS: {frame_metrics['frame_rate']['current_fps']}")
      print(f"Average frame size: {frame_metrics['frame_size']['avg_bytes']/1024:.1f} KB")


  {
      "frame_metrics": {
          "total_frames": 300,
          "frame_rate": {
              "current_fps": 30.0,
              "frame_time_ms": 33.3,
              "frame_time_variation_ms": 1.2
          },
          "frame_size": {
              "avg_bytes": 51200,
              "max_bytes": 65536,
              "min_bytes": 32768
          },
          "latency": {
              "min_ms": 15.0,
              "max_ms": 45.0,
              "avg_ms": 25.0,
              "jitter_ms": 5.0
          }
      }
  }


  open5gs.reset_metrics()
  ```


  For JSON data like sensor readings, use `get_sensor_metrics()`:

  ```python

  sensor_metrics = open5gs.get_sensor_metrics()  # For JSON data/sensor readings
  print(f"Reading rate: {sensor_metrics['sensor_metrics']['reading_rate']['current_rps']} readings/sec")
  print(f"Lost readings: {sensor_metrics['sensor_metrics']['reading_rate']['readings_lost']}")


  {
      "throughput": {
          "total_mbps": 1.5        # Total throughput in Mbps
      },
      "latency": {
          "min_ms": 5.0,           # Minimum latency
          "max_ms": 25.0,          # Maximum latency
          "avg_ms": 15.0,          # Average latency
          "jitter_ms": 2.5         # Latency variation
      },
      "sensor_metrics": {
          "reading_rate": {
              "current_rps": 10.0,           # Readings per second
              "reading_interval_ms": 100.0,   # Average interval between readings
              "total_readings": 1000,        # Total readings received
              "readings_lost": 5             # Number of lost readings
          },
          "by_sensor": {
              "1": {                         # Per-sensor statistics
                  "total_readings": 500,
                  "readings_lost": 2,
                  "latest_value": {"temperature": 25.5},
                  "min_value": {"temperature": 20.0},
                  "max_value": {"temperature": 30.0},
                  "avg_value": 24.5
              }
          }
      }
  }


  open5gs.reset_sensor_metrics()
  ```

  The metrics collection works automatically when using `send_data()` and `receive_data()`. The API detects the data type and uses the appropriate metrics collector:
  - Binary data → Video metrics
  - JSON data with 'sensor_id' → Sensor metrics

  Common utility methods for both types:
  ```python
  throughput = open5gs.get_throughput()           # Current throughput in Mbps
  latency_stats = open5gs.get_latency_stats()     # Latency statistics
  ```





  ```python

  sessions = open5gs.list_sessions()
  print("Current sessions:", sessions)


  session_name = "video-streaming"
  session_details = open5gs.get_session_details(session_name)
  print(f"Details of session '{session_name}':", session_details)
  ```



  ```python

  session = open5gs.policy.session('video-streaming')
  session.ambr.downlink(value=10000000, unit=1)
  session.ambr.uplink(value=20000000, unit=1)
  session.qos(index=5)
  session.arp(priority_level=7, pre_emption_vulnerability=2, pre_emption_capability=1)


  session.pcc_rule[0].qos(index=3)
  session.pcc_rule[0].mbr.downlink(value=2000000, unit=1)
  session.pcc_rule[0].gbr.uplink(value=1000000, unit=1)
  session.pcc_rule[0].add_flow(direction=2, description="permit out ip from any to assigned")
  ```



  ```python

  new_session = open5gs.policy.add_session('new-session-name')
  new_session.ambr.downlink(value=5000000, unit=1)
  new_session.ambr.uplink(value=1000000, unit=1)


  open5gs.policy.remove_session('session-to-remove')


  open5gs.rename_session('old-session-name', 'new-session-name')
  ```



  After making changes to the configuration, you need to update the system:

  ```python

  open5gs.update_pcf()


  open5gs.update_config()


  open5gs.run_background_nodes()
  ```

  You can check the status of these operations:

  ```python

  if open5gs.is_update_pcf_complete():
      print("PCF update complete")

  if open5gs.is_update_config_complete():
      print("Configuration update complete")


  if open5gs.is_run_background_nodes_complete():
      print("Background nodes are running")
  else:
      status = open5gs.get_background_process_status()
      print(f"Background process status: {status}")
  ```





  - `open5gs.set_config_path(path: str)`: Set the PCF configuration file path
  - `open5gs.set_env_path(path: str)`: Set the environment file path
  - `open5gs.reload_config()`: Reload the PCF configuration
  - `open5gs.reload_env()`: Reload the environment configuration
  - `open5gs.get_num_ues() -> int`: Get current number of UEs
  - `open5gs.set_num_ues(num_ues: int)`: Set number of UEs



  - `open5gs.ue(endpoint: str) -> str`: Get the UE API URL
  - `open5gs.upf(endpoint: str) -> str`: Get the UPF API URL
  - `open5gs.send_data(endpoint: str, data: Any, port_offset: int = 0) -> Dict[str, Any]`: Send data to specified endpoint
    - `endpoint`: API endpoint URL
    - `data`: Data to send (JSON or binary)
    - `port_offset`: Port offset for multiple UEs (default=0)
  - `open5gs.receive_data(endpoint: str) -> Any`: Receive data from specified endpoint



  - `open5gs.get_metrics() -> Dict[str, Any]`: Get comprehensive network performance metrics
  - `open5gs.get_frame_metrics() -> Optional[Dict[str, Any]]`: Get frame-specific metrics for video streaming
  - `open5gs.get_throughput() -> float`: Get current throughput in Mbps
  - `open5gs.get_latency_stats() -> Dict[str, float]`: Get latency statistics
  - `open5gs.reset_metrics()`: Reset all network metrics

  The metrics system automatically detects the type of data being transmitted:
  - JSON data (e.g., sensor readings, control messages) → Basic network metrics
  - Binary data (e.g., video frames, images) → Additional frame-specific metrics

  Key metrics provided:
  - Throughput measurement in Mbps
  - Latency statistics (min, max, average, jitter)
  - Packet statistics
  - Frame rate and frame size statistics (for video data)
  - Frame timing and latency statistics (for video data)

  Metrics are collected automatically when using `send_data()` and `receive_data()` methods, requiring no changes to existing code.



  - `open5gs.launch_wireshark(ip_address: str, display_filter: str, capture_filter: str) -> bool`: Launch Wireshark with custom filters
  - `open5gs.launch_gtp_wireshark() -> bool`: Launch Wireshark with GTP filtering



  - `open5gs.list_sessions() -> List[str]`: Get a list of all session names
  - `open5gs.get_session_details(name: str) -> Dict[str, Any]`: Get details of a specific session
  - `open5gs.rename_session(old_name: str, new_name: str)`: Rename a session
  - `open5gs.policy.session(name: str) -> Session`: Get or create a session
  - `open5gs.policy.add_session(name: str) -> Session`: Add a new session
  - `open5gs.policy.remove_session(name: str)`: Remove a session



  - `session.ambr.downlink(value: int, unit: int)`: Set downlink AMBR
  - `session.ambr.uplink(value: int, unit: int)`: Set uplink AMBR
  - `session.qos(index: int)`: Set QoS index
  - `session.arp(priority_level: int, pre_emption_vulnerability: int, pre_emption_capability: int)`: Set ARP parameters



  - `session.pcc_rule[index].qos(index: int)`: Set QoS index for a PCC rule
  - `session.pcc_rule[index].mbr.downlink(value: int, unit: int)`: Set downlink MBR for a PCC rule
  - `session.pcc_rule[index].mbr.uplink(value: int, unit: int)`: Set uplink MBR for a PCC rule
  - `session.pcc_rule[index].gbr.downlink(value: int, unit: int)`: Set downlink GBR for a PCC rule
  - `session.pcc_rule[index].gbr.uplink(value: int, unit: int)`: Set uplink GBR for a PCC rule
  - `session.pcc_rule[index].add_flow(direction: int, description: str)`: Add a flow to a PCC rule



  - `open5gs.update_pcf()`: Update the PCF YAML file
  - `open5gs.update_config()`: Tear down and redeploy containers with new configuration
  - `open5gs.run_background_nodes()`: Run initialization scripts and start background processes in UE and UPF containers



  - `open5gs.is_run_background_nodes_complete() -> bool`: Check if background nodes are running
  - `open5gs.get_background_process_status() -> Dict[str, Any]`: Get detailed status of background processes



  This API uses custom exception classes to handle various error scenarios. When using the API, you may catch the following exceptions:



  Raised when there are issues related to the overall configuration of the Open5GS system. It may occur in the following scenarios:

  - The configuration file (pcf.yaml) cannot be found or read.
  - The environment file (.env) cannot be found or read.
  - There are structural problems with the configuration files.
  - Unable to initialize or access necessary components of the Open5GS system.
  - Attempting to access or modify a non-existent session.
  - Failing to restart the PCF service.
  - Attempting to modify NUM_UES after update_config() has been called.
  - Wireshark is not installed when attempting to launch packet capture.

  Example usage:
  ```python
  try:
      open5gs.set_config_path('/path/to/pcf.yaml')
      open5gs.set_env_path('/path/to/.env')
  except ConfigurationError as e:
      print(f"Configuration error: {e}")
      
  ```



  Raised when the input values provided for specific configuration parameters are invalid or out of the allowed range. It typically occurs when:

  - Setting an invalid QoS index.
  - Providing an out-of-range value for AMBR.
  - Using an incorrect value for ARP parameters.
  - Setting an invalid session type.
  - Adding an invalid flow direction in PCC rules.
  - Setting an invalid number of UEs (must be positive integer).
  - Providing invalid Wireshark filter expressions.

  Example usage:
  ```python
  try:
      session = open5gs.policy.session('internet')
      session.qos(index=100)  # 100 is not a valid QoS index
      open5gs.set_num_ues(0)  # 0 is not a valid number of UEs
  except ValidationError as e:
      print(f"Validation error: {e}")
      
  ```



  Raised when there are issues communicating with the UE or UPF components. It may occur when:

  - Sending data to the UE API fails.
  - Receiving data from the UPF API fails.
  - Unable to establish connection with Wireshark for packet capture.
  - Background nodes (UE/UPF) fail to start or become unresponsive.
  - TUN interfaces are not properly set up for UE communication.

  Example usage 1:
  ```python
  try:
      response = open5gs.send_data(UE_API_URL, data)
      if not open5gs.launch_gtp_wireshark():
          raise CommunicationError("Failed to launch Wireshark")
  except CommunicationError as e:
      print(f"Communication error: {e}")
      
  ```
  Example usage 2:
  ```python

  try:
      for ue_index in range(num_ues):
          data = {"sensor_id": ue_index, "value": 25.5}
          response = open5gs.send_data(UE_API_URL, data, port_offset=ue_index)
  except CommunicationError as e:
      print(f"Communication error: {e}")
      
  ```

  You can also check the detailed status of background processes when encountering errors:

  ```python
  try:
      open5gs.run_background_nodes()
      if not open5gs.is_run_background_nodes_complete():
          status = open5gs.get_background_process_status()
          if status['error_message']:
              raise CommunicationError(f"Background process error: {status['error_message']}")
  except CommunicationError as e:
      print(f"Communication error: {e}")
      
  ```



  ```python

  try:
      metrics = open5gs.get_metrics()
      if metrics['frame_metrics']:  # Frame data detected
          print(f"Streaming performance:")
          print(f"FPS: {metrics['frame_metrics']['frame_rate']['current_fps']}")
          print(f"Frame latency: {metrics['frame_metrics']['latency']['avg_ms']} ms")
      else:  # Regular data
          print(f"Network performance:")
          print(f"Throughput: {metrics['throughput']['total_mbps']} Mbps")
          print(f"Latency: {metrics['latency']['avg_ms']} ms")
  except Exception as e:
      print(f"Error getting metrics: {e}")
      
  ```

  Metrics are collected with microsecond precision using monotonic time to ensure accurate measurements.


pkgId: adcc4e1afc31233c8f2cd62f12f03f9a021084318cc9f28d456f7891691dd6fe
name: python-openaerostruct
arch: noarch
version: 2.9.1
epoch: 0
release: 1
summary: OpenAeroStruct
url: https://github.com/mdolab/OpenAeroStruct
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openaerostruct-2.9.1-1.src.rpm
location_href: Packages/python-openaerostruct-2.9.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://dev.azure.com/mdolab/Public/_apis/build/status%2Fmdolab.OpenAeroStruct?repoName=mdolab%2FOpenAeroStruct&branchName=main)](https://dev.azure.com/mdolab/Public/_build/latest?definitionId=49&repoName=mdolab%2FOpenAeroStruct&branchName=main)
  [![codecov](https://codecov.io/gh/mdolab/OpenAeroStruct/branch/main/graph/badge.svg?token=yOxeH7rT2H)](https://codecov.io/gh/mdolab/OpenAeroStruct)
  [![Documentation Status](https://readthedocs.com/projects/mdolab-openaerostruct/badge/?version=latest)](https://mdolab-openaerostruct.readthedocs-hosted.com/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/openaerostruct)](https://pypi.org/project/openaerostruct/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/openaerostruct)](https://pypi.org/project/openaerostruct/)
  OpenAeroStruct is a lightweight tool that performs aerostructural optimization using OpenMDAO.
  It couples a vortex-lattice method (VLM) and a 6 degrees of freedom 3-dimensional spatial beam model to simulate aerodynamic and structural analyses using lifting surfaces.
  These simulations are wrapped with an optimizer using NASA's OpenMDAO framework.
  The analysis and optimization results can be visualized using included tools, producing figures such as these:
  *With a tubular structure*
  ![Example](https://raw.githubusercontent.com/mdolab/OpenAeroStruct/main/openaerostruct/docs/figures/example.png)
  *With a wingbox structure*
  ![Example2](https://raw.githubusercontent.com/mdolab/OpenAeroStruct/main/openaerostruct/docs/figures/wingbox_fine.png)
  Please note that this repository is provided as is without any guaranteed support.
  If you would like to highlight issues, ask questions, or make changes, please do so using GitHub Issues and Pull Requests.
  The developers will address them at their discretion.
  The easiest way to get started is by installing OpenAeroStruct via the Python Package Index with
  `pip install openaerostruct`
  If you'd like easier access to the examples and source code, install OpenAeroStruct by cloning this repository and entering the folder it generates.
  Then do:
  `pip install -e .`


pkgId: 2358b6961c55fb20a712b204abd4c8b504ee092df244e406fd7f173cc2c30594
name: python-openai-gradio-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for openai-gradio
url: https://pypi.org/project/openai-gradio/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openai-gradio-0.0.5-1.src.rpm
location_href: Packages/python-openai-gradio-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Note: if you are getting a 401 authentication error, then the OpenAI API Client is not able to get the API token from the environment variable. This happened to me as well, in which case save it in your Python session, like this:
  ```py
  import os
  os.environ["OPENAI_API_KEY"] = ...
  ```


pkgId: fe495bf6cc7aaeddcb32b2536cbef884744007a69c73f16d4d2070558cdd3e42
name: python-openai-help
arch: noarch
version: 1.57.4
epoch: 0
release: 1
summary: Development documents and examples for openai
url: https://github.com/openai/openai-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openai-1.57.4-1.src.rpm
location_href: Packages/python-openai-help-1.57.4-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/openai.svg)](https://pypi.org/project/openai/)

  The OpenAI Python library provides convenient access to the OpenAI REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated from our [OpenAPI specification](https://github.com/openai/openai-openapi) with [Stainless](https://stainlessapi.com/).



  The REST API documentation can be found on [platform.openai.com](https://platform.openai.com/docs). The full API of this library can be found in [api.md](https://github.com/openai/openai-python/tree/main/api.md).



  > [!IMPORTANT]
  > The SDK was rewritten in v1, which was released November 6th 2023. See the [v1 migration guide](https://github.com/openai/openai-python/discussions/742), which includes scripts to automatically update your code.

  ```sh

  pip install openai
  ```



  The full API of this library can be found in [api.md](https://github.com/openai/openai-python/tree/main/api.md).

  ```python
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
  )

  chat_completion = client.chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Say this is a test",
          }
      ],
      model="gpt-4o",
  )
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `OPENAI_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  With a hosted image:

  ```python
  response = client.chat.completions.create(
      model="gpt-4o-mini",
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": prompt},
                  {
                      "type": "image_url",
                      "image_url": {"url": f"{img_url}"},
                  },
              ],
          }
      ],
  )
  ```

  With the image as a base64 encoded string:

  ```python
  response = client.chat.completions.create(
      model="gpt-4o-mini",
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": prompt},
                  {
                      "type": "image_url",
                      "image_url": {"url": f"data:{img_type};base64,{img_b64_str}"},
                  },
              ],
          }
      ],
  )
  ```



  When interacting with the API some actions such as starting a Run and adding files to vector stores are asynchronous and take time to complete. The SDK includes
  helper functions which will poll the status until it reaches a terminal state and then return the resulting object.
  If an API method results in an action that could benefit from polling there will be a corresponding version of the
  method ending in '\_and_poll'.

  For instance to create a Run and poll until it reaches a terminal state you can run:

  ```python
  run = client.beta.threads.runs.create_and_poll(
      thread_id=thread.id,
      assistant_id=assistant.id,
  )
  ```

  More information on the lifecycle of a Run can be found in the [Run Lifecycle Documentation](https://platform.openai.com/docs/assistants/how-it-works/run-lifecycle)



  When creating and interacting with vector stores, you can use polling helpers to monitor the status of operations.
  For convenience, we also provide a bulk upload helper to allow you to simultaneously upload several files at once.

  ```python
  sample_files = [Path("sample-paper.pdf"), ...]

  batch = await client.vector_stores.file_batches.upload_and_poll(
      store.id,
      files=sample_files,
  )
  ```



  The SDK also includes helpers to process streams and handle incoming events.

  ```python
  with client.beta.threads.runs.stream(
      thread_id=thread.id,
      assistant_id=assistant.id,
      instructions="Please address the user as Jane Doe. The user has a premium account.",
  ) as stream:
      for event in stream:
          
          if event.type == "thread.message.delta" and event.data.delta.content:
              print(event.data.delta.content[0].text)
  ```

  More information on streaming helpers can be found in the dedicated documentation: [helpers.md](https://github.com/openai/openai-python/tree/main/helpers.md)



  Simply import `AsyncOpenAI` instead of `OpenAI` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from openai import AsyncOpenAI

  client = AsyncOpenAI(
      api_key=os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      chat_completion = await client.chat.completions.create(
          messages=[
              {
                  "role": "user",
                  "content": "Say this is a test",
              }
          ],
          model="gpt-4o",
      )


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  We provide support for streaming responses using Server Side Events (SSE).

  ```python
  from openai import OpenAI

  client = OpenAI()

  stream = client.chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Say this is a test",
          }
      ],
      model="gpt-4o",
      stream=True,
  )
  for chunk in stream:
      print(chunk.choices[0].delta.content or "", end="")
  ```

  The async client uses the exact same interface.

  ```python
  import asyncio
  from openai import AsyncOpenAI

  client = AsyncOpenAI()


  async def main():
      stream = await client.chat.completions.create(
          model="gpt-4",
          messages=[{"role": "user", "content": "Say this is a test"}],
          stream=True,
      )
      async for chunk in stream:
          print(chunk.choices[0].delta.content or "", end="")


  asyncio.run(main())
  ```



  > [!IMPORTANT]
  > We highly recommend instantiating client instances instead of relying on the global client.

  We also expose a global client instance that is accessible in a similar fashion to versions prior to v1.

  ```py
  import openai


  openai.api_key = '...'


  openai.base_url = "https://..."
  openai.default_headers = {"x-foo": "true"}

  completion = openai.chat.completions.create(
      model="gpt-4o",
      messages=[
          {
              "role": "user",
              "content": "How do I output all files in a directory using Python?",
          },
      ],
  )
  print(completion.choices[0].message.content)
  ```

  The API is the exact same as the standard client instance-based API.

  This is intended to be used within REPLs or notebooks for faster iteration, **not** in application code.

  We recommend that you always instantiate a client (e.g., with `client = OpenAI()`) in application code because:

  - It can be difficult to reason about where client options are configured
  - It's not possible to change certain client options without potentially causing race conditions
  - It's harder to mock for testing purposes
  - It's not possible to control cleanup of network connections



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  List methods in the OpenAI API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from openai import OpenAI

  client = OpenAI()

  all_jobs = []

  for job in client.fine_tuning.jobs.list(
      limit=20,
  ):
      
      all_jobs.append(job)
  print(all_jobs)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from openai import AsyncOpenAI

  client = AsyncOpenAI()


  async def main() -> None:
      all_jobs = []
      
      async for job in client.fine_tuning.jobs.list(
          limit=20,
      ):
          all_jobs.append(job)
      print(all_jobs)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.fine_tuning.jobs.list(
      limit=20,
  )
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.data)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.fine_tuning.jobs.list(
      limit=20,
  )

  print(f"next page cursor: {first_page.after}")  # => "next page cursor: ..."
  for job in first_page.data:
      print(job.id)


  ```



  Nested parameters are dictionaries, typed using `TypedDict`, for example:

  ```python
  from openai import OpenAI

  client = OpenAI()

  completion = client.chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "Can you generate an example json object describing a fruit?",
          }
      ],
      model="gpt-4o",
      response_format={"type": "json_object"},
  )
  ```



  Request parameters that correspond to file uploads can be passed as `bytes`, a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance or a tuple of `(filename, contents, media type)`.

  ```python
  from pathlib import Path
  from openai import OpenAI

  client = OpenAI()

  client.files.create(
      file=Path("input.jsonl"),
      purpose="fine-tune",
  )
  ```

  The async client uses the exact same interface. If you pass a [`PathLike`](https://docs.python.org/3/library/os.html#os.PathLike) instance, the file contents will be read asynchronously automatically.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `openai.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `openai.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `openai.APIError`.

  ```python
  import openai
  from openai import OpenAI

  client = OpenAI()

  try:
      client.fine_tuning.jobs.create(
          model="gpt-4o",
          training_file="file-abc123",
      )
  except openai.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except openai.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except openai.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  > For more information on debugging requests, see [these docs](https://platform.openai.com/docs/api-reference/debugging-requests)

  All object responses in the SDK provide a `_request_id` property which is added from the `x-request-id` response header so that you can quickly log failing requests and report them back to OpenAI.

  ```python
  completion = await client.chat.completions.create(
      messages=[{"role": "user", "content": "Say this is a test"}], model="gpt-4"
  )
  print(completion._request_id)  # req_123
  ```

  Note that unlike other properties that use an `_` prefix, the `_request_id` property
  *is* public. Unless documented otherwise, *all* other `_` prefix properties,
  methods and modules are *private*.




  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from openai import OpenAI


  client = OpenAI(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "How can I get the name of the current day in JavaScript?",
          }
      ],
      model="gpt-4o",
  )
  ```



  By default requests time out after 10 minutes. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from openai import OpenAI


  client = OpenAI(
      
      timeout=20.0,
  )


  client = OpenAI(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).chat.completions.create(
      messages=[
          {
              "role": "user",
              "content": "How can I list all files in a directory using Python?",
          }
      ],
      model="gpt-4o",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/openai/openai-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `OPENAI_LOG` to `info`.

  ```shell
  $ export OPENAI_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from openai import OpenAI

  client = OpenAI()
  response = client.chat.completions.with_raw_response.create(
      messages=[{
          "role": "user",
          "content": "Say this is a test",
      }],
      model="gpt-4o",
  )
  print(response.headers.get('X-My-Header'))

  completion = response.parse()  # get the object that `chat.completions.create()` would have returned
  print(completion)
  ```

  These methods return an [`LegacyAPIResponse`](https://github.com/openai/openai-python/tree/main/src/openai/_legacy_response.py) object. This is a legacy class as we're changing it slightly in the next major version.

  For the sync client this will mostly be the same with the exception
  of `content` & `text` will be methods instead of properties. In the
  async client, all methods will be async.

  A migration script will be provided & the migration in general should
  be smooth.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  As such, `.with_streaming_response` methods return a different [`APIResponse`](https://github.com/openai/openai-python/tree/main/src/openai/_response.py) object, and the async client returns an [`AsyncAPIResponse`](https://github.com/openai/openai-python/tree/main/src/openai/_response.py) object.

  ```python
  with client.chat.completions.with_streaming_response.create(
      messages=[
          {
              "role": "user",
              "content": "Say this is a test",
          }
      ],
      model="gpt-4o",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from openai import OpenAI, DefaultHttpxClient

  client = OpenAI(
      
      base_url="http://my.test.server.example.com:8083/v1",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  To use this library with [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/overview), use the `AzureOpenAI`
  class instead of the `OpenAI` class.

  > [!IMPORTANT]
  > The Azure API shape differs from the core API shape which means that the static types for responses / params
  > won't always be correct.

  ```py
  from openai import AzureOpenAI


  client = AzureOpenAI(
      
      api_version="2023-07-01-preview",
      
      azure_endpoint="https://example-endpoint.openai.azure.com",
  )

  completion = client.chat.completions.create(
      model="deployment-name",  # e.g. gpt-35-instant
      messages=[
          {
              "role": "user",
              "content": "How do I output all files in a directory using Python?",
          },
      ],
  )
  print(completion.to_json())
  ```

  In addition to the options provided in the base `OpenAI` client, the following options are provided:

  - `azure_endpoint` (or the `AZURE_OPENAI_ENDPOINT` environment variable)
  - `azure_deployment`
  - `api_version` (or the `OPENAI_API_VERSION` environment variable)
  - `azure_ad_token` (or the `AZURE_OPENAI_AD_TOKEN` environment variable)
  - `azure_ad_token_provider`

  An example of using the client with Microsoft Entra ID (formerly known as Azure Active Directory) can be found [here](https://github.com/openai/openai-python/blob/main/examples/azure_ad.py).



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/openai/openai-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import openai
  print(openai.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/openai/openai-python/tree/main/./CONTRIBUTING.md).


pkgId: 355c4f7bd408193a0701bcad2c4e426c32060983c7fd0e8a90cae54beaed8442
name: python-openalgo-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for openalgo
url: https://docs.openalgo.in
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openalgo-1.0.5-1.src.rpm
location_href: Packages/python-openalgo-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  A Python library for algorithmic trading using OpenAlgo's REST APIs. This library provides a comprehensive interface for order management, market data, and account operations.



  ```bash
  pip install openalgo
  ```



  ```python
  from openalgo import api


  client = api(
      api_key="your_api_key",
      host="http://127.0.0.1:5000"  # or your OpenAlgo server URL
  )
  ```






  Get funds and margin details of the trading account.
  ```python
  result = client.funds()

  {
      "data": {
          "availablecash": "18083.01",
          "collateral": "0.00",
          "m2mrealized": "0.00",
          "m2munrealized": "0.00",
          "utiliseddebits": "0.00"
      },
      "status": "success"
  }
  ```


  Get orderbook details with statistics.
  ```python
  result = client.orderbook()




  ```


  Get execution details of trades.
  ```python
  result = client.tradebook()




  ```


  Get current positions across all segments.
  ```python
  result = client.positionbook()



  ```


  Get stock holdings with P&L details.
  ```python
  result = client.holdings()




  ```




  Place a regular order.
  ```python
  result = client.placeorder(
      symbol="RELIANCE",
      exchange="NSE",
      action="BUY",
      quantity=1,
      price_type="MARKET",
      product="MIS"
  )
  ```


  Place an order with position sizing.
  ```python
  result = client.placesmartorder(
      symbol="RELIANCE",
      exchange="NSE",
      action="BUY",
      quantity=1,
      position_size=100,
      price_type="MARKET",
      product="MIS"
  )
  ```


  Place multiple orders simultaneously.
  ```python
  orders = [
      {
          "symbol": "RELIANCE",
          "exchange": "NSE",
          "action": "BUY",
          "quantity": 1,
          "pricetype": "MARKET",
          "product": "MIS"
      },
      {
          "symbol": "INFY",
          "exchange": "NSE",
          "action": "SELL",
          "quantity": 1,
          "pricetype": "MARKET",
          "product": "MIS"
      }
  ]
  result = client.basketorder(orders=orders)
  ```


  Split a large order into smaller ones.
  ```python
  result = client.splitorder(
      symbol="YESBANK",
      exchange="NSE",
      action="SELL",
      quantity=105,
      splitsize=20,
      price_type="MARKET",
      product="MIS"
  )
  ```


  Check status of a specific order.
  ```python
  result = client.orderstatus(
      order_id="24120900146469",
      strategy="Test Strategy"
  )
  ```


  Get current open position for a symbol.
  ```python
  result = client.openposition(
      symbol="YESBANK",
      exchange="NSE",
      product="CNC"
  )
  ```


  Modify an existing order.
  ```python
  result = client.modifyorder(
      order_id="24120900146469",
      symbol="RELIANCE",
      action="BUY",
      exchange="NSE",
      quantity=2,
      price="2100",
      product="MIS",
      price_type="LIMIT"
  )
  ```


  Cancel a specific order.
  ```python
  result = client.cancelorder(
      order_id="24120900146469"
  )
  ```


  Cancel all open orders.
  ```python
  result = client.cancelallorder()
  ```


  Close all open positions.
  ```python
  result = client.closeposition()
  ```




  Get real-time quotes for a symbol.
  ```python
  result = client.quotes(
      symbol="RELIANCE",
      exchange="NSE"
  )
  ```


  Get market depth (order book) data.
  ```python
  result = client.depth(
      symbol="RELIANCE",
      exchange="NSE"
  )
  ```


  Get historical price data.
  ```python
  result = client.history(
      symbol="RELIANCE",
      exchange="NSE",
      interval="5m",
      start_date="2024-01-01",
      end_date="2024-01-31"
  )
  ```


  Get supported time intervals for historical data.
  ```python
  result = client.interval()
  ```



  Check the examples directory for detailed usage:
  - account_test.py: Test account-related functions
  - order_test.py: Test order management functions
  - data_examples.py: Test market data functions



  1. Update version in `openalgo/__init__.py`

  2. Build the distribution:
  ```bash
  python -m pip install --upgrade build
  python -m build
  ```

  3. Upload to PyPI:
  ```bash
  python -m pip install --upgrade twine
  python -m twine upload dist/*
  ```



  This project is licensed under the MIT License - see the LICENSE file for details.


pkgId: 0e376188eede2f24d10c2c33593ec4b67ae3f0829587f0610f12c660142e926d
name: python-openapi-ts-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for openapi-ts
url: https://pypi.org/project/openapi-ts/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openapi-ts-0.1.4-1.src.rpm
location_href: Packages/python-openapi-ts-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  > Generate typescript clients for OpenAPI (e.g. FastAPI) apps, using openapi-ts



  Make sure you have `openapi-ts` installed:

  ```bash
  npm -g i @hey-api/openapi-ts
  ```

  ```python
  from fastapi import FastAPI
  from pydantic import BaseModel
  from openapi_ts import generate_client


  app = FastAPI(generate_unique_id_function=lambda route: route.name)

  class User(BaseModel):
    name: str
    email: str

  @app.get('/users')
  def get_users(how_many: int | None = None) -> list[User]:
    ...


  generate_client(app.openapi(), 'path/to/client')
  ```



  - See a full walkthrough of `fastapi` x `openapi-ts` in the [FastAPI docs](https://fastapi.tiangolo.com/advanced/generate-clients/#generate-a-typescript-client)
  - For configuration and more of `openapi-ts`, see their [website](https://github.com/hey-api/openapi-ts)


pkgId: c2f30875911be9a8cd9aad8dd92bee644f6d90a753a21732250d97112d339329
name: python-openapi2jsonschema2-help
arch: noarch
version: 1.1.5
epoch: 0
release: 1
summary: Development documents and examples for openapi2jsonschema2
url: https://github.com/cam3ron2/openapi2jsonschema2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openapi2jsonschema2-1.1.5-1.src.rpm
location_href: Packages/python-openapi2jsonschema2-help-1.1.5-1.noarch.rpm
checksum_type: sha256
description:
  <!-- Space: CLDCOE -->
  <!-- Parent: NIQ Managed Actions -->
  <!-- Type: page -->
  <!-- Layout: article -->

  <!-- Include: disclaimer.tmpl -->
  <!-- Include: ac:toc -->

  A utility to extract [JSON Schema](http://json-schema.org/) from a
  valid [OpenAPI](https://www.openapis.org/) specification.

  > Forked and updated from [openapi2jsonschema](https://github.com/instrumenta/openapi2jsonschema). The original project does not appear to be maintained. All credit to the original authors.



  OpenAPI contains a list of type `definitions` using a superset of JSON
  Schema. These are used internally by various OpenAPI compatible tools. I
  found myself however wanting to use those schemas separately, outside
  existing OpenAPI tooling. Generating separate schemas for types defined
  in OpenAPI allows for all sorts of indepent tooling to be build which
  can be easily maintained, because the canonical definition is shared.



  `openapi2jsonschema2` is implemented in Python. Assuming you have a
  Python intepreter and pip installed you should be able to install with:

  ```shell
  pip install openapi2jsonschema2
  ```

  This has not yet been widely tested and is currently in a _works on my
  machine_ state.



  The simplest usage is to point the `openapi2jsonschema2` tool at a URL
  containing a JSON (or YAML) OpenAPI definition like so:

  ```shell
  openapi2jsonschema2 https://raw.githubusercontent.com/kubernetes/kubernetes/master/api/openapi-spec/swagger.json
  ```

  This will generate a set of schemas in a `schemas` directory. The tool
  provides a number of options to modify the output:

  ```shell
  $ openapi2jsonschema2 --help
  Usage: openapi2jsonschema2 [OPTIONS] SCHEMA

    Converts a valid OpenAPI specification into a set of JSON Schema files

  Options:
    -o, --output PATH  Directory to store schema files
    -p, --prefix TEXT  Prefix for JSON references (only for OpenAPI versions
                       before 3.0)
    --stand-alone      Whether or not to de-reference JSON schemas
    --kubernetes       Enable Kubernetes specific processors
    --strict           Prohibits properties not in the schema
                       (additionalProperties: false)
    --help             Show this message and exit.
  ```



  My specific use-case was being able to validate a Kubernetes
  configuration file without a Kubernetes client like `kubectl` and
  without the server. For that I have a bash script,
  [available here](https://github.com/instrumenta/kubernetes-json-schema/blob/master/build.sh).

  The output from running this script can be seen in the accompanying
  [instrumenta/kubernetes-json-schema](https://github.com/instrumenta/kubernetes-json-schema).

  <!-- Include: footer.tmpl -->


pkgId: d6936823da69f350c569e6d2640c75d346753b1d63f209699b6968b21034e693
name: python-opendapi-help
arch: noarch
version: 1.0.10
epoch: 0
release: 1
summary: Development documents and examples for opendapi
url: https://wovencollab.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opendapi-1.0.10-1.src.rpm
location_href: Packages/python-opendapi-help-1.0.10-1.noarch.rpm
checksum_type: sha256
description:
  Read more about OpenDAPI at [opendapi.org](https://opendapi.org)
  Reach out to us at [Woven](https://wovencollab.com) to try this out


pkgId: 56b20406c90d43c21a17e1b577d5dd97a5a5e58ed117fa1cebc4fce3c6e9f6fe
name: python-opendbt-help
arch: noarch
version: 0.11.0
epoch: 0
release: 1
summary: Development documents and examples for opendbt
url: https://github.com/memiiso/opendbt
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opendbt-0.11.0-1.src.rpm
location_href: Packages/python-opendbt-help-0.11.0-1.noarch.rpm
checksum_type: sha256
description:
  ![logo-badge](https://github.com/mac-s-g/github-help-wanted/blob/master/src/images/logo-full.png?raw=true)
  [![License](http://img.shields.io/:license-apache%202.0-brightgreen.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
  ![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)



  This project adds new capabilities to dbt-core by dynamically modifying dbt's source code.
  dbt is a popular solution for batch data processing in data analytics. While it operates on
  an [open-core model](https://opencoreventures.com/blog/2023-07-open-core-is-misunderstood-business-model/), which can
  sometimes limit the inclusion of community features in the open-source version. no worries opendbt is here to solve it.
  opendbt offers a fully open-source package to address these concerns. **OpenDBT builds upon dbt-core, adding valuable
  features without changing dbt-core code.**

  `opendbt` unlocks many customization which are not in dbt-core, allowing end user to tailor dbt to his/her specific
  needs and data workflows.

  With `opendbt` you can go beyond the core functionalities of dbt. For example seamlessly integrating your customized
  adapter and providing jinja context with further adapter/python methods.



  - Customize Existing Adapters: Leverage OOP to create custom adapters that extends existing ones. With this user
    could provide more python features to jinja
  - Execute Local Python Code: Use dbt Python models to run local Python code. For example, you could import data from web
    APIs directly within your dbt model.
  - Granular Model-Level Orchestration with Airflow: Integrate Airflow for fine-grained control over model execution.
  - Serve dbt Docs in Airflow UI: Create a custom page on the Airflow server that displays dbt documentation as an Airflow
    UI page.
  - Customized dbt Docs: Replace the default dbt documentation page with your own custom index.html file.
  - Run end to end ETL pipeline with dbt
    using [dlt](https://dlthub.com/) [integration](https://github.com/memiiso/opendbt/issues/40)
  - Register dbt callbacks within a dbt project to trigger custom actions or alerts based on selected dbt events.

  For detailed examples, see: [examples](docs/EXAMPLES.md).

  ![opendbt-airflow-ui.png](docs/assets/opendbt-airflow-ui.png)



  install version from github:

  ```shell
  pip install https://github.com/memiiso/opendbt/archive/refs/tags/0.4.0.zip --upgrade --user
  ```



  The project completely open-source, using the Apache 2.0 license.
  opendbt still is a young project and there are things to improve.
  Please feel free to test it, give feedback, open feature requests or send pull requests.



  <a href="https://github.com/memiiso/opendbt/graphs/contributors">
    <img src="https://contributors-img.web.app/image?repo=memiiso/opendbt" />
  </a>


pkgId: fa45a8d76ef3ad2013d3242ff0935f8ae3d70a4e15eb2692ca299ee49447368e
name: python-openfactcheck-help
arch: noarch
version: 0.3.9
epoch: 0
release: 1
summary: Development documents and examples for openfactcheck
url: https://github.com/hasaniqbal777/openfactcheck
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openfactcheck-0.3.9-1.src.rpm
location_href: Packages/python-openfactcheck-help-0.3.9-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://github.com/hasaniqbal777/OpenFactCheck/actions/workflows/release.yaml">
      <img src="https://img.shields.io/github/actions/workflow/status/hasaniqbal777/openfactcheck/release.yaml?logo=github&label=Release" alt="Release">
  </a>
  <a href="https://readthedocs.org/projects/openfactcheck/builds/">
      <img alt="Docs" src="https://img.shields.io/readthedocs/openfactcheck?logo=readthedocs&label=Docs">
  </a>
  <br>
  <a href="https://opensource.org/licenses/Apache-2.0">
      <img src="https://img.shields.io/github/license/hasaniqbal777/openfactcheck" alt="License: Apache-2.0">
  </a>
  <a href="https://pypi.org/project/openfactcheck/">
      <img src="https://img.shields.io/pypi/pyversions/openfactcheck.svg" alt="Python Version">
  </a>
  <a href="https://pypi.org/project/openfactcheck/">
      <img src="https://img.shields.io/pypi/v/openfactcheck.svg" alt="PyPI Latest Release">
  </a>
  <a href="https://arxiv.org/abs/2405.05583"><img src="https://img.shields.io/badge/arXiv-2405.05583-B31B1B" alt="arXiv"></a>
  <a href="https://zenodo.org/doi/10.5281/zenodo.13358664"><img src="https://img.shields.io/badge/DOI-10.5281/zenodo.13358664-blue" alt="DOI"></a>

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright (c) 2024 MBZUAI  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 91f83e497d1f3f6669961af9dbb95511331051134aed1de6182394706742158d
name: python-opengate-data-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for opengate-data
url: https://pypi.org/project/opengate-data/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opengate-data-1.4.0-1.src.rpm
location_href: Packages/python-opengate-data-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Opengate-data is a python library that helps you integrate OpenGate into your python projects.


  To install the library, run:

  ```python
  pip install opengate-data
  ```


  To import the OpenGateClient, use:

  ```python
  from opengate_data import OpenGateClient
  ```



  To initialize the OpenGateClient using a username and password:

  ```python
  client = OpenGateClient(url="Url", user="User", password="Password")
  ```


  To initialize the client using an api_key:

  ```python
  client = OpenGateClient(url="Url", api_key="Api_Key")
  ```


  To initialize the client using an api_key with a .env file.

  1. Create a .env file with the following content:

      `API_KEY="api-key"`
      <br>

  2. Load the environment variable and initialize the client:

      ```python
      from dotenv import load_dotenv
      from pathlib import Path

      
      env_path = Path(".") / ".env"
      load_dotenv(dotenv_path=env_path)

      client = OpenGateClient(url="Url")
      
      client = OpenGateClient(url="Url", api_key=None)
      ```

  In this case, you can either set `api_key` to `None` or simply `omit` it, as the client will automatically retrieve the `API_KEY` from the environment variable when needed.
  If you are connecting to internal services, such as those in `K8s`, you can set the URL to `None` or `omit` it entirely, similar to the examples provided for `K8s` usage.



  To initialize the client using an api_key from an environment variable, you can set the api_key directly in your environment without relying on a .env:

  1. Create environment variable

     - On UNIX systems, use:
       ```bash
       export API_KEY="your-api-key"
       ```

     - On Windows, use:
        ```bash
        set API_KEY="your-api-key"
        ```

  2. Initialize the client.

      ```python
      client = OpenGateClient(url="Url")
      
      client = OpenGateClient(url="Url", api_key=None)
      ```

  Similar to the previous example, you can set `api_key` to `None` or omit it, as the client will automatically retrieve the value from the environment variable. Additionally, you can also authenticate using a `username` and `password` by specifying those credentials instead.
  If you are connecting to internal services, such as those in `K8s`, you can set the URL to `None` or `omit` it entirely, similar to the examples provided for `K8s` usage.



  To initialize the OpenGateClient without specifying a URL, you can either `omit` the `URL` parameter or set it to `None`

  ```python
  client = OpenGateClient(api_key="Api_Key")

  client = OpenGateClient(url=None, api_key="Api_Key")
  ```
  Similar to the previous examples, you have the option to provide the `api_key` directly, set it to `None`, or `omit` it altogether. If you choose to `omit` it, the client will automatically retrieve the `api_key` from the environment variable if it is set. Additionally, you can also authenticate using a `username` and `password` by specifying those credentials instead.




  The library consists of the following modules:

  - **IA**
    - Models
    - Pipelines
    - Transformers
  - **Collection**
    - Collection
    - Bulk Collection
  - **Provision**
    - Asset
    - Bulk
    - Devices
    - Processor
  - **Rules**
    - Rules
  - **Searching**
    - Datapoints
    - Data sets
    - Entities
    - Operations
    - Rules
    - Timeseries



  To generate the API documentation you can execute `./generate_doc.sh` and open the generated Markdown on:
  **docs/documentation.md**



  The examples of the different modules are found in the path `docs/basic_examples.md`



  For more details and examples about each of the modules,
  consult the [complete documentation](https://documentation.opengate.es/).



  To configure uploading packages to `PyPI`, you need to create and set up the .pypirc file in your home directory. Below are the steps for different operating systems:

  - **Windows**: `notepad $env:USERPROFILE\.pypirc`.
  - **Linux**: `nano ~/.pypirc`.

  Inside the .pypirc file, configure the following lines, replacing token with your actual PyPI API token:

  ```python
  [pypi]
       username = __token__
       password = token
  ```

  Open the setup.py file and update the version of your project as needed and install twine. `pip install twine`
  After updating the version in setup.py, run the following script to build and upload your package to PyPI: `./dish.sh`





  If you want to run all the tests, both unit and integration tests, you can execute the `pytest.ini` file.
  Run the following command in your terminal: `pytest`



  Inside the unit folder, you will find all the unit tests corresponding to each module.
  These tests verify the functionality of each function individually.
  To run a unit test, use the pytest command followed by the name of the unit test.
  For example: `pytest test_iot_collection.py`



  Inside the test/features, you will find all the integration tests.
  Additionally, you need to add the `url` and `api_key` to the `test_steps_cucumber.py` file

  To run the tests, use the following command: `pytest test_steps_cucumber.py`



  This project is licensed under the MIT License.


pkgId: 26227099503a5f9b93a879968c4149f5e8926c9a0aa6a4e1aac6173e743526ac
name: python-openghg-help
arch: noarch
version: 0.11.0
epoch: 0
release: 1
summary: Development documents and examples for openghg
url: https://github.com/openghg/openghg
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openghg-0.11.0-1.src.rpm
location_href: Packages/python-openghg-help-0.11.0-1.noarch.rpm
checksum_type: sha256
description:
  Enter path for object store (default /home/gareth/openghg_store):
  INFO:openghg.util:Creating config at /home/gareth/.config/openghg/openghg.conf
  INFO:openghg.util:Configuration written to /home/gareth/.config/openghg/openghg.conf
  ```

  Using the `create_config` function from the `openghg.util` submodule.
  ```
  from openghg.util import create_config
  create_config()


pkgId: d2fb830688dafefd4cf1dab084e81c5681a6e497544c50d48a3c1267b05c2384
name: python-opengradient-help
arch: noarch
version: 0.3.17
epoch: 0
release: 1
summary: Development documents and examples for opengradient
url: https://opengradient.ai
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opengradient-0.3.17-1.src.rpm
location_href: Packages/python-opengradient-help-0.3.17-1.noarch.rpm
checksum_type: sha256
description:
  Python SDK for the OpenGradient platform provides decentralized model management & inference services. Python SDK allows programmatic access to our model repository and decentralized AI infrastructure.



  To install Python SDK and CLI, run the following command:
  ```python
  pip install opengradient
  ```



  To get started, run:

  ```python
  import opengradient as og
  og.init(private_key="<private_key>", email="<email>", password="<password>")
  ```

  The following commands show how to use Python SDK.


  ```python
  og.create_model(model_name="<model_name>", model_desc="<model_description>")
  ```


  ```python
  og.create_model(model_name="<model_name>", model_desc="<model_description>", model_path="<model_path>")
  ```


  ```python
  og.create_version(model_name="<model_name>", notes="<model_notes>")
  ```


  ```python
  og.upload(model_path="<model_path>", model_name="<model_name>", version="<version>")
  ```


  ```python
  og.list_files(model_name="<model_name>", version="<version>")
  ```


  ```python
  inference_mode = og.InferenceMode.VANILLA
  og.infer(model_cid, model_inputs, inference_mode)
  ```
   - inference mode can be `VANILLA`, `ZKML`, or `TEE`



  ```python
  tx_hash, response = og.llm_completion(
      model_cid='meta-llama/Meta-Llama-3-8B-Instruct',
      prompt="Translate the following English text to French: 'Hello, how are you?'",
      max_tokens=50,
      temperature=0.0
  )
  ```


  ```python

  messages = [
      {
          "role": "system",
          "content": "You are a helpful AI assistant.",
          "name": "HAL"
      },
      {
          "role": "user",
          "content": "Hello! How are you doing? Can you repeat my name?",
      }]


  tx_hash, finish_reason, message = og.llm_chat(
    model_cid=og.LLM.MISTRAL_7B_INSTRUCT_V3,
    messages=messages
  )
  ```





  ```bash
  export OPENGRADIENT_EMAIL="<email>"
  export OPENGRADIENT_PASSWORD="<password>"
  ```


  ```bash
  opengradient create_model_repo "<model_name>" "<description>"
  ```
  - creating a model automatically initializes version `v0.01`


  ```bash
  opengradient create_model_repo "<model_name>" "<description>"
  ```


  ```bash
  opengradient upload "<model_path>" "<model_name>" "<version>"
  ```


  ```bash
  opengradient list_files "<model_name>" "<version>"
  ```


  ```bash
  opengradient infer QmbUqS93oc4JTLMHwpVxsE39mhNxy6hpf6Py3r9oANr8aZ VANILLA '{"num_input1":[1.0, 2.0, 3.0], "num_input2":10, "str_input1":["hello", "ONNX"], "str_input2":" world"}'
  ```


  ```bash
  opengradient infer QmbUqS93oc4JTLMHwpVxsE39mhNxy6hpf6Py3r9oANr8aZ VANILLA --input_file input.json
  ```


  We also have explicit support for using LLMs through the completion and chat commands in the CLI.

  For example, you can run a competion inference with Llama-3 using the following command:

  ``` bash
  opengradient completion --model "meta-llama/Meta-Llama-3-8B-Instruct" --prompt "hello who are you?" --max-tokens 50
  ```

  Or you can use files instead of text input in order to simplify your command:

  ```bash
  opengradient chat --model "mistralai/Mistral-7B-Instruct-v0.3" --messages-file messages.json --tools-file tools.json --max-tokens 200
  ```

  For more information read the OpenGradient [documentation](https://docs.opengradient.ai/).

rpm_license:
  MIT License  Copyright (c) 2024 OpenGradient  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: 0e3621043556e2684ad089befb8620c752a81e08552d0aa6edb7286957f50fe6
name: python-openhdemg-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for openhdemg
url: https://pypi.org/project/openhdemg/
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openhdemg-0.1.1-1.src.rpm
location_href: Packages/python-openhdemg-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="left">
      <a href="https://pypi.python.org/pypi/openhdemg/" alt="openhdemg version" target="_blank">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/openhdemg?label=pip&logo=PyPI&logoColor=gold&color=blue"></a>
      <a href="https://pypi.org/project/openhdemg" alt="Python version" target="_blank">
          <img alt="PyPI" src="https://img.shields.io/pypi/pyversions/openhdemg?logo=Python&logoColor=gold&color=blue"></a>
      <a href="https://www.youtube.com/@openhdemg" alt="YouTube" target="_blank">
          <img src="https://img.shields.io/badge/youtube-Watch_videos-red.svg?color=blue&logoColor=gold&logo=youtube" /></a>
      <a href="https://twitter.com/openhdemg" alt="Twitter" target="_blank">
          <img src="https://img.shields.io/badge/twitter-Follow_us-red.svg?color=blue&logoColor=gold&logo=twitter" /></a>
  </p>

  <br/>

  <p align="center">
    <img src="https://www.giacomovalli.com/openhdemg/md_graphics/index/banner_logo.png" />
  </p>

  <br/>



  *openhdemg is a powerful toolbox for the analysis of HD-EMG recordings.*

  *openhdemg* is an open-source framework written in Python 3 with many functionalities specifically designed for the analysis of High-Density
  Electromyography (HD-EMG) recordings. Some of its main features are listed below, but there is much more to discover! For a full list of available functions, please refer to the **API reference** section at [www.giacomovalli.com/openhdemg](https://www.giacomovalli.com/openhdemg/).

  1. **Load** decomposed HD-EMG files from various sources, such as .mat and .csv files. This allows to interface *openhdemg* with the commonly used softwares like OTBioLab+, DEMUSE, Delsys NeuroMap and potentially with any other software.
  2. **Visualise** your EMG or force/reference signal, as well as the motor units' firing times and their action potentials shape.
  3. **Edit** your file changing the reference signal offset, filtering noise, calculating differential derivations and removing unwanted motor units.
  4. **Analyse** motor units' recruitment/derecruitment thresholds, discharge rate, conduction velocity, action potentials amplitude and more...
  5. **Remove duplicates** between different files from the same recording session and analyse them together to increase the number of motor units'.
  6. **Track** motor units' across different recording sessions.
  7. **Save** the results of the analyses and the edited file.


  If you already know how to use Python, that's the way to go! Otherwise, have a look at the tutorial explaining how to [Setup your Python working environment](https://www.giacomovalli.com/openhdemg/tutorials/setup_working_env/).

  *openhdemg* can be easily installed using pip:

  ```shell
  pip install openhdemg
  ```

  If you want an overview of what you can do with the *openhdemg* library, have a look at the [Quick Start section](https://www.giacomovalli.com/openhdemg/quick-start/).


  In addition to the rich set of modules and functions presented in the **API documentation**, *openhdemg* offers also a practical graphical user interface (GUI) from which many tasks can be performed without writing a single line of code!

  After installing the *openhdemg* package, the GUI can be simply accessed from the command line (check to be into the virtual environment) with:

  ```shell
  python -m openhdemg.gui.openhdemg_gui
  ```

  Once opened, it will look like this. It is cool, isn't it?

  ![gui_preview](https://www.giacomovalli.com/openhdemg/md_graphics/index/gui_preview_v2.png)


  The *openhdemg* project was born in 2022 with the aim to provide the HD-EMG community with a free and open-source framework to analyse motor units' properties.

  The field of EMG analysis in humans has always been characterized by a lack of available software for signal post-processing and analysis. This has forced users to code their own scripts, which can lead to problems when the scripts are not shared open-source. Why?

  - If different users use different scripts, the results can differ.
  - Any code can contain errors, if the code is not shared, the errors will never be known and them will repeat in the following analyses.
  - There is a significant difference between the methods presented in research papers and the practical implementation of a script. Reproducing a script solely based on written instructions can be challenging, making the reproducibility of a study unrealistic.
  - Anyone who doesn't code, will not be able to analyse the recordings.

  In order to overcome these problems, we developed a fully transparent framework for the analysis of motor units' properties.

  This project is intended for the users that already know the Python language, for those willing to learn it and even for those not interested in coding, thanks to a friendly graphical user interface (GUI).

  Both the *openhdemg* project and its contributors adhere to the Open Science Principles and especially to the idea of public release  of data and other scientific resources necessary for conducting honest research.


pkgId: 2bef2f4270fee22fe08d0cca4417d887f9040e768e695116b8eb88e2e488f54f
name: python-openinference-instrumentation-help
arch: noarch
version: 0.1.20
epoch: 0
release: 1
summary: Development documents and examples for openinference-instrumentation
url: https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openinference-instrumentation-0.1.20-1.src.rpm
location_href: Packages/python-openinference-instrumentation-help-0.1.20-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation.svg)](https://pypi.python.org/pypi/openinference-instrumentation)

  Utility functions for OpenInference instrumentation.



  ```shell
  pip install openinference-instrumentation
  ```



  The `openinference-instrumentation` package offers utilities to track important application metadata such as sessions and metadata using Python context managers:

  * `using_session`: to specify a session ID to track and group a multi-turn conversation with a user
  * `using_user`: to specify a user ID to track different conversations with a given user
  * `using_metadata`: to add custom metadata, that can provide extra information that supports a wide range of operational needs
  * `using_tag`: to add tags, to help filter on specific keywords
  * `using_prompt_template`: to reflect the prompt template used, with its version and variables. This is useful for prompt template management
  * `using_attributes`: it helps handling multiple of the previous options at once in a concise manner

  For example:

  ```python
  from openinference.instrumentation import using_attributes
  tags = ["business_critical", "simple", ...]
  metadata = {
      "country": "United States",
      "topic":"weather",
      ...
  }
  prompt_template = "Please describe the weather forecast for {city} on {date}"
  prompt_template_variables = {"city": "Johannesburg", "date":"July 11"}
  prompt_template_version = "v1.0"
  with using_attributes(
      session_id="my-session-id",
      user_id="my-user-id",
      metadata=metadata,
      tags=tags,
      prompt_template=prompt_template,
      prompt_template_version=prompt_template_version,
      prompt_template_variables=prompt_template_variables,
  ):
      
      
      
      
      
      
      
      
      ...
  ```

  You can read more about this in our [docs](https://docs.arize.com/phoenix/tracing/how-to-tracing/customize-spans).



  This package contains the central `TraceConfig` class, which lets you specify a tracing configuration that lets you control settings like data privacy and payload sizes. For instance, you may want to keep sensitive information from being logged for security reasons, or you may want to limit the size of the base64 encoded images logged to reduced payload size.

  In addition, you an also use environment variables, read more [here](../../spec/configuration.md). The following is an example of using the `TraceConfig` object:

  ```python
  from openinference.instrumentation import TraceConfig
  config = TraceConfig(
      hide_inputs=hide_inputs,
      hide_outputs=hide_outputs,
      hide_input_messages=hide_input_messages,
      hide_output_messages=hide_output_messages,
      hide_input_images=hide_input_images,
      hide_input_text=hide_input_text,
      hide_output_text=hide_output_text,
      base64_image_max_length=base64_image_max_length,
  )
  tracer_provider=...

  OpenAIInstrumentor().instrument(tracer_provider=tracer_provider, config=config)
  ```


pkgId: 0b5963706460a7347f10570526d5f76b87853cb7a6d5ab9e9e85df186f2cbb69
name: python-openinference-instrumentation-llama-index-help
arch: noarch
version: 3.1.1
epoch: 0
release: 1
summary: Development documents and examples for openinference-instrumentation-llama-index
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openinference-instrumentation-llama-index-3.1.1-1.src.rpm
location_href: Packages/python-openinference-instrumentation-llama-index-help-3.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Python auto-instrumentation library for LlamaIndex.

  These traces are fully OpenTelemetry compatible and can be sent to an OpenTelemetry collector for viewing, such as [`arize-phoenix`](https://github.com/Arize-ai/phoenix).

  [![pypi](https://badge.fury.io/py/openinference-instrumentation-llama-index.svg)](https://pypi.org/project/openinference-instrumentation-llama-index/)



  ```shell
  pip install openinference-instrumentation-llama-index
  ```



  | llama-index version | openinference-instrumentation-llama-index version |
  |---------------------|---------------------------------------------------|
  | \>=0.11.0           | \>=3.0                                            |
  | \>=0.10.43          | \>=2.0, <3.0                                      |
  | \>=0.10.0, <0.10.43 | \>=1.0, <0.2                                      |
  | \>=0.9.14, <0.10.0  | 0.1.3                                             |



  Install packages needed for this demonstration.

  ```shell
  python -m pip install --upgrade \
      openinference-instrumentation-llama-index \
      opentelemetry-sdk \
      opentelemetry-exporter-otlp \
      "opentelemetry-proto>=1.12.0" \
      arize-phoenix
  ```

  Start the Phoenix app in the background as a collector. By default, it listens on `http://localhost:6006`. You can visit the app via a browser at the same address.

  The Phoenix app does not send data over the internet. It only operates locally on your machine.

  ```shell
  python -m phoenix.server.main serve
  ```

  The following Python code sets up the `LlamaIndexInstrumentor` to trace `llama-index` and send the traces to Phoenix at the endpoint shown below.

  ```python
  from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
  from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
  from opentelemetry.sdk import trace as trace_sdk
  from opentelemetry.sdk.trace.export import SimpleSpanProcessor

  endpoint = "http://127.0.0.1:6006/v1/traces"
  tracer_provider = trace_sdk.TracerProvider()
  tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))

  LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
  ```

  To demonstrate tracing, we'll use LlamaIndex below to query a document.

  First, download a text file.

  ```python
  import tempfile
  from urllib.request import urlretrieve
  from llama_index.core import SimpleDirectoryReader

  url = "https://raw.githubusercontent.com/Arize-ai/phoenix-assets/main/data/paul_graham/paul_graham_essay.txt"
  with tempfile.NamedTemporaryFile() as tf:
      urlretrieve(url, tf.name)
      documents = SimpleDirectoryReader(input_files=[tf.name]).load_data()
  ```

  Next, we'll query using OpenAI. To do that you need to set up your OpenAI API key in an environment variable.

  ```python
  import os

  os.environ["OPENAI_API_KEY"] = "<your openai key>"
  ```

  Now we can query the indexed documents.

  ```python
  from llama_index.core import VectorStoreIndex

  query_engine = VectorStoreIndex.from_documents(documents).as_query_engine()
  print(query_engine.query("What did the author do growing up?"))
  ```

  Visit the Phoenix app at `http://localhost:6006` to see the traces.



  * [More info on OpenInference and Phoenix](https://docs.arize.com/phoenix)
  * [How to customize spans to track sessions, metadata, etc.](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#customizing-spans)
  * [How to account for private information and span payload customization](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#tracing-configuration)

url:
  https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-llama-index


pkgId: 0560d7b3027c440ba76dc70abe32c9259d31419324c2ec7116aa1cd63c67684f
name: python-openlane-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for openlane
url: https://efabless.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openlane-2.3.0-1.src.rpm
location_href: Packages/python-openlane-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/The-OpenROAD-Project/OpenLane">
          <img src="./docs/_static/support_banner.svg" style="width: 70%;overflow: visible" alt="Banner explaining that OpenLane 2.0 is not the primary supported option for hardening Caravel User Project-based designs targeting chipIgnite"/>
      </a>
  </p>

  <h1 align="center">OpenLane</h1>
  <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: Apache 2.0"/></a>
      <a href="https://www.python.org"><img src="https://img.shields.io/badge/Python-3.8-3776AB.svg?style=flat&logo=python&logoColor=white" alt="Python 3.8 or higher" /></a>
      <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code Style: black"/></a>
      <a href="https://mypy-lang.org/"><img src="https://www.mypy-lang.org/static/mypy_badge.svg" alt="Checked with mypy"/></a>
      <a href="https://nixos.org/"><img src="https://img.shields.io/static/v1?logo=nixos&logoColor=white&label=&message=Built%20with%20Nix&color=41439a" alt="Built with Nix"/></a>
  </p>
  <p align="center">
      <a href="https://colab.research.google.com/github/efabless/openlane2/blob/main/notebook.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open in Colab"></a>
      <a href="https://openlane2.readthedocs.io/"><img src="https://readthedocs.org/projects/openlane2/badge/?version=latest" alt="Documentation Build Status Badge"/></a>
      <a href="https://open-source-silicon.dev"><img src="https://img.shields.io/badge/Community-Open%20Source%20Silicon%20Slack-ff69b4?logo=slack" alt="Invite to the Open Source Silicon Slack"/></a>
  </p>

  OpenLane is an ASIC infrastructure library based on several components including
  OpenROAD, Yosys, Magic, Netgen, CVC, KLayout and a number of custom scripts for
  design exploration and optimization.

  A reference flow, "Classic", performs all ASIC implementation steps from RTL all
  the way down to GDSII.

  You can find the documentation
  [here](https://openlane2.readthedocs.io/en/latest/getting_started/) to get
  started. You can discuss OpenLane 2 in the
  [#openlane-2](https://open-source-silicon.slack.com/archives/C05M85Q5GCF)
  channel of the
  [Efabless Open Source Silicon Slack](https://invite.skywater.tools).

  ```mermaid
  timeline
    title The OpenLane Infrastructure
    RTL to Netlist
      : Linting / Verilator
      : Power Distribution Network Hierarchy / Yosys
      : Synthesis / Yosys
      : Synthesis / Design Compiler (with proprietary plugin)
      : Multi-corner Netlist STA / OpenSTA
    Floorplanning
      : Floorplan Initialization / OpenROAD
      : Manual Macro Placement / OpenDB
      : Tap/Endcap Insertion / OpenROAD
      : PDN Generation / OpenROAD
    Placement
      : Pin Placement (from config file) / OpenROAD, OpenDB
      : Pin Placement (Random/Matching/Annealing) / OpenROAD
      : Pin Placement (from template DEF) / OpenDB
      : Global Placement / OpenROAD
      : Resizer Design Repair (Post-GPL) / OpenROAD
      : Detailed Placement / OpenROAD
    Clock Tree Synthesis
      : Clock-Tree Synthesis / OpenROAD
      : Resizer Timing Repair (Post-CTS) / OpenROAD
    Routing
      : Global Routing / OpenROAD
      : Resizer Design Repair (Post-GRT) / OpenROAD
      : Diode Insertion on Ports / OpenDB
      : Heuristic Diode Insertion / OpenDB
      : Antenna Repair / OpenROAD
      : Resizer Timing Repair (Post-GRT) / OpenROAD
      : Detailed Routing / OpenROAD
      : Row Filling / OpenROAD
    Signoff (Timing)
      : Parasitics Extraction / OpenROAD
      : Multi-corner Static Timing Analysis / OpenSTA
      : SI-Enabled Multi-corner Static Timing Analysis / PrimeTime (with proprietary plugin)
    Signoff (Physical)
      : GDSII Stream-Out / Magic
      : GDSII Stream-Out / KLayout
      : Magic vs. KLayout Stream XOR / KLayout
      : Design Rule Checks / Magic
      : Design Rule Checks / KLayout
      : Spice Extraction / Magic
      : Layout vs. Schematic / Netgen
      : Equivalence Check (Alpha) / Yosys EQY
  ```



  You can try OpenLane right in your browser, free-of-charge, using Google
  Colaboratory by following
  [**this link**](https://colab.research.google.com/github/efabless/openlane2/blob/main/notebook.ipynb).



  You'll need the following:

  * Python **3.8** or higher with PIP, Venv and Tkinter



  Works for macOS and Linux (x86-64 and aarch64). Recommended, as it is more
  integrated with your filesystem and overall has less upload and download deltas.

  See
  [Nix-based installation](https://openlane2.readthedocs.io/en/latest/getting_started/common/nix_installation/index.html)
  in the docs for more info.



  Works for Windows, macOS and Linux (x86-64 and aarch64).

  See
  [Docker-based installation](https://openlane2.readthedocs.io/en/latest/getting_started/common/docker_installation/index.html)
  in the docs for more info.

  Do note you'll need to add `--dockerized` right after `openlane` in most CLI
  invocations.



  **You'll need to bring your own compiled utilities**, but otherwise, simply
  install OpenLane as follows:

  ```sh
  python3 -m pip install --upgrade openlane
  ```

  Python-only installations are presently unsupported and entirely at your own
  risk.



  In the root folder of the repository, you may invoke:

  ```sh
  python3 -m openlane --pdk-root <path/to/pdk> </path/to/config.json>
  ```

  To start with, you can try:

  ```sh
  python3 -m openlane --pdk-root $HOME/.volare ./designs/spm/config.json
  ```



  If you use OpenLane in your research, please cite the following paper.

  * M. Shalan and T. Edwards, “Building OpenLANE: A 130nm OpenROAD-based
    Tapeout-Proven Flow: Invited Paper,” *2020 IEEE/ACM International Conference
    On Computer Aided Design (ICCAD)*, San Diego, CA, USA, 2020, pp. 1-6.
    [Paper](https://ieeexplore.ieee.org/document/9256623)

  ```bibtex
  @INPROCEEDINGS{9256623,
    author={Shalan, Mohamed and Edwards, Tim},
    booktitle={2020 IEEE/ACM International Conference On Computer Aided Design (ICCAD)},
    title={Building OpenLANE: A 130nm OpenROAD-based Tapeout- Proven Flow : Invited Paper},
    year={2020},
    volume={},
    number={},
    pages={1-6},
    doi={}}
  ```



  [The Apache License, version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt).

  Docker images distributed by Efabless Corporation under the same license.

  Binaries bundled with OpenLane either via Cachix or Docker are distributed by
  Efabless Corporation and may fall under stricter open source licenses.


pkgId: 73cee1b2fab8857a0e1d9b2d285a3cb203e9a0fe4fde61b492d68d451018091b
name: python-openlayer-help
arch: noarch
version: 0.2.0a41
epoch: 0
release: 1
summary: Development documents and examples for openlayer
url: https://github.com/openlayer-ai/openlayer-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openlayer-0.2.0a41-1.src.rpm
location_href: Packages/python-openlayer-help-0.2.0a41-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/openlayer.svg)](https://pypi.org/project/openlayer/)

  The Openlayer Python library provides convenient access to the Openlayer REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [openlayer.com](https://openlayer.com/docs/api-reference/rest/overview). The full API of this library can be found in [api.md](https://github.com/openlayer-ai/openlayer-python/tree/main/api.md).



  ```sh

  pip install --pre openlayer
  ```



  The full API of this library can be found in [api.md](https://github.com/openlayer-ai/openlayer-python/tree/main/api.md).

  ```python
  import os
  from openlayer import Openlayer

  client = Openlayer(
      api_key=os.environ.get("OPENLAYER_API_KEY"),  # This is the default and can be omitted
  )

  response = client.inference_pipelines.data.stream(
      inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
      config={
          "input_variable_names": ["user_query"],
          "output_column_name": "output",
          "num_of_token_column_name": "tokens",
          "cost_column_name": "cost",
          "timestamp_column_name": "timestamp",
      },
      rows=[
          {
              "user_query": "what is the meaning of life?",
              "output": "42",
              "tokens": 7,
              "cost": 0.02,
              "timestamp": 1610000000,
          }
      ],
  )
  print(response.success)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `OPENLAYER_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncOpenlayer` instead of `Openlayer` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from openlayer import AsyncOpenlayer

  client = AsyncOpenlayer(
      api_key=os.environ.get("OPENLAYER_API_KEY"),  # This is the default and can be omitted
  )


  async def main() -> None:
      response = await client.inference_pipelines.data.stream(
          inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
          config={
              "input_variable_names": ["user_query"],
              "output_column_name": "output",
              "num_of_token_column_name": "tokens",
              "cost_column_name": "cost",
              "timestamp_column_name": "timestamp",
          },
          rows=[
              {
                  "user_query": "what is the meaning of life?",
                  "output": "42",
                  "tokens": 7,
                  "cost": 0.02,
                  "timestamp": 1610000000,
              }
          ],
      )
      print(response.success)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `openlayer.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `openlayer.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `openlayer.APIError`.

  ```python
  import openlayer
  from openlayer import Openlayer

  client = Openlayer()

  try:
      client.inference_pipelines.data.stream(
          inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
          config={
              "input_variable_names": ["user_query"],
              "output_column_name": "output",
              "num_of_token_column_name": "tokens",
              "cost_column_name": "cost",
              "timestamp_column_name": "timestamp",
          },
          rows=[
              {
                  "user_query": "what is the meaning of life?",
                  "output": "42",
                  "tokens": 7,
                  "cost": 0.02,
                  "timestamp": 1610000000,
              }
          ],
      )
  except openlayer.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except openlayer.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except openlayer.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from openlayer import Openlayer


  client = Openlayer(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).inference_pipelines.data.stream(
      inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
      config={
          "input_variable_names": ["user_query"],
          "output_column_name": "output",
          "num_of_token_column_name": "tokens",
          "cost_column_name": "cost",
          "timestamp_column_name": "timestamp",
      },
      rows=[
          {
              "user_query": "what is the meaning of life?",
              "output": "42",
              "tokens": 7,
              "cost": 0.02,
              "timestamp": 1610000000,
          }
      ],
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from openlayer import Openlayer


  client = Openlayer(
      
      timeout=20.0,
  )


  client = Openlayer(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).inference_pipelines.data.stream(
      inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
      config={
          "input_variable_names": ["user_query"],
          "output_column_name": "output",
          "num_of_token_column_name": "tokens",
          "cost_column_name": "cost",
          "timestamp_column_name": "timestamp",
      },
      rows=[
          {
              "user_query": "what is the meaning of life?",
              "output": "42",
              "tokens": 7,
              "cost": 0.02,
              "timestamp": 1610000000,
          }
      ],
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/openlayer-ai/openlayer-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `OPENLAYER_LOG` to `info`.

  ```shell
  $ export OPENLAYER_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from openlayer import Openlayer

  client = Openlayer()
  response = client.inference_pipelines.data.with_raw_response.stream(
      inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
      config={
          "input_variable_names": ["user_query"],
          "output_column_name": "output",
          "num_of_token_column_name": "tokens",
          "cost_column_name": "cost",
          "timestamp_column_name": "timestamp",
      },
      rows=[{
          "user_query": "what is the meaning of life?",
          "output": "42",
          "tokens": 7,
          "cost": 0.02,
          "timestamp": 1610000000,
      }],
  )
  print(response.headers.get('X-My-Header'))

  data = response.parse()  # get the object that `inference_pipelines.data.stream()` would have returned
  print(data.success)
  ```

  These methods return an [`APIResponse`](https://github.com/openlayer-ai/openlayer-python/tree/main/src/openlayer/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/openlayer-ai/openlayer-python/tree/main/src/openlayer/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.inference_pipelines.data.with_streaming_response.stream(
      inference_pipeline_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e",
      config={
          "input_variable_names": ["user_query"],
          "output_column_name": "output",
          "num_of_token_column_name": "tokens",
          "cost_column_name": "cost",
          "timestamp_column_name": "timestamp",
      },
      rows=[
          {
              "user_query": "what is the meaning of life?",
              "output": "42",
              "tokens": 7,
              "cost": 0.02,
              "timestamp": 1610000000,
          }
      ],
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for [proxies](https://www.python-httpx.org/advanced/proxies/)
  - Custom [transports](https://www.python-httpx.org/advanced/transports/)
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  import httpx
  from openlayer import Openlayer, DefaultHttpxClient

  client = Openlayer(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxy="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/openlayer-ai/openlayer-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import openlayer
  print(openlayer.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/openlayer-ai/openlayer-python/tree/main/./CONTRIBUTING.md).


pkgId: 44ca0efafdb24f3516c02d518094c48600e72948b863369e856dd2541eefbe89
name: python-openllm-help
arch: noarch
version: 0.6.16
epoch: 0
release: 1
summary: Development documents and examples for openllm
url: https://bentoml.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openllm-0.6.16-1.src.rpm
location_href: Packages/python-openllm-help-0.6.16-1.noarch.rpm
checksum_type: sha256
description:
  [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202-green.svg)](https://github.com/bentoml/OpenLLM/blob/main/LICENSE)
  [![Releases](https://img.shields.io/pypi/v/openllm.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/openllm)
  [![CI](https://results.pre-commit.ci/badge/github/bentoml/OpenLLM/main.svg)](https://results.pre-commit.ci/latest/github/bentoml/OpenLLM/main)
  [![X](https://badgen.net/badge/icon/@bentomlai/000000?icon=twitter&label=Follow)](https://twitter.com/bentomlai)
  [![Community](https://badgen.net/badge/icon/Community/562f5d?icon=slack&label=Join)](https://l.bentoml.com/join-slack)

  OpenLLM allows developers to run **any open-source LLMs** (Llama 3.2, Qwen2.5, Phi3 and [more](#supported-models)) or **custom models** as **OpenAI-compatible APIs** with a single command. It features a [built-in chat UI](#chat-ui), state-of-the-art inference backends, and a simplified workflow for creating enterprise-grade cloud deployment with Docker, Kubernetes, and [BentoCloud](#deploy-to-bentocloud).

  Understand the [design philosophy of OpenLLM](https://www.bentoml.com/blog/from-ollama-to-openllm-running-llms-in-the-cloud).



  Run the following commands to install OpenLLM and explore it interactively.

  ```bash
  pip install openllm  # or pip3 install openllm
  openllm hello
  ```



  ![hello](https://github.com/user-attachments/assets/5af19f23-1b34-4c45-b1e0-a6798b4586d1)



  OpenLLM supports a wide range of state-of-the-art open-source LLMs. You can also add a [model repository to run custom models](#set-up-a-custom-repository) with OpenLLM.

  | Model            | Parameters | Quantization | Required GPU  | Start a Server                      |
  | ---------------- | ---------- | ------------ | ------------- | ----------------------------------- |
  | Llama 3.2        | 1B         | -            | 12G           | `openllm serve llama3.2:1b`         |
  | Llama 3.2        | 3B         | -            | 12G           | `openllm serve llama3.2:3b`         |
  | Llama 3.2 Vision | 11B        | -            | 80G           | `openllm serve llama3.2:11b-vision` |
  | Mistral          | 7B         | -            | 24G           | `openllm serve mistral:7b`          |
  | Qwen 2.5         | 1.5B       | -            | 12G           | `openllm serve qwen2.5:1.5b`        |
  | Gemma 2          | 9B         | -            | 24G           | `openllm serve gemma2:9b`           |
  | Phi3             | 3.8B       | -            | 12G           | `openllm serve phi3:3.8b`           |

  ...

  For the full model list, see the [OpenLLM models repository](https://github.com/bentoml/openllm-models).



  To start an LLM server locally, use the `openllm serve` command and specify the model version.

  > [!NOTE]
  > OpenLLM does not store model weights. A Hugging Face token (HF_TOKEN) is required for gated models.
  > 1. Create your Hugging Face token [here](https://huggingface.co/settings/tokens).
  > 2. Request access to the gated model, such as [meta-llama/Meta-Llama-3-8B](https://huggingface.co/meta-llama/Meta-Llama-3-8B).
  > 3. Set your token as an environment variable by running:
  >    ```bash
  >    export HF_TOKEN=<your token>
  >    ```

  ```bash
  openllm serve llama3:8b
  ```

  The server will be accessible at [http://localhost:3000](http://localhost:3000/), providing OpenAI-compatible APIs for interaction. You can call the endpoints with different frameworks and tools that support OpenAI-compatible APIs. Typically, you may need to specify the following:

  - **The API host address**: By default, the LLM is hosted at [http://localhost:3000](http://localhost:3000/).
  - **The model name:** The name can be different depending on the tool you use.
  - **The API key**: The API key used for client authentication. This is optional.

  Here are some examples:

  <details>

  <summary>OpenAI Python client</summary>

  ```python
  from openai import OpenAI

  client = OpenAI(base_url='http://localhost:3000/v1', api_key='na')





  chat_completion = client.chat.completions.create(
      model="meta-llama/Meta-Llama-3-8B-Instruct",
      messages=[
          {
              "role": "user",
              "content": "Explain superconductors like I'm five years old"
          }
      ],
      stream=True,
  )
  for chunk in chat_completion:
      print(chunk.choices[0].delta.content or "", end="")
  ```

  </details>


  <details>

  <summary>LlamaIndex</summary>

  ```python
  from llama_index.llms.openai import OpenAI

  llm = OpenAI(api_bese="http://localhost:3000/v1", model="meta-llama/Meta-Llama-3-8B-Instruct", api_key="dummy")
  ...
  ```
  </details>



  OpenLLM provides a chat UI at the `/chat` endpoint for the launched LLM server at http://localhost:3000/chat.

  <img width="800" alt="openllm_ui" src="https://github.com/bentoml/OpenLLM/assets/5886138/8b426b2b-67da-4545-8b09-2dc96ff8a707">



  To start a chat conversation in the CLI, use the `openllm run` command and specify the model version.

  ```bash
  openllm run llama3:8b
  ```



  A model repository in OpenLLM represents a catalog of available LLMs that you can run. OpenLLM provides a default model repository that includes the latest open-source LLMs like Llama 3, Mistral, and Qwen2, hosted at [this GitHub repository](https://github.com/bentoml/openllm-models). To see all available models from the default and any added repository, use:

  ```bash
  openllm model list
  ```

  To ensure your local list of models is synchronized with the latest updates from all connected repositories, run:

  ```bash
  openllm repo update
  ```

  To review a model’s information, run:

  ```bash
  openllm model get llama3:8b
  ```



  You can contribute to the default model repository by adding new models that others can use. This involves creating and submitting a Bento of the LLM. For more information, check out this [example pull request](https://github.com/bentoml/openllm-models/pull/1).



  You can add your own repository to OpenLLM with custom models. To do so, follow the format in the default OpenLLM model repository with a `bentos` directory to store custom LLMs. You need to [build your Bentos with BentoML](https://docs.bentoml.com/en/latest/guides/build-options.html) and submit them to your model repository.

  First, prepare your custom models in a `bentos` directory following the guidelines provided by [BentoML to build Bentos](https://docs.bentoml.com/en/latest/guides/build-options.html). Check out the [default model repository](https://github.com/bentoml/openllm-repo) for an example and read the [Developer Guide](https://github.com/bentoml/OpenLLM/blob/main/DEVELOPMENT.md) for details.

  Then, register your custom model repository with OpenLLM:

  ```bash
  openllm repo add <repo-name> <repo-url>
  ```

  **Note**: Currently, OpenLLM only supports adding public repositories.



  OpenLLM supports LLM cloud deployment via BentoML, the unified model serving framework, and BentoCloud, an AI inference platform for enterprise AI teams. BentoCloud provides fully-managed infrastructure optimized for LLM inference with autoscaling, model orchestration, observability, and many more, allowing you to run any AI model in the cloud.

  [Sign up for BentoCloud](https://www.bentoml.com/) for free and [log in](https://docs.bentoml.com/en/latest/bentocloud/how-tos/manage-access-token.html). Then, run `openllm deploy` to deploy a model to BentoCloud:

  ```bash
  openllm deploy llama3:8b
  ```

  > [!NOTE]
  > If you are deploying a gated model, make sure to set HF_TOKEN in enviroment variables.

  Once the deployment is complete, you can run model inference on the BentoCloud console:

  <img width="800" alt="bentocloud_ui" src="https://github.com/bentoml/OpenLLM/assets/65327072/4f7819d9-73ea-488a-a66c-f724e5d063e6">



  OpenLLM is actively maintained by the BentoML team. Feel free to reach out and join us in our pursuit to make LLMs more accessible and easy to use 👉 [Join our Slack community!](https://l.bentoml.com/join-slack)



  As an open-source project, we welcome contributions of all kinds, such as new features, bug fixes, and documentation. Here are some of the ways to contribute:

  - Repost a bug by [creating a GitHub issue](https://github.com/bentoml/OpenLLM/issues/new/choose).
  - [Submit a pull request](https://github.com/bentoml/OpenLLM/compare) or help review other developers’ [pull requests](https://github.com/bentoml/OpenLLM/pulls).
  - Add an LLM to the OpenLLM default model repository so that other users can run your model. See the [pull request template](https://github.com/bentoml/openllm-models/pull/1).
  - Check out the [Developer Guide](https://github.com/bentoml/OpenLLM/blob/main/DEVELOPMENT.md) to learn more.



  This project uses the following open-source projects:

  - [bentoml/bentoml](https://github.com/bentoml/bentoml) for production level model serving
  - [vllm-project/vllm](https://github.com/vllm-project/vllm) for production level LLM backend
  - [blrchen/chatgpt-lite](https://github.com/blrchen/chatgpt-lite) for a fancy Web Chat UI
  - [chujiezheng/chat_templates](https://github.com/chujiezheng/chat_templates)
  - [astral-sh/uv](https://github.com/astral-sh/uv) for blazing fast model requirements installing

  We are grateful to the developers and contributors of these projects for their hard work and dedication.


pkgId: aa146a1b38038a42cb91a1a3f5bb9d7d8a05ca31b8679a61095418f9a22d1c96
name: python-openlxp-xia-help
arch: noarch
version: 1.6.1
epoch: 0
release: 1
summary: Development documents and examples for openlxp-xia
url: https://github.com/OpenLXP/openlxp-xia/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openlxp-xia-1.6.1-1.src.rpm
location_href: Packages/python-openlxp-xia-help-1.6.1-1.noarch.rpm
checksum_type: sha256
description:
  OpenLXP XIA is a Python package that provides the validation functionality of extracted metadata from the source. In addition, it helps transform metadata into target metadata and further load it into indexing services. The OpenLXP XIA package does not include the metadata extraction process because extraction methods can be different for different sources. But once metadata gets extracted from the source, OpenLXP-XIA continues the V-T-V-L  (Validate-Transform-Validate-Load) cycle.

  The schema files used for validation can be placed on the schema server. Currently, OpenLXP-XIA uses AWS S3 buckets as a schema server.

  Below are the workflow which are performed by the OpenLXP-XIA after package installation.



  The OpenLXP-XIA implements five core workflows after extracting metadata from the Specifiec source, as follows:

  1. `Validate`: Compares extracted learning experience metadata against the configured source metadata reference schema stored in the Experience Schema Service (XSS).

  2. `Transform`: Transforms extracted+validated source learning experience metadata to the configured target schema using the "XSR-to-Target" transformation map stored in the Experience Schema Service (XSS)

  3. `Validate`: Compares transformed learning experience metadata against the configured target metadata reference schema stored in the Experience Schema Service (XSS).

  4. `Load`: Pushes transformed and validated learning experience metadata to the target Experience Index Service (XIS) for further processing.

  5. `Log`: Records error, warning, informational, and debug events which can be reviewed and monitored.


  `Python >=3.7` : Download and install python from here [Python](https://www.python.org/downloads/).




      $ python -m pip install OpenLXP-XIA (use the latest package version)

  Add OpenLXP-XIA in the setting.py in your project.

  INSTALLED_APPS = [
          ...

          'openlxp_xia',

          ....
  ]



  1. On the Admin page, log in with the admin credentials

  2. `Add xis configuration`: Configure Experience Index Services (XIS):

      `Xis metadata api endpoint`: API endpoint for XIS where metadata will get stored.

      Example:
      `Xis metadata api endpoint`: http://localhost:8080/api/metadata/

      `Xis supplemental api endpoint`: API endpoint for XIS where supplemental metadata will get stored.

      Example:
      `Xis supplemental api endpoint`: http://openlxp-xis:8020/api/supplemental-data/

      (Note: Replace localhost with the XIS Host)


  3.  `Add xia configuration` : Configure Experience Index Agents(XIA):

      `Publisher`: Agent Name

      `Xss api`: API endpoint for XSS where schemas will be retrieved from.

      Example:
      `Xss api`: https://localhost:8000/api/

      `Source metadata schema`: Schema iri or name for source metadata validation

      `Target metadata schema`: Schema iri or name for target metadata validation

      (Note: Please make sure to upload schema files in the Experience Schema Server (XSS). )


  4. `Add metadata field overwrite`: Here, we can add new fields and their values or overwrite values for existing fields.

      `Field name`: Add new or existing field Name

      `Field type`: Add date type of the field

      `Field value`: Add corresponding value

      `Overwrite`: Check the box if existing values need to be overwritten.



  ETL or EVTVL (Extract-Transform-Load) Pipeline can be run through two ways:

  1. Through API Endpoint:
  To run ETL tasks run below API:

      http://localhost:8000/api/xia-workflow
  (Note: Change localhost with XIA host)

  2. Periodically through celery beat:
   On the admin page add periodic task and it's schedule. On selected time interval celery task will run.



  To check the running of celery tasks, check the logs of application and celery container.








   This project uses the [MIT](http://www.apache.org/licenses/LICENSE-2.0) license.


pkgId: f9a6a1d28d756875155d562bfee894cbeb6e59a10e3c6f4635b76aeb8b1f65d3
name: python-openmdao-help
arch: noarch
version: 3.36.0
epoch: 0
release: 1
summary: Development documents and examples for openmdao
url: http://openmdao.org
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openmdao-3.36.0-1.src.rpm
location_href: Packages/python-openmdao-help-3.36.0-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Actions Test Badge][17]][18]
  [![Coveralls Badge][13]][14]
  [![PyPI version][10]][11]
  [![PyPI Monthly Downloads][12]][11]



  OpenMDAO is an open-source high-performance computing platform for
  systems analysis and multidisciplinary optimization, written in Python.
  It enables you to decompose your models, making them easier to build and
  maintain, while still solving them in a tightly coupled manner with
  efficient parallel numerical methods.

  The OpenMDAO project is primarily focused on supporting gradient-based
  optimization with analytic derivatives to allow you to explore large
  design spaces with hundreds or thousands of design variables, but the
  framework also has a number of parallel computing features that can
  work with gradient-free optimization, mixed-integer nonlinear
  programming, and traditional design space exploration.

  If you are using OpenMDAO, please [cite][20] us!



  Documentation for the latest development version can be found [here][2].

  Documentation for all released versions can be found [here][3].



  While the API is relatively stable, **OpenMDAO** remains in active development.
  There will be periodic changes to the API.
  User's are encouraged to pin their version of OpenMDAO to a recent release and
  update periodically.



  You have two options for installing **OpenMDAO**, (1) from the
  [Python Package Index (PyPI)][1], and (2) from the [GitHub repository][4].

  **OpenMDAO** includes several optional sets of dependencies including:
  `test` for installing the developer tools (e.g., testing, coverage),
  `docs` for building the documentation and
  `visualization` for some extra visualization tools.
  Specifying `all` will include all of the optional dependencies.



  This is the easiest way to install **OpenMDAO**. To install only the runtime
  dependencies:

      pip install openmdao

  To install all the optional dependencies:

      pip install openmdao[all]



  This allows you to install **OpenMDAO** from a local copy of the source code.

      git clone http://github.com/OpenMDAO/OpenMDAO
      cd OpenMDAO
      pip install .

  If you would like to make changes to **OpenMDAO** it is recommended you
  install it in *[editable][16]* mode (i.e., development mode) by adding the `-e`
  flag when calling `pip`, this way any changes you make to the source code will
  be included when you import **OpenMDAO** in *Python*. You will also want to
  install the packages necessary for running **OpenMDAO**'s tests and documentation
  generator.  You can install everything needed for development by running:

      pip install -e OpenMDAO[all]



  **OpenMDAO 3.x.y** represents the current, supported version. It requires Python 3.8
  or later and is maintained [here][4]. To upgrade to the latest release, run:

      pip install --upgrade openmdao

  **OpenMDAO 2.10.x** was the last version to support Python 2.x and is no longer supported.
  To install this older release, run:

      pip install "openmdao<3"

  **OpenMDAO 1.7.4** was an earlier version of OpenMDAO and is also no longer supported.
  The code repository is now named **OpenMDAO1**, and has moved [here][5]. To install it, run:

      pip install "openmdao<2"

  The legacy **OpenMDAO v0.x** (versions 0.13.0 and older) of the
  **OpenMDAO-Framework** are [here][6].



  Users are encouraged to run the unit tests to ensure **OpenMDAO** is performing
  correctly.  In order to do so, you must install the testing dependencies.

  1. Install **OpenMDAO** and its testing dependencies:

      `pip install openmdao[test]`

      > Alternatively, you can clone the repository, as explained
      [here](#install-from-a-cloned-repository), and install the development
      dependencies as described [here](#install-the-developer-dependencies).

  2. Run tests:

      `testflo openmdao -n 1`

  3. If everything works correctly, you should see a message stating that there
  were zero failures.  If the tests produce failures, you are encouraged to report
  them as an [issue][7].  If so, please make sure you include your system spec,
  and include the error message.

      > If tests fail, please include your system information, you can obtain
      that by running the following commands in *python* and copying the results
      produced by the last line.

          import platform, sys

          info = platform.uname()
          (info.system, info.version), (info.machine, info.processor), sys.version

      > Which should produce a result similar to:

          (('Windows', '10.0.17134'),
           ('AMD64', 'Intel64 Family 6 Model 94 Stepping 3, GenuineIntel'),
           '3.6.6 | packaged by conda-forge | (default, Jul 26 2018, 11:48:23) ...')



  Documentation for the latest version can always be found [here][2], but if you would like to build a local copy you can find instructions to do so [here][19].

  [0]: http://openmdao.org/ "OpenMDAO"
  [1]: https://pypi.org/project/openmdao/ "OpenMDAO @PyPI"

  [2]: http://openmdao.org/newdocs/versions/latest "Latest Docs"
  [3]: http://openmdao.org/docs "Archived Docs"

  [4]: https://github.com/OpenMDAO/OpenMDAO "OpenMDAO Git Repo"
  [5]: https://github.com/OpenMDAO/OpenMDAO1 "OpenMDAO 1.x Git Repo"
  [6]: https://github.com/OpenMDAO/OpenMDAO-Framework "OpenMDAO Framework Git Repo"

  [7]: https://github.com/OpenMDAO/OpenMDAO/issues/new "Make New OpenMDAO Issue"

  [8]: https://help.github.com/articles/changing-a-remote-s-url/ "Update Git Remote URL"

  [10]: https://badge.fury.io/py/openmdao.svg "PyPI Version"
  [11]: https://badge.fury.io/py/openmdao "OpenMDAO @PyPI"

  [12]: https://img.shields.io/pypi/dm/openmdao "PyPI Monthly Downloads"

  [13]: https://coveralls.io/repos/github/OpenMDAO/OpenMDAO/badge.svg?branch=master "Coverage Badge"
  [14]: https://coveralls.io/github/OpenMDAO/OpenMDAO?branch=master "OpenMDAO @Coveralls"

  [15]: https://en.wikipedia.org/wiki/Software_release_life_cycle#Beta "Wikipedia Beta"

  [16]: https://setuptools.readthedocs.io/en/latest/setuptools.html#development-mode "Pip Editable Mode"

  [17]: https://github.com/OpenMDAO/OpenMDAO/actions/workflows/openmdao_test_workflow.yml/badge.svg "Github Actions Badge"
  [18]: https://github.com/OpenMDAO/OpenMDAO/actions "Github Actions"

  [19]: http://openmdao.org/newdocs/versions/latest/other_useful_docs/developer_docs/doc_build.html

  [20]: https://openmdao.org/newdocs/versions/latest/other/citing.html


pkgId: 4ea23a056ec42c297c8fd7c8c98cda28451d301416098bd80985c6ae5de95eef
name: python-openmetadata-managed-apis-help
arch: noarch
version: 1.6.1.0
epoch: 0
release: 1
summary: Development documents and examples for openmetadata-managed-apis
url: https://open-metadata.org/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openmetadata-managed-apis-1.6.1.0-1.src.rpm
location_href: Packages/python-openmetadata-managed-apis-help-1.6.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a plugin for Apache Airflow >= 1.10 and Airflow >=2.x that exposes REST APIs to deploy an
  OpenMetadata workflow definition and manage DAGS and tasks.



  You can run `make branch=issue-3659-v2 test_up` and specify any branch from OpenMetadata that you'd
  need to test the changes in the APIs. This will prepare a separated airflow container.

  The command will build the image by downloading the branch changes inside the container. This helps us
  test the REST APIs using some ongoing changes on OpenMetadata as well.



  First, make sure that Airflow is properly installed with the latest version `2.3.3`. From
  the [docs](https://airflow.apache.org/docs/apache-airflow/stable/installation/installing-from-pypi.html):

  Then, install following packages in your scheduler and webserver python env.

  ```
  pip install openmetadata-airflow-managed-apis
  ```



  Add the following section to airflow.cfg

  ```
  [openmetadata_airflow_apis]
  dag_generated_configs = {AIRFLOW_HOME}/dag_generated_configs
  ```

  substitute AIRFLOW_HOME with your airflow installation home




  ```
  pip install "apache-airflow==2.3.3" --constraint "https://raw.githubusercontent.com/apache/airflow/constraints-2.3.3/constraints-3.9.txt"
  ```

  1. Install the package
  2. `mkdir -p {AIRFLOW_HOME}/dag_generated_configs`
  3. (re)start the airflow webserver and scheduler

      ```
      airflow webserver
      airflow scheduler
      ```



  You can check that the plugin is correctly loaded by going to `http://{AIRFLOW_HOST}:{AIRFLOW_PORT}/restapi`,
  or accessing the REST_API_PLUGIN view through the Admin dropdown.




  Plugin enables JWT Token based authentication for Airflow versions 1.10.4 or higher when RBAC support is enabled.



  ```bash
  curl -XPOST http://localhost:8080/api/v1/security/login -H "Content-Type: application/json" -d '{"username":"admin", "password":"admin", "refresh":true, "provider": "db"}'
  ```


  ```bash
  curl -X POST http://localhost:8080/api/v1/security/login -H "Content-Type: application/json" -d '{"username":"admin", "password":"admin", "refresh":true, "provider": "db"}'
  ```


  ```json
  {
   "access_token":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2MDQyMTc4MzgsIm5iZiI6MTYwNDIxNzgzOCwianRpIjoiMTI4ZDE2OGQtMTZiOC00NzU0LWJiY2EtMTEyN2E2ZTNmZWRlIiwiZXhwIjoxNjA0MjE4NzM4LCJpZGVudGl0eSI6MSwiZnJlc2giOnRydWUsInR5cGUiOiJhY2Nlc3MifQ.xSWIE4lR-_0Qcu58OiSy-X0XBxuCd_59ic-9TB7cP9Y",
   "refresh_token":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2MDQyMTc4MzgsIm5iZiI6MTYwNDIxNzgzOCwianRpIjoiZjA5NTNkODEtNWY4Ni00YjY0LThkMzAtYzg5NTYzMmFkMTkyIiwiZXhwIjoxNjA2ODA5ODM4LCJpZGVudGl0eSI6MSwidHlwZSI6InJlZnJlc2gifQ.VsiRr8_ulCoQ-3eAbcFz4dQm-y6732QR6OmYXsy4HLk"
  }
  ```
  By default, JWT access token is valid for 15 mins and refresh token is valid for 30 days. You can renew the access token with the help of refresh token as shown below.


  ```bash
  curl -X POST "http://{AIRFLOW_HOST}:{AIRFLOW_PORT}/api/v1/security/refresh" -H 'Authorization: Bearer <refresh_token>'
  ```

  ```bash
  curl -X POST "http://localhost:8080/api/v1/security/refresh" -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2MDQyMTc4MzgsIm5iZiI6MTYwNDIxNzgzOCwianRpIjoiZjA5NTNkODEtNWY4Ni00YjY0LThkMzAtYzg5NTYzMmFkMTkyIiwiZXhwIjoxNjA2ODA5ODM4LCJpZGVudGl0eSI6MSwidHlwZSI6InJlZnJlc2gifQ.VsiRr8_ulCoQ-3eAbcFz4dQm-y6732QR6OmYXsy4HLk'
  ```

  ```json
  {
   "access_token":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2MDQyODQ2OTksIm5iZiI6MTYwNDI4NDY5OSwianRpIjoiZDhhN2IzMmYtMWE5Zi00Y2E5LWFhM2ItNDEwMmU3ZmMyMzliIiwiZXhwIjoxNjA0Mjg1NTk5LCJpZGVudGl0eSI6MSwiZnJlc2giOmZhbHNlLCJ0eXBlIjoiYWNjZXNzIn0.qY2e-bNSgOY-YboinOoGqLfKX9aQkdRjo025mZwBadA"
  }
  ```



  ```json
  {"msg":"Missing Authorization Header"}
  ```

  Examples:
  ```bash
  curl -X GET -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2MDQyODQ2OTksIm5iZiI6MTYwNDI4NDY5OSwianRpIjoiZDhhN2IzMmYtMWE5Zi00Y2E5LWFhM2ItNDEwMmU3ZmMyMzliIiwiZXhwIjoxNjA0Mjg1NTk5LCJpZGVudGl0eSI6MSwiZnJlc2giOmZhbHNlLCJ0eXBlIjoiYWNjZXNzIn0.qY2e-bNSgOY-YboinOoGqLfKX9aQkdRjo025mZwBadA' http://localhost:8080/rest_api/api\?api\=dag_state\&dag_id\=dag_test\&run_id\=manual__2020-10-28T17%3A36%3A28.838356%2B00%3A00
  ```


  Once you deploy the plugin and restart the webserver, you can start to use the REST API. Bellow you will see the endpoints that are supported.

  **Note:** If enable RBAC, `http://{AIRFLOW_HOST}:{AIRFLOW_PORT}/rest_api/`<br>
  This web page will show the Endpoints supported and provide a form for you to test submitting to them.

  - [deploy_dag](#deploy_dag)
  - [delete_dag](#delete_dag)



  - Deploy a new dag, and refresh dag to session.

  ```text
  http://{AIRFLOW_HOST}:{AIRFLOW_PORT}/rest_api/api?api=deploy_dag
  ```

  - POST

  ```json
  {
  	"workflow": {
  		"name": "test_ingestion_x_35",
  		"force": "true",
  		"pause": "false",
  		"unpause": "true",
  		"dag_config": {
  			"test_ingestion_x_35": {
  				"default_args": {
  					"owner": "harsha",
  					"start_date": "2021-10-29T00:00:00.000Z",
  					"end_date": "2021-11-05T00:00:00.000Z",
  					"retries": 1,
  					"retry_delay_sec": 300
  				},
  				"schedule_interval": "0 3 * * *",
  				"concurrency": 1,
  				"max_active_runs": 1,
  				"dagrun_timeout_sec": 60,
  				"default_view": "tree",
  				"orientation": "LR",
  				"description": "this is an example dag!",
  				"tasks": {
  					"task_1": {
  						"operator": "airflow.operators.python_operator.PythonOperator",
  						"python_callable_name": "metadata_ingestion_workflow",
  						"python_callable_file": "metadata_ingestion.py",
  						"op_kwargs": {
  							"workflow_config": {
  								"metadata_server": {
  									"config": {
  										"api_endpoint": "http://localhost:8585/api",
  										"auth_provider_type": "no-auth"
  									},
  									"type": "metadata-server"
  								},
  								"sink": {
  									"config": {
  										"es_host": "localhost",
  										"es_port": 9200,
  										"index_dashboards": "true",
  										"index_tables": "true",
  										"index_topics": "true"
  									},
  									"type": "elasticsearch"
  								},
  								"source": {
  									"config": {
  										"include_dashboards": "true",
  										"include_tables": "true",
  										"include_topics": "true",
  										"limit_records": 10
  									},
  									"type": "metadata"
  								}
  							}
  						}
  					}
  				}
  			}
  		}
  	}
  }
  ```


  ```bash
  curl -H  'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE2MzU2NTE1MDAsIm5iZiI6MTYzNTY1MTUwMCwianRpIjoiNWQyZTM3ZDYtNjdiYS00NGZmLThjOWYtMDM0ZTQyNGE3MTZiIiwiZXhwIjoxNjM1NjUyNDAwLCJpZGVudGl0eSI6MSwiZnJlc2giOnRydWUsInR5cGUiOiJhY2Nlc3MifQ.DRUYCAiMh5h2pk1MZZJ4asyVFC20pu35DuAANQ5GxGw' -H 'Content-Type: application/json' -d "@test_ingestion_config.json" -X POST http://localhost:8080/rest_api/api\?api\=deploy_dag```

  ```json
  {"message": "Workflow [test_ingestion_x_35] has been created", "status": "success"}
  ```



  - Delete dag based on dag_id.

  ```text
  http://{AIRFLOW_HOST}:{AIRFLOW_PORT}/rest_api/api?api=delete_dag&dag_id=value
  ```

  - GET

  - dag_id - string - The id of dag.

  ```bash
  curl -X GET http://localhost:8080/rest_api/api?api=delete_dag&dag_id=dag_test
  ```

  ```json
  {
    "message": "DAG [dag_test] deleted",
    "status": "success"
  }
  ```

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


pkgId: ba5f582ade81b0d18062d5a1186ea508214813cddaa669b42460bc29e020d537
name: python-openmodule-help
arch: noarch
version: 14.0.2
epoch: 0
release: 1
summary: Development documents and examples for openmodule
url: https://gitlab.com/arivo-public/device-python/openmodule.git
rpm_license: GNU General Public License v2 (GPLv2)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openmodule-14.0.2-1.src.rpm
location_href: Packages/python-openmodule-help-14.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [TOC]



  You can install this library via pip:
  ```bash
  pip install openmodule
  ```



  During development it might be necessary to install a version of openmodule, where no pip package exists.
  Below you can find how to install a certain openmodule branch for your application with pip.



  Bash command:
  ```bash
  pip install "git+https://gitlab.com/arivo-public/device-python/openmodule@<branch>#egg=openmodule"
  ```

  requirements.txt:
  ```text
  git+https://gitlab.com/arivo-public/device-python/openmodule@<branch>#egg=openmodule
  ```



  Bash command:
  ```bash
  pip install "git+https://gitlab.com/arivo-public/device-python/openmodule@<branch>#egg=openmodule-test&subdirectory=openmodule_test"
  ```

  requirements.txt:
  ```text
  git+https://gitlab.com/arivo-public/device-python/openmodule@<branch>#egg=openmodule-test&subdirectory=openmodule_test
  ```



  Bash command:
  ```bash
  pip install "git+https://gitlab.com/arivo-public/device-python/openmodule@<branch>#egg=openmodule-commands&subdirectory=openmodule_commands
  ```

  requirements.txt:
  ```text
  git+https://gitlab.com/arivo-public/device-python/openmodule@<branch>#egg=openmodule-commands&subdirectory=openmodule_commands
  ```



  Sometimes you want to test local changes of the Openmodule library in device services and therefore you can do a local
  installation of the library. We use the
  [editable installs](https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs) of Pip for this.



  bash command:
  ```bash
  pip install -e <path_to_openmodule_root>
  ```



  bash command:
  ```bash
  pip install -e <path_to_openmodule_root>/openmodule_test/
  ```



  bash command:
  ```bash
  pip install -e <path_to_openmodule_root>/openmodule_commands/
  ```



  - [Breaking Changes](docs/migrations.md)
  - [Known Issues](docs/known_issues.md)





  - [Getting Started](docs/getting_started.md)
  - [Coding Standard](docs/coding_standard.md)
  - [Settings](docs/settings.md)
  - [RPC](docs/rpc.md)
  - [Health](docs/health.md)
  - [Database](docs/database.md)
  - [Eventlog](docs/event_sending.md)
  - [Package Reader](docs/package_reader.md)
  - [Anonymization](docs/anonymization.md)
  - [Connection Status Listener](docs/connection_status_listener.md)
  - [Settings Provider](docs/settings_provider.md)
  - [Access Service](docs/access_service.md)
  - [CSV Export](docs/csv_export.md)
  - [Translations](docs/translation.md)
  - [Utils](docs/utils.md)
  - [Deprecated Features](docs/deprecated.md)
  - [Testing](docs/testing.md)
  - [File Cleanup](docs/cleanup.md)



  - [Openmodule Commands](docs/commands.md)


pkgId: 8ca41852164bbb960b23bd4f7abdb0e0bfb551c514e7ba19307c8422a8af1dfc
name: python-openmsistream-help
arch: noarch
version: 1.8.2
epoch: 0
release: 1
summary: Development documents and examples for openmsistream
url: https://github.com/openmsi/openmsistream
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openmsistream-1.8.2-1.src.rpm
location_href: Packages/python-openmsistream-help-1.8.2-1.noarch.rpm
checksum_type: sha256
description:
  [![JOSS DOI](https://joss.theoj.org/papers/10.21105/joss.04896/status.svg)](https://doi.org/10.21105/joss.04896) ![PyPI](https://img.shields.io/pypi/v/openmsistream) ![License](https://img.shields.io/github/license/openmsi/openmsistream) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openmsistream) ![CircleCI](https://img.shields.io/circleci/build/github/openmsi/openmsistream/main) [![Documentation Status](https://readthedocs.org/projects/openmsistream/badge/?version=latest)](https://openmsistream.readthedocs.io/en/latest/?badge=latest) [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)

  Applications for laboratory, analysis, and computational materials data streaming using [Apache Kafka](https://kafka.apache.org/)

  Available on PyPI at https://pypi.org/project/openmsistream and GitHub at https://github.com/openmsi/openmsistream

  Official documentation at https://openmsistream.readthedocs.io/en/latest/

  Developed for Open MSI (NSF DMREF award #1921959); published in the [Journal of Open Source Software](https://doi.org/10.21105/joss.04896)


pkgId: aa424762bd3e7094c12fa4a37ccb25224f2b8b54d518a1b6fdcdeaa3aab97ab9
name: python-opennano-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for opennano
url: https://github.com/Niamhck/opennano
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opennano-0.1.0-1.src.rpm
location_href: Packages/python-opennano-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
     <img src="OpenNano.png",
     height=300>
  </div>



  Open Nano is a free open source python package developed to address a lack of python-based tools for analysing Nanostring GeoMx DSP data.

  From your dcc, pkc, and metadata files, you can:
  -  create an AnnData object of your data
  -  perform quality control and normalisation steps
  -  do a differential gene expression analysis
  -  look at spatial autocorralation with Moran's I statistic
  -  perform UMAP and tSNE clustering

  Benchmarked against GeoMxTools R package and DESeq2.

  See

  Created by Charalampos Anagostakis, Laura Beltrame, Cristiano Cordì, and Niamh Callian Keenan
  as part of the Integrated Bioinformatics Project for the MSc in Bioinformatics at KU Leuven, Belgium


pkgId: cfe6caa371e054f98b28d14bef35b51055db1861918324f3846f1fd4b4f9b536
name: python-openplx-bundles
arch: noarch
version: 0.15.5
epoch: 0
release: 1
summary: OpenPlx Bundles package, i.e. all OpenPLX sourcefiles and convenience access method in a package
url: https://pypi.org/project/openplx-bundles/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openplx-bundles-0.15.5-1.src.rpm
location_href: Packages/python-openplx-bundles-0.15.5-1.noarch.rpm
checksum_type: sha256
description:
  Contains all OpenPLX bundles such as Physics, Robotics, DriveTrain and Simulation.
  The package contains convenience methods and .openplx files.



  ```bash
  pip install openplxbundles
  ```



  [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0)



  ```python
  from openplxbundles import bundle_path
  assert os.path.exists(f"{bundle_path()}/Simulation/config.openplx")
  ```


pkgId: 07baf5fcd372fe42864d0329eb236e7edeac51be3293c064089e8204226ccd11
name: python-openpmd-beamphysics-help
arch: noarch
version: 0.9.12
epoch: 0
release: 1
summary: Development documents and examples for openpmd-beamphysics
url: https://github.com/ChristopherMayes/openPMD-beamphysics
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openpmd-beamphysics-0.9.12-1.src.rpm
location_href: Packages/python-openpmd-beamphysics-help-0.9.12-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/beamphysics-documentation-blue.svg)](https://christophermayes.github.io/openPMD-beamphysics/)  |
  Tools for analyzing and viewing particle data in the openPMD standard, extension beamphysics.
  https://github.com/openPMD/openPMD-standard/blob/upcoming-2.0.0/EXT_BeamPhysics.md

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


pkgId: 00c2e7c1d8e5dd8edb97e260623517f0d5b0f6d0b1e2ee497ca0e014c1bde44d
name: python-openpo-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for openpo
url: https://github.com/dannylee1020/openpo
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openpo-0.5.1-1.src.rpm
location_href: Packages/python-openpo-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/openpo.svg)](https://pypi.org/project/openpo/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Documentation](https://img.shields.io/badge/docs-docs.openpo.dev-blue)](https://docs.openpo.dev)
  ![Python](https://img.shields.io/badge/python->=3.10.1-blue.svg)


  OpenPO simplifies building synthetic datasets for preference tuning from 200+ LLMs.

  | Resources | Notebooks |
  |----------|----------|
  | Building dataset with OpenPO and PairRM  |📔 [Notebook](https://colab.research.google.com/drive/1G1T-vOTXjIXuRX3h9OlqgnE04-6IpwIf?usp=sharing) |



  OpenPO is an open source library that simplifies the process of building synthetic datasets for LLM preference tuning. By collecting outputs from 200 + LLMs and evaluating them using research-proven methodologies, OpenPO helps developers build better, more fine-tuned language models with minimal effort.



  - 🤖 **Multiple LLM Support**: Collect diverse set of outputs from 200+ LLMs

  - 📊 **Research-Backed Evaluation Methods**: Support for state-of-art evaluation methods for data synthesis

  - 💾 **Flexible Storage:** Out of the box storage providers for HuggingFace and S3.




  OpenPO uses pip for installation. Run the following command in the terminal to install OpenPO:

  ```bash
  pip install openpo
  ```


  Clone the repository first then run the follow command
  ```bash
  cd openpo
  poetry install
  ```


  set your environment variable first

  ```bash

  export HF_API_KEY=<your-api-key>
  export OPENROUTER_API_KEY=<your-api-key>


  export OPENAI_API_KEY=<your-openai-api-key>
  export ANTHROPIC_API_KEY=<your-anthropic-api-key>
  ```


  To get started with collecting LLM responses, simply pass in a list of model names of your choice

  > [!NOTE]
  > OpenPO requires provider name to be prepended to the model identifier.

  ```python
  import os
  from openpo import OpenPO

  client = OpenPO()

  response = client.completions(
      models = [
          "huggingface/Qwen/Qwen2.5-Coder-32B-Instruct",
          "huggingface/mistralai/Mistral-7B-Instruct-v0.3",
          "huggingface/microsoft/Phi-3.5-mini-instruct",
      ],
      messages=[
          {"role": "system", "content": PROMPT},
          {"role": "system", "content": MESSAGE},
      ],
  )
  ```

  You can also call models with OpenRouter.

  ```python

  client = OpenPO()

  response = client.completions(
      models = [
          "openrouter/qwen/qwen-2.5-coder-32b-instruct",
          "openrouter/mistralai/mistral-7b-instruct-v0.3",
          "openrouter/microsoft/phi-3.5-mini-128k-instruct",
      ],
      messages=[
          {"role": "system", "content": PROMPT},
          {"role": "system", "content": MESSAGE},
      ],

  )
  ```

  OpenPO takes default model parameters as a dictionary. Take a look at the documentation for more detail.

  ```python
  response = client.completions(
      models = [
          "huggingface/Qwen/Qwen2.5-Coder-32B-Instruct",
          "huggingface/mistralai/Mistral-7B-Instruct-v0.3",
          "huggingface/microsoft/Phi-3.5-mini-instruct",
      ],
      messages=[
          {"role": "system", "content": PROMPT},
          {"role": "system", "content": MESSAGE},
      ],
      params={
          "max_tokens": 500,
          "temperature": 1.0,
      }
  )

  ```


  OpenPO offers various ways to synthesize your dataset. To run evaluation, install extra dependencies by running

  ```bash
  pip install openpo[eval]
  ```


  To use single judge to evaluate your response data, use `eval_single`

  ```python
  client = OpenPO()

  res = openpo.eval_single(
      model='openai/gpt-4o',
      data=responses,
  )
  ```

  To use multi judge, use `eval_multi`

  ```python
  res = openpo.eval_multi(
      models=["openai/gpt-4o", "anthropic/claude-sonnet-3-5-latest"],
      data=responses,
  )
  ```


  You can use pre-trained open source evaluation models. OpenPo currently supports two types of models: `PairRM` and `Prometheus2`.

  > [!NOTE]
  > Appropriate hardware with GPU and memory is required to make inference with these models.

  To use PairRM to rank responses:

  ```python
  from openpo import PairRM

  pairrm = PairRM()
  res = pairrm.eval(prompts, responses)
  ```

  To use Prometheus2:

  ```python
  from openpo import Prometheus2
  from openpo.resources.provider.vllm import VLLM

  model = VLLM<(model="prometheus-eval/prometheus-7b-v2.0")
  pm = Prometheus2(model=model)

  feedback = pm.eval_relative(
      instructions=instructions,
      responses_A=response_A,
      responses_B=response_B,
      rubric='reasoning',
  )
  ```




  Use out of the box storage class to easily upload and download data.

  ```python
  from openpo.storage import HuggingFaceStorage
  hf_storage = HuggingFaceStorage(repo_id="my-dataset-repo")


  preference = {"prompt": "text", "preferred": "response1", "rejected": "response2"}
  hf_storage.push_to_repo(data=preference)


  data = hf_storage.load_from_repo()
  ```



  Contributions are what makes open source amazingly special! Here's how you can help:


  1. Clone the repository
  ```bash
  git clone https://github.com/yourusername/openpo.git
  cd openpo
  ```

  1. Install Poetry (dependency management tool)
  ```bash
  curl -sSL https://install.python-poetry.org | python3 -
  ```

  1. Install dependencies
  ```bash
  poetry install
  ```


  1. Create a new branch for your feature
  ```bash
  git checkout -b feature-name
  ```

  2. Submit a Pull Request
  - Write a clear description of your changes
  - Reference any related issues


pkgId: 6aa02e7ea16282165a18a2fe0a0c94e85a7d59e0b53c226737ef634dd6800857
name: python-openpo-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for openpo
url: https://github.com/dannylee1020/openpo
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openpo-0.6.1-1.src.rpm
location_href: Packages/python-openpo-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/openpo.svg)](https://pypi.org/project/openpo/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Documentation](https://img.shields.io/badge/docs-docs.openpo.dev-blue)](https://docs.openpo.dev)
  ![Python](https://img.shields.io/badge/python->=3.10.1-blue.svg)


  OpenPO simplifies building synthetic datasets for preference tuning from 200+ LLMs.

  | Resources | Notebooks |
  |----------|----------|
  | Building dataset with OpenPO and PairRM  |📔 [Notebook](https://colab.research.google.com/drive/1G1T-vOTXjIXuRX3h9OlqgnE04-6IpwIf?usp=sharing) |
  | Using OpenPO with Prometheus 2 | 📔 [Notebook](https://colab.research.google.com/drive/1dro0jX1MOfSg0srfjA_DZyeWIWKOuJn2?usp=sharing) |
  | Evaluating with LLM-as-a-Judge| 📔 [Notebook](https://colab.research.google.com/drive/1_QrmejW2Ym8yzP5RLJbLpVNA_FsEt2ZG?usp=sharing) |




  OpenPO is an open source library that simplifies the process of building synthetic datasets for LLM preference tuning. By collecting outputs from 200 + LLMs and synthesizing them using research-proven methodologies, OpenPO helps developers build better, more fine-tuned language models with minimal effort.



  - 🤖 **Multiple LLM Support**: Collect diverse set of outputs from 200+ LLMs

  - 📊 **Research-Backed Evaluation Methods**: Support for state-of-art evaluation methods for data synthesis

  - 💾 **Flexible Storage:** Out of the box storage providers for HuggingFace and S3.




  OpenPO uses pip for installation. Run the following command in the terminal to install OpenPO:

  ```bash
  pip install openpo
  ```


  Clone the repository first then run the follow command
  ```bash
  cd openpo
  poetry install
  ```


  set your environment variable first

  ```bash

  export HF_API_KEY=<your-api-key>
  export OPENROUTER_API_KEY=<your-api-key>


  export OPENAI_API_KEY=<your-openai-api-key>
  export ANTHROPIC_API_KEY=<your-anthropic-api-key>
  ```


  To get started with collecting LLM responses, simply pass in a list of model names of your choice

  > [!NOTE]
  > OpenPO requires provider name to be prepended to the model identifier.

  ```python
  import os
  from openpo import OpenPO

  client = OpenPO()

  response = client.completions(
      models = [
          "huggingface/Qwen/Qwen2.5-Coder-32B-Instruct",
          "huggingface/mistralai/Mistral-7B-Instruct-v0.3",
          "huggingface/microsoft/Phi-3.5-mini-instruct",
      ],
      messages=[
          {"role": "system", "content": PROMPT},
          {"role": "system", "content": MESSAGE},
      ],
  )
  ```

  You can also call models with OpenRouter.

  ```python

  client = OpenPO()

  response = client.completions(
      models = [
          "openrouter/qwen/qwen-2.5-coder-32b-instruct",
          "openrouter/mistralai/mistral-7b-instruct-v0.3",
          "openrouter/microsoft/phi-3.5-mini-128k-instruct",
      ],
      messages=[
          {"role": "system", "content": PROMPT},
          {"role": "system", "content": MESSAGE},
      ],

  )
  ```

  OpenPO takes default model parameters as a dictionary. Take a look at the documentation for more detail.

  ```python
  response = client.completions(
      models = [
          "huggingface/Qwen/Qwen2.5-Coder-32B-Instruct",
          "huggingface/mistralai/Mistral-7B-Instruct-v0.3",
          "huggingface/microsoft/Phi-3.5-mini-instruct",
      ],
      messages=[
          {"role": "system", "content": PROMPT},
          {"role": "system", "content": MESSAGE},
      ],
      params={
          "max_tokens": 500,
          "temperature": 1.0,
      }
  )

  ```


  OpenPO offers various ways to synthesize your dataset. To run evaluation, install extra dependencies by running

  ```bash
  pip install openpo[eval]
  ```


  To use single judge to evaluate your response data, use `eval_single`

  ```python
  client = OpenPO()

  res = openpo.eval_single(
      model='openai/gpt-4o',
      questions=questions,
      responses=responses,
  )
  ```

  To use multi judge, use `eval_multi`

  ```python
  res = openpo.eval_multi(
      models=["openai/gpt-4o", "anthropic/claude-sonnet-3-5-latest"],
      questions=questions,
      responses=responses,
  )
  ```


  You can use pre-trained open source evaluation models. OpenPo currently supports two types of models: `PairRM` and `Prometheus2`.

  > [!NOTE]
  > Appropriate hardware with GPU and memory is required to make inference with pre-trained models.

  To use PairRM to rank responses:

  ```python
  from openpo import PairRM

  pairrm = PairRM()
  res = pairrm.eval(prompts, responses)
  ```

  To use Prometheus2:

  ```python
  from openpo import Prometheus2
  from openpo.resources.provider import VLLM

  model = VLLM<(model="prometheus-eval/prometheus-7b-v2.0")
  pm = Prometheus2(model=model)

  feedback = pm.eval_relative(
      instructions=instructions,
      responses_A=response_A,
      responses_B=response_B,
      rubric='reasoning',
  )
  ```



  Use out of the box storage class to easily upload and download data.

  ```python
  from openpo.storage import HuggingFaceStorage
  hf_storage = HuggingFaceStorage()


  preference = {"prompt": "text", "preferred": "response1", "rejected": "response2"}
  hf_storage.push_to_repo(repo_id="my-hf-repo", data=preference)


  data = hf_storage.load_from_repo(path="my-hf-repo")
  ```



  Contributions are what makes open source amazingly special! Here's how you can help:


  1. Clone the repository
  ```bash
  git clone https://github.com/yourusername/openpo.git
  cd openpo
  ```

  1. Install Poetry (dependency management tool)
  ```bash
  curl -sSL https://install.python-poetry.org | python3 -
  ```

  1. Install dependencies
  ```bash
  poetry install
  ```


  1. Create a new branch for your feature
  ```bash
  git checkout -b feature-name
  ```

  2. Submit a Pull Request
  - Write a clear description of your changes
  - Reference any related issues


pkgId: b5666362d24ed134c530755a3e989b1ce6253d3c1d9d4dfad04b0bd36442068d
name: python-openrelik-api-client-help
arch: noarch
version: 2024.10.3
epoch: 0
release: 1
summary: Development documents and examples for openrelik-api-client
url: https://pypi.org/project/openrelik-api-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openrelik-api-client-2024.10.3-1.src.rpm
location_href: Packages/python-openrelik-api-client-help-2024.10.3-1.noarch.rpm
checksum_type: sha256
description:
  This Python package provides a simple API client (`APIClient`) that automatically handles token refresh on 401 (Unauthorized) responses.

  * **Automatic token refresh:** Seamlessly refreshes expired access tokens using a refresh token.
  * **Easy-to-use interface:** Simple methods for common HTTP requests (GET, POST, PUT, DELETE).
  * **Customizable:**  Allows you to specify the API server URL, API key, and API version.



     ```bash
     pip install openrelik-api-client
     ```

  **Example:**
      ```python
      import os
      from openrelik_api_client import APIClient

      
      api_server_url = "http://localhost:8710"

      
      api_key = os.getenv("OPENRELIK_API_KEY")

      
      api_client = APIClient(api_server_url, api_key)

      
      response = api_client.get("/users/me/")
      print(response.json())
      ```

  **How it works:**

  The `APIClient` utilizes a custom session class (`TokenRefreshSession`) that intercepts requests and checks for 401 responses. If a 401 response is encountered, it automatically attempts to refresh the access token using the provided refresh token. If the refresh is successful, the original request is retried with the new access token.


  This is not an official Google product (experimental or otherwise), it is just code that happens to be owned by Google.


pkgId: b6d0c41bc3c3bfb2079d220238f0058ea8745853b65a7d7e3bb4a4b3ced6c754
name: python-openshift-cli-installer-help
arch: noarch
version: 3.0.2
epoch: 0
release: 1
summary: Development documents and examples for openshift-cli-installer
url: https://github.com/RedHatQE/openshift-cli-installer
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openshift-cli-installer-3.0.2-1.src.rpm
location_href: Packages/python-openshift-cli-installer-help-3.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Basic Openshift install CLI wrapper.
  The tool allows deploying or deletion of one or more clusters.
  The clusters can be deployed on different platforms; currently supported platforms: AWS IPI, AWS OSD, GCP OSD, ROSA and Hypershift.
  Each cluster can be provided with different configuration options, such as worker type, number of workers etc.



  - AWS IPI installation uses openshift-installer cli which is extracted from the cluster's target version.
    The binary is taken from `quay.io/openshift-release-dev/ocp-release:<target version>`
  - ROSA and Hypershift installation uses the latest ROSA CLI



  Image locate at [openshift-cli-installer](https://quay.io/repository/redhat_msi/openshift-cli-installer)
  To pull the image: `podman pull quay.io/redhat_msi/openshift-cli-installer`





  ```bash
  poetry install
  poetry run python openshift_cli_installer/cli.py --help
  ```



  ```bash
  pipx install .
  ```

  For shell complition Add this to ~/.bashrc or ~/.zshrc:

  ```bash
  eval "$(_OPENSHIFT_CLI_INSTALLER_COMPLETE=zsh_source openshift-cli-installer)"
  ```



  User can create/destroy clusters by sending YAML file instead with CLI args
  Example YAML file can be found [here](openshift_cli_installer/manifests/clusters.example.yaml)
  pass `--clusters-yaml-config-file=.local/clusters-example.yaml` to use YAML file.
  Action also can be passed to the CLI as `--action create/destroy` instead of specifying the action in the YAML file.
  `--action create --clusters-yaml-config-file=.local/clusters-example.yaml`



  - `--clusters-install-data-directory`: Clusters configurations are written to `<clusters-install-data-directory><platform><cluster name>`; write permissions are needed.
    - `<cluster directory>/auth` contains `kubeconfig` and `kubeadmin-password` files
    - Hypershift cluster:
      - `<cluster directory>/auth/api.login` contains the full login command to the cluster.
      - `<cluster directory>/auth/rosa-admin-password` contains the password for the `rosa-admin` user.
  - `--parallel`: To create / destroy clusters in parallel
  - Pass `--s3-bucket-name` (and optionally `--s3-bucket-path` and `--s3-bucket-object-name`) to back up <cluster directory> in an S3 bucket.
  - `--ocm-token`: OCM token, defaults to `OCM_TOKEN` environment variable.
  - `--must-gather-output-dir`: Path to must-gather output dir. `must-gather` will try to collect data when cluster installation fails and cluster can be accessed.

  - AWS IPI clusters:

    - The installer output is saved in the `<cluster directory>`.
    - The data is used for cluster destroy.
    - `platform=aws`: Must pass in cluster parameters
    - `base-domain`: cluster parameter is mandatory
    - `auto-region=True`: Optional cluster parameter for assigning `region` param to a region which have the least number of VPCs.
    - `log_level`: Log level, defaults to `error` for cluster config to hide the openshift-installer logs which contains kubeadmin password.
    - `--registry-config-file`: registry-config json file path, can be obtained from [openshift local cluster](https://console.redhat.com/openshift/create/local)
    - `--docker-config-file`: Path to Docker config.json file, defaults to `~/.docker/config.json`. File must include token for `registry.ci.openshift.org`
    - `--ssh-key-file`: id_rsa file path, defaults to `/openshift-cli-installer/ssh-key/id_rsa.pub`

  - GCP IPI clusters:

    - The installer output is saved in the `<cluster directory>`.
    - The data is used for cluster destroy.
    - `platform=gcp`: Must pass in cluster parameters
    - `base-domain`: cluster parameter is mandatory
    - `--gcp-service-account-file`: Path to GCP service account json. The file will be copied to specific path `~/.gcp/osServiceAccount.json` for installer .
      Follow [these](#steps-to-create-gcp-service-account-file) steps to get the ServiceAccount file.
    - `--registry-config-file`: registry-config json file path, can be obtained from [openshift local cluster](https://console.redhat.com/openshift/create/local)
    - `--docker-config-file`: Path to Docker config.json file, defaults to `~/.docker/config.json`. File must include token for `registry.ci.openshift.org`
    - `--ssh-key-file`: id_rsa file path, defaults to `/openshift-cli-installer/ssh-key/id_rsa.pub`

  - ROSA / Hypershift clusters:

    - `platform=rosa`: Must pass in cluster parameters
    - `--aws-account-id`: AWS account ID for Hypershift clusters

  - AWS OSD clusters:

    - `platform=aws-osd`: Must pass in cluster parameters
    - `auto-region=True`: Optional cluster parameter for assigning `region` param to a region which have the least number of VPCs.
    - `--aws-access-key-id`: AWS access key ID
    - `--aws-secret-access-key`: AWS secret access key
    - `--aws-account-id`: AWS account ID

  - GCP OSD clusters:
    - `platform=gcp-osd`: Must pass in cluster parameters
    - `--gcp-service-account-file`: Path to GCP service account json.
      Follow [these](#steps-to-create-gcp-service-account-file) steps to get the ServiceAccount file.



  Every call to the openshift installer cli must have at least one `--cluster` option.

  - Mandatory parameters:
    - name or name-prefix: The name of the cluster or the prefix of the name of the cluster, if prefix is used we generate a unique name up to 15 characters.
    - platform: The platform to deploy the cluster on (supported platforms are: aws, rosa and hypershift)
    - region: The region to deploy the cluster. Optional for AWS-IPI and AWS-OSD clusters, but mandatory for other (GCP, ROSA, Hypershift) clusters.
  - Optional parameters:
    - Parameter names should be separated by semicolons (`;`)
    - To set cluster create / destroy timeout (not applicable for AWS IPI clusters), pass `--cluster ...timeout=1h'`; default is 60 minutes.
    - `timeout` and `expiration-time` format examples: `1h`, `30m`, `3600s`
    - `ocm-env`: OCM environment to deploy the cluster; available options: `stage` or `production` (defaults to `stage`). AWS-IPI clusters only use `production`.
    - AWS/GCP IPI:
      - To overwrite cluster config, check below manifests for parameters
        - [aws-install-config-template.j2](openshift_cli_installer/manifests/aws-install-config-template.j2)
        - [gcp-install-config-template.j2](openshift_cli_installer/manifests/gcp-install-config-template.j2)
      - Every parameter (marked with double curly brackets in the template) can be overwritten.
      - For example: to overwrite `{{ fips|default("false", true) }}` pass `--cluster '...fips=true'`
    - ROSA / Hypershift:
      - Every supported ROSA CLI create/delete parameter can be passed. Check `rosa create --help` for more details.
      - For example:
        - Pass `--cluster ...fips=true'` to enable FIPS
        - Pass `--cluster ...expiration-time=2h'` to have the cluster expiration time set to 2 hours
    - Hypershift:
      - Cluster VPC CIDR, public and private subnets can be configured from the CLI. Otherwise, values in [setup-vpc.tf](openshift_cli_installer/manifests/setup-vpc.tf) will be used.
        - To set `cidr`, pass `--cluster ...cidr=1.1.0.0/16'`
        - To set `private-subnets`, pass `--cluster ...private-subnets=10.1.1.0/24,10.1.2.0/24'`
        - To set `public-subnets`, pass `--cluster ...public-subnets=10.1.10.0/24,10.1.20.0/24'`



  To create the file, create a service account and download it:

  1.  Go to https://console.cloud.google.com/iam-admin/serviceaccounts?project=<project>
  2.  Select the service account -> "Create Key"
  3.  Select the Key Type as `JSON` and click Create



  Managed clusters (Rosa, AWS and OSD) can be deployed with ACM and attached to ACM hub.
  To deploy ACM on cluster pass `--cluster ... acm=True`
  To enable observability on the ACM enabled cluster pass `--cluster ... acm-observability=True`
  Attach clusters to ACM cluster hub:

  - Support only clusters that created during the run
  - To attach cluster to this ACM hub pass `--cluster ... acm-clusters=mycluser1,mycluster2`
    - `mycluser1,mycluster2` needs to be sent with `--cluster ...` for the script to create them.



  `--destroy-clusters-from-install-data-directory`, `--destroy-clusters-from-s3-bucket` and `--destroy-clusters-from-install-data-directory-using-s3-bucket` must have:

  ```bash
    --ocm-token=$OCM_TOKEN \
    --registry-config-file=${HOME}/docker-secrets.json \
    --aws-access-key-id=${AWS_ACCESS_KEY_ID} \
    --aws-secret-access-key=${AWS_SECRET_ACCESS_KEY}
  ```



  To destroy all clusters locate in `--clusters-install-data-directory` run:

  ```bash
  podman run quay.io/redhat_msi/openshift-cli-installer \
    --destroy-clusters-from-install-data-directory \
    --clusters-install-data-directory=/openshift-cli-installer/clusters-install-data
  ```



  ```bash
  podman run quay.io/redhat_msi/openshift-cli-installer \
    --destroy-clusters-from-install-data-directory-using-s3-bucket \
    --clusters-install-data-directory=/openshift-cli-installer/clusters-install-data
  ```



  To destroy all clusters from uploaded zip files in S3 bucket run:

  ```bash
  podman run quay.io/redhat_msi/openshift-cli-installer \
    --destroy-clusters-from-s3-bucket \
    --s3-bucket-name="openshift-cli-installer" \
    --s3-bucket-path="openshift-ci"
  ```

  To filter cluster pass `--destroy-clusters-from-s3-bucket-query` query:

  ```bash
  podman run quay.io/redhat_msi/openshift-cli-installer--destroy-clusters-from-s3-bucket \
    --s3-bucket-name=openshift-cli-installer \
    --s3-bucket-path=install-folders \
    --destroy-clusters-from-s3-bucket-query="mycluster"
  ```



  ```
  podman run quay.io/redhat_msi/openshift-cli-installer --help
  ```



  Clone the [repository](https://github.com/RedHatQE/openshift-cli-installer)

  ```
  git clone https://github.com/RedHatQE/openshift-cli-installer.git
  ```

  Install [poetry](https://github.com/python-poetry/poetry)

  Install [regctl](https://github.com/regclient/regclient)

  Install Terraform [how-to](https://computingforgeeks.com/how-to-install-terraform-on-fedora/)

  ```bash
  sudo dnf config-manager --add-repo https://rpm.releases.hashicorp.com/fedora/hashicorp.repo
  sudo dnf install terraform
  ```

  Use `poetry run python openshift_cli_installer/cli.py` to execute the cli.

  ```
  poetry install
  poetry run python openshift_cli_installer/cli.py --help
  ```



  Each command can be run via container `podman run quay.io/redhat_msi/openshift-cli-installer` or via poetry command `poetry run python openshift_cli_installer/cli.py`
  When using the container pass:
  `-e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID`
  `-e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY`
  `-v registry-config.json:/registry-config.json`
  `-v ./clusters-install-data:/openshift-cli-installer/clusters-install-data`







  - Supported `streams` are: `stable`, `nightly`, `rc`, `ci` and `ec`, Supported architecture(s): `X86_64`
  - If passed exact version this version will be used (if exists), Example: 3.14.9
  - If passed partial version, latest version will be used, Example: 4.13 install 4.13.9 (latest)
  - If passed `stream=nightly` and version 4.13, latest 4.13 nightly will be used.
    - stream should be passed as part on `--cluster`, `--cluster ...... stream=stable`

  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action create \
      --registry-config-file=registry-config.json \
      --s3-bucket-name=openshift-cli-installer \
      --s3-bucket-path=install-folders \
      --s3-bucket-object-name=cluster-backup \
      --cluster 'name=ipi1;base-domain=gcp.interop.ccitredhat.com;platform=gcp;region=us-east1;version=4.14.0-ec.2;worker-flavor=custom-4-16384;log_level=info'
  ```

  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action create \
      --registry-config-file=registry-config.json \
      --s3-bucket-name=openshift-cli-installer \
      --s3-bucket-path=install-folders \
      --cluster 'name=ipi2;base-domain=aws.interop.ccitredhat.com;platform=aws;auto-region=True;version=4.14.0-ec.2;worker-flavor= m5.4xlarge'
  ```





  [Same for Hypershift clusters]

  - Supported `channel-group` are: `stable`, `candidate`, and `nightly`.
  - If passed exact version this version will be used (if exists), Example: 3.14.9
  - If passed partial version, latest version will be used, Example: 4.13 install 4.13.9 (latest)
  - If passed `channel-group=nightly` and version 4.13, latest 4.13 nightly will be used.
    - stream should be passed as part on `--cluster`, `--cluster ...... channel-group=stable`

  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action create \
      --ocm-token=$OCM_TOKEN \
      --cluster 'name=rosa1;platform=rosa;region=us-east-2;version=4.13.4;compute-machine-type=m5.xlarge;replicas=2;channel-group=candidate;expiration-time=4h;timeout=1h;ocm-env=production
  ```



  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action create \
      --ocm-token=$OCM_TOKEN \
      --cluster 'name=hyper;platform=hypershift;region=us-west-2;version=4.13.4;compute-machine-type=m5.4xlarge;replicas=6;channel-group=candidate;expiration-time=4h;timeout=1h'
  ```



  To run multiple clusters deployments in parallel pass -p,--parallel.

  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action create \
      --registry-config-file=registry-config.json \
      --s3-bucket-name=openshift-cli-installer \
      --s3-bucket-path=install-folders \
      --cluster 'name=hyper1;platform=hypershift;region=us-west-2;version=4.13.4;compute-machine-type=m5.4xlarge;replicas=6;channel-group=candidate;expiration-time=2h;timeout=1h' \
      --ocm-token=$OCM_TOKEN \

      --cluster 'name=ipi1;base-domain=aws.interop.ccitredhat.com;platform=aws;region=us-east-2;version=4.14.0-ec.2;worker-flavor=m5.xlarge' \
      --cluster 'name=rosa1;platform=rosa;region=us-east-2;version=4.13.4;compute-machine-type=m5.xlarge;replicas=2;channel-group=candidate;expiration-time=4h;timeout=1h' \
      --parallel
  ```







  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action destroy \
      --ocm-token=$OCM_TOKEN \
      --cluster 'name=ipi1;region=us-east-2;version=4.14.0-ec.2;timeout=1h'
  ```



  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action destroy \
      --ocm-token=$OCM_TOKEN \
      --cluster 'name=rosa1;platform=rosa;region=us-east-2;version=4.13.4;timeout=1h;ocm-env=production'
  ```



  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action destroy \
      --ocm-token=$OCM_TOKEN \
      --cluster 'name=hyper1;platform=hypershift;region=us-east-2;version=4.13.4;timeout=1h'
  ```



  To run multiple clusters deletion in parallel pass -p,--parallel.

  ```
  podman run quay.io/redhat_msi/openshift-cli-installer \
      --action destroy \
      --ocm-token=$OCM_TOKEN \
      --cluster 'name=rosa1;platform=rosa;region=us-east-2;version=4.13.4;timeout=1h' \
      --cluster 'name=hyper1;platform=rosa;region=us-east-2;version=4.13.4;timeout=1h' \
      --cluster 'name=ipi1;region=us-east-2;version=4.14.0-ec.2;timeout=1h'
  ```


pkgId: 1dbb7f91c2013dd19c970f8073a4501094b0515cbe90693b17a6b97029dc8c32
name: python-openshift-cluster-management-python-wrapper-help
arch: noarch
version: 2.0.3
epoch: 0
release: 1
summary: Development documents and examples for openshift-cluster-management-python-wrapper
url: https://github.com/RedHatQE/openshift-cluster-management-python-wrapper
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openshift-cluster-management-python-wrapper-2.0.3-1.src.rpm
location_href: Packages/python-openshift-cluster-management-python-wrapper-help-2.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Wrapper for [openshift-cluster-management-python client](https://github.com/RedHatQE/openshift-cluster-management-python-client)



  * Export GitHub token
  ```bash
  export GITHUB_TOKEN=<your_github_token>
  ```
  * [release-it](https://github.com/release-it/release-it)

  Run the following once (execute outside repository dir, for example `~/`):
  ```bash
  sudo npm install --global release-it
  npm install --save-dev @release-it/bumper
  ```

  * Create a release, run from the relevant branch.
  To create a 1.0 release, run:
  ```bash
  git checkout v1.0
  git pull
  release-it # Follow the instructions
  ```


  From source:
  ```bash
  git clone https://github.com/RedHatQE/openshift-cluster-management-python-client.git
  cd openshift-cluster-management-python-client
  python setup.py install --user
  ```



  ```python
  from ocm_python_wrapper.ocm_client import OCMPythonClient
  ocm_client = OCMPythonClient(
      token=<ocm api token>>,
      endpoint=<endpoint url>,
      api_host=<production or stage>,
      discard_unknown_keys=True,
  )
  return ocm_client.client
  ```

  ```python
  from ocm_python_wrapper.cluster import Cluster
  cluster = Cluster(client=client, name=<cluster name>)
  cluster_ocp_version = cluster.instance.version.raw_id
  ```


pkgId: 2280d259d8c004ab90b67968df714719766085cd6ea23e14c43d77787918334b
name: python-openshift-python-utilities-help
arch: noarch
version: 6.0.2
epoch: 0
release: 1
summary: Development documents and examples for openshift-python-utilities
url: https://github.com/RedHatQE/openshift-python-utilities
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openshift-python-utilities-6.0.2-1.src.rpm
location_href: Packages/python-openshift-python-utilities-help-6.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Pypi: [openshift-python-utilities](https://pypi.org/project/openshift-python-utilities/)
  A utilities repository for [openshift-restclient-python](https://github.com/openshift/openshift-restclient-python)





  * Export GitHub token

  ```bash
  export GITHUB_TOKEN=<your_github_token>
  ```

  * [release-it](https://github.com/release-it/release-it)

  Run the following once (execute outside repository dir for example `~/`):

  ```bash
  sudo npm install --global release-it
  npm install --save-dev @release-it/bumper
  ```


  * Create a release, run from the relevant branch.
  To create a 4.11 release, run:

  ```bash
  git checkout v4.11
  git pull
  release-it # Follow the instructions
  ```



  From source using [poetry](https://github.com/python-poetry/poetry).

  ```
  git clone https://github.com/RedHatQE/openshift-python-utilities.git
  cd openshift-python-utilities
  poetry install
  ```





  ```python
  from ocp_utilities.infra import get_client
  client = get_client(config_file=<path to kubeconfig>))
  ```



  ```python
  from ocp_utilities.operators import install_operator
  install_operator(
      admin_client=client,
      name=<operator name>,
      channel=<channel>,
      source=<source>,
  )
  ```


pkgId: 183977497b76c69797405bfb7bc77d97c31068eded0a4c656152d41a28ef448e
name: python-openshift-python-wrapper-data-collector-help
arch: noarch
version: 2.0.3
epoch: 0
release: 1
summary: Development documents and examples for openshift-python-wrapper-data-collector
url: https://github.com/RedHatQE/openshift-python-wrapper-data-collector
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openshift-python-wrapper-data-collector-2.0.3-1.src.rpm
location_href: Packages/python-openshift-python-wrapper-data-collector-help-2.0.3-1.noarch.rpm
checksum_type: sha256
description:
  To enable data-collector pass data-collector.yaml
  YAML format:
  ```yaml
      data_collector_base_directory: "<base directory for data collection>"
      collect_data_function: "<import path for data collection method>"
      collect_pod_logs: true|false # bool whether to collect logs if resource is a pod
  ```
  YAML Example `ocp_utilities/data-collector.yaml`:
  ```yaml
      data_collector_base_directory: "collected-info"
      collect_data_function: "data_collector.collect_data"
      collect_pod_logs: true
  ```
  Either export path to yaml file in `OPENSHIFT_PYTHON_WRAPPER_DATA_COLLECTOR_YAML` or set `data_collector` in your py_config
  The environment variable takes precedence over py_config.

  To use dynamic base directory, export `OPENSHIFT_PYTHON_WRAPPER_DATA_COLLECTOR_DYNAMIC_BASE_DIR`
  Example:
  ```
  data_collector_base_directory = "/data/results/collected-info"
  OPENSHIFT_PYTHON_WRAPPER_DATA_COLLECTOR_DYNAMIC_BASE_DIR = "dynamic_collector_test_dir"

  Result: /data/results/dynamic_collector_test_dir/collected-info
  ```


pkgId: 056dcef4af0698b01082d15cd35739413b035bb6dac7b23b372df5de2f4acb89
name: python-openshift-python-wrapper-help
arch: noarch
version: 11.0.12
epoch: 0
release: 1
summary: Development documents and examples for openshift-python-wrapper
url: https://pypi.org/project/openshift-python-wrapper/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openshift-python-wrapper-11.0.12-1.src.rpm
location_href: Packages/python-openshift-python-wrapper-help-11.0.12-1.noarch.rpm
checksum_type: sha256
description:
  Pypi: [openshift-python-wrapper](https://pypi.org/project/openshift-python-wrapper)
  A python wrapper for [kubernetes-python-client](https://github.com/kubernetes-client/python) with support for [RedHat Container Virtualization](https://www.openshift.com/learn/topics/virtualization)
  Docs: [openshift-python-wrapper docs](https://openshift-python-wrapper.readthedocs.io/en/latest/)

  The wrapper offers a simple and intuitive interface for interacting with the API.
  It standardizes how to work with cluster resources and offers unified resource CRUD (Create, Read, Update, and Delete) flows.
  The wrapper also provides additional capabilities, such as resource-specific functionality that otherwise needs to be implemented by users.
  The wrapper makes code easier to read and maintain over time.

  One example of simplified usage is interacting with a container.
  Running a command inside a container requires using Kubernetes stream, handling errors, and more.
  The wrapper handles it all and provides simple and intuitive functionality.

  ![Alt Text](examples/pod_example.gif)

  Both developers or testers can use the wrapper.  The code is modular and easy to maintain.
  Instead of writing custom code for every API, you can use the wrapper that provides a consistent interface for interacting with APIs.
  It saves time, avoids code duplications, and reduces the chance of errors.

  Using Python capabilities, context managers can provide out-of-the-box resource creation and deletion,
  and inheritance can be used to extend functionality for specific use cases.
  Pytest fixtures can utilize the code for setup and teardown, leaving no leftovers.
  Resources can even be saved for debugging.
  Resource manifests and logs can be easily collected.


  From source:
  ```bash
  git clone https://github.com/RedHatQE/openshift-python-wrapper.git
  cd openshift-python-wrapper
  python setup.py install --user
  ```
  From pypi:
  ```bash
  pip install openshift-python-wrapper --user
  ```



  * Export GitHub token
  ```bash
  export GITHUB_TOKEN=<your_github_token>
  ```
  * [release-it](https://github.com/release-it/release-it)
  ```bash
  sudo npm install --global release-it
  npm install --save-dev @release-it/bumper
  ```

  * Create a release, run from the relevant branch.
  To create a 4.11 release, run:
  ```bash
  git checkout v4.11
  git pull
  release-it # Follow the instructions
  ```


  Hosted on readthedocs.io [openshift-python-wrapper](https://openshift-python-wrapper.readthedocs.io/en/latest/)


  For PR dependency we use [dpulls](https://www.dpulls.com/)
  To make PR depends on other PR add `depends on #<PR NUMBER>` in the PR description.


  To change log level export OPENSHIFT_PYTHON_WRAPPER_LOG_LEVEL:

  ```bash
  export OPENSHIFT_PYTHON_WRAPPER_LOG_LEVEL=<LOG_LEVEL> # can be: "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
  ```


  We use pre-commit for code check.
  ```bash
  pre-commit install
  ```

  Some code examples locate at [examples](examples) directory


  To contribute new additions or changes to the project, please refer to the [contribution guide](CONTRIBUTING.md) first.


pkgId: b57f25ee4c38a03759f54eb146a3f538e06b6d047f20d2588b5efe7c1dc5914a
name: python-openspoor-help
arch: noarch
version: 0.2.9
epoch: 0
release: 1
summary: Development documents and examples for openspoor
url: https://pypi.org/project/openspoor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openspoor-0.2.9-1.src.rpm
location_href: Packages/python-openspoor-help-0.2.9-1.noarch.rpm
checksum_type: sha256
description:
  ![alt text](https://www.radingspoor.nl/images/Stoom/Modellen_van_Leden/7_Inch_modellen/Zandloc_Janny/51133945_533417650499237_1555124498724814848_n.jpg)

  The openspoor package is intended to allow easy transformation between different geographical and topological systems
  commonly used in Dutch Railway and prepare this data for analysis and visualisations. Its goal is to be publicly available and function as an open source package.

  Currently the openspoor package allows the following transformations:

  **Type of input:**
  - Point data

  These transformations can be performed between the following systems:

  **Geographical systems:**
  - WGS84 coordinate system (commonly known as GPS coordinates)
  - EPSG:28992 coordinate system (commonly known in the Netherlands as Rijksdriehoek)

  **Topological systems:**
  - Geocode and geocode kilometrering
  - Spoortak and spoortak kilometrering (unavailable on switches)
  - Spoortakken of different historical versions






  Openspoor is dependent on Fiona and GDAL, which are missing Windows dependencies on PyPi.

  Use conda to install Fiona and GDAL:

  - `conda install -c conda-forge Fiona GDAL`

  - `pip install openspoor`



  - `pip install openspoor`



  - `conda create -n [env_name] python=3.11`
  - `conda install -c conda-forge proj=7.0.0`
  - `conda install -c conda-forge pyproj=2.6.0`
  - `pip install openspoor`

  The steps above involving conda(-forge) are necessary for Mac M1 chips (used since Nov 2020). In case your Mac does not
  have a M1 chip, then `pip install openspoor` should suffice.





  Installation using anaconda
  - Clone the "openspoor" repository
    - `git clone https://github.com/ProRail-DataLab/openspoor.git`
  - create an environment:
    - `conda create -n openspoorenv python==3.11`
  - activate the environment:
    - `conda activate openspoorenv`
  - install dependencies:
    - `pip install -r requirements.txt`
  - In the root directory of the repository, execute the command:
    - `pip install -e .[dev]`
  - In the root directory of the repository, execute the command:
    - `pytest --nbmake --nbmake-kernel=python3`
  - If all the test succeed, the openspoor package is ready to use and you are on the right "track"!



  Installation using anaconda

  - Clone the "openspoor" repository
    - `git clone https://github.com/ProRail-DataLab/openspoor.git`
  - create an environment in your preferred way in Python 3.8 and activate. For example:
    - `python3 -m venv venv`
    - `source ./venv/bin/activate`
  - activate the environment:
    - `conda activate openspoorenv`
  - update pip:
    - `pip install --upgrade pip`
  - install dependencies:
    - `pip install -r requirements.txt`
  - In the root directory of the repository, execute the command:
    - `pip install -e .[dev]`
  - In the root directory of the repository, execute the command:
    - `pytest --nbmake --nbmake-kernel=python3`
  - If all the test succeed, the openspoor package is ready to use and you are on the right "track"!



  In the demo_notebook folder a notebook can be found that demonstrates the example usage of the openspoor package.



  The transformations available in the openspoor package rely completely on data and API's made available at
  https://mapservices.prorail.nl/. Be aware of this dependency and specifically of the following possible issues:

  - The use of API's on mapservices.prorail.nl is changed
  - The output data of the mapservices API's is changed (with added, removed or missing columns for instance)




  The openspoor package is split into 4 categories.



  The MapservicesData classes use mapservices.prorail.nl API's to retrieve the necessary data to perform transformations.
  The essentially function as an interface with the topological systems used by ProRail.

  - PUICMapservices provides general data about railway tracks (spoor) and switches (wissel and kruisingbenen). This
  contains information regarding Geocode, geocodekilometrering, but also Spoortak identificatie.
  - SpoortakMapservices provides information about railway tracks concerning Spoortak identificatie and lokale
  kilometrering.



  The various transformers use the geopandas dataframes obtained by MapservicesData objects to add additional geographical
  or topological systems to a given geopandas input dataframe. The current transformers only function for geopandas
  dataframes containing Point data. The available transformers are:

  - TransformerCoordinatesToSpoor: transforms WGS84 or EPSG:28992 coordinates to spoortak and lokale kilomtrering as well
  as geocode and geocode kilometrering.
  - TransformerGeocodeToCoordinates: transforms geocode and geocode kilometrering to WGS84 or EPSG:28992 coordinates.
  - TransformerSpoorToCoordinates: transforms spoortak and lokale kilometrering to WGS84 or EPSG:28992 coordinates.



  mapservices.prorail.nl only provides current information about the topological systems used in Dutch
  Railways. As the topological systems tend to change with time, due to changing infrastructure and naming conventions,
  the current topological system is not necessarily sufficient to provide transformations on historical data. We added
  historical topological systems as part of the functionality of this package in such a way that it
  is available publicly. This enables users to also knwow where assets where in previous versions of the
  track topology.



  This part contains functionalities to plot locations on a map of the Netherlands.This currently supports pandas or geopandas dataframes with locations of either points or linestrings.



  - <b>0.1.9</b>
    - Added spoortakmodel and visualisations
    - Updated readme

  - <b>0.1</b>
    - The first proper release
    - ADD: transform point data between geographical systems.
  - <b>0.0.1</b>
    - Work in progress


  The openspoor package stimulates every other person the contribute to the package. To do so:

  - Fork it
  - Create your feature branch (git checkout -b feature/fooBar)
  - Commit your changes (git commit -am 'Add some fooBar')
  - Push to the branch (git push origin feature/fooBar)
  - Create a new Pull Request with 3 obligated reviewers from the developement team.

  You could also contribute by working on one of the open Issues as noted on the GitHub page.


pkgId: 9bc0b43699188e13178a28f89823bf95553f1ca40aea0e2cc083cebf2b636a4d
name: python-openstack-flavor-manager-help
arch: noarch
version: 0.20241213.0
epoch: 0
release: 1
summary: Development documents and examples for openstack-flavor-manager
url: https://github.com/osism/openstack-flavor-manager
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openstack-flavor-manager-0.20241213.0-1.src.rpm
location_href: Packages/python-openstack-flavor-manager-help-0.20241213.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi version](https://badgen.net/pypi/v/openstack-flavor-manager/)](https://pypi.org/project/openstack-flavor-manager/)
  [![PyPi license](https://badgen.net/pypi/license/openstack-flavor-manager/)](https://pypi.org/project/openstack-flavor-manager/)
  [![Documentation](https://img.shields.io/static/v1?label=&message=documentation&color=blue)](https://osism.tech/docs/guides/operations-guide/openstack/tools/flavor-manager)

  Easily create OpenStack flavors based on standardised YAML files

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


pkgId: 17629646215b731204a9126a2d4aa432eaeff67d812d085d3bb629fe8ae28f0e
name: python-openstack-image-manager-help
arch: noarch
version: 0.20241213.0
epoch: 0
release: 1
summary: Development documents and examples for openstack-image-manager
url: https://github.com/osism/openstack-image-manager
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openstack-image-manager-0.20241213.0-1.src.rpm
location_href: Packages/python-openstack-image-manager-help-0.20241213.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi version](https://badgen.net/pypi/v/openstack-image-manager/)](https://pypi.org/project/openstack-image-manager/)
  [![PyPi license](https://badgen.net/pypi/license/openstack-image-manager/)](https://pypi.org/project/openstack-image-manager/)
  [![Documentation](https://img.shields.io/static/v1?label=&message=documentation&color=blue)](https://osism.tech/docs/guides/operations-guide/openstack/tools/image-manager/)

  Easily manage and keep up to date a large number of images on an OpenStack environment

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


pkgId: 4ef028a8cd709791be647690f12a0a045a0904b8741540ec80c65edbe831aabf
name: python-openstarlab-preprocessing-help
arch: noarch
version: 0.1.22
epoch: 0
release: 1
summary: Development documents and examples for openstarlab-preprocessing
url: https://github.com/open-starlab/PreProcessing
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openstarlab-preprocessing-0.1.22-1.src.rpm
location_href: Packages/python-openstarlab-preprocessing-help-0.1.22-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/openstarlab/badge/?version=latest)](https://openstarlab.readthedocs.io/en/latest/?badge=latest)
  [![dm](https://img.shields.io/pypi/dm/openstarlab-preprocessing)](https://pypi.org/project/openstarlab-preprocessing/)


  The OpenSTARLab PreProcessing package is a core component for the OpenSTARLab suite, providing essential data preprocessing functions. It is designed with minimal dependencies and aims to avoid those that are heavily version-dependent.

  This package is continuously evolving to support future OpenSTARLab projects. If you have any suggestions or encounter any bugs, please feel free to open an issue.


  - To install this package via PyPI
  ```
  pip install openstarlab-preprocessing
  ```
  - To install manually
  ```
  git clone git@github.com:open-starlab/PreProcessing.git
  cd ./PreProcessing
  pip install -e .
  ```



  - [Event data in Football/Soccer ⚽](https://github.com/open-starlab/PreProcessing/blob/master/preprocessing/sports/event_data/soccer/README.md)


  - [x] Release the package
  - [ ] Incorporate more functions



  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  <!-- [![All Contributors](https://img.shields.io/badge/all_contributors-2-orange.svg?style=flat-square)](#contributors-) -->
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/calvinyeungck"><img src="https://github.com/calvinyeungck.png" width="100px;" alt="Calvin Yeung"/><br /><sub><b>Calvin Yeung</b></sub></a><br /><a href="#Developer-CalvinYeung" title="Lead Developer">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kenjiro-mk"><img src="https://github.com/kenjiro-mk.png" width="100px;" alt="Kenjiro Ide"/><br /><sub><b>Kenjiro Ide</b></sub></a><br /><a href="#Developer-KenjiroIde" title="Developer">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/czzzzz129"><img src="https://github.com/czzzzz129.png" width="100px;" alt="Zheng Chen"/><br /><sub><b>Zheng Chen</b></sub></a><br /><a href="#Developer-ZhengChen" title="Developer">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/keisuke198619"><img src="https://github.com/keisuke198619.png" width="100px;" alt="Keisuke Fujii"/><br /><sub><b>Keisuke Fujii</b></sub></a><br /><a href="#lead-KeisukeFujii" title="Team Leader">🧑‍💻</a></td>
      </tr>
    </tbody>
  </table>


pkgId: e34c29a8e652d2292dd031a88713f6aa8a10bb3513699781107eb505b9f7de70
name: python-opentaskpy-help
arch: noarch
version: 24.51.0
epoch: 0
release: 1
summary: Development documents and examples for opentaskpy
url: https://github.com/adammcdonagh/open-task-framework
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opentaskpy-24.51.0-1.src.rpm
location_href: Packages/python-opentaskpy-help-24.51.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/opentaskpy.svg)](https://pypi.org/project/opentaskpy/)
  ![unittest status](https://github.com/adammcdonagh/open-task-framework/actions/workflows/test.yml/badge.svg)
  [![Coverage](https://img.shields.io/codecov/c/github/adammcdonagh/open-task-framework.svg)](https://codecov.io/gh/adammcdonagh/open-task-framework)
  [![License](https://img.shields.io/github/license/adammcdonagh/open-task-framework.svg)](https://github.com/adammcdonagh/open-task-framework/blob/master/LICENSE)
  [![Issues](https://img.shields.io/github/issues/adammcdonagh/open-task-framework.svg)](https://github.com/adammcdonagh/open-task-framework/issues)
  [![Stars](https://img.shields.io/github/stars/adammcdonagh/open-task-framework.svg)](https://github.com/adammcdonagh/open-task-framework/stargazers)

  <h1>Open Task Framework (opentaskpy)</h1>

  - [Installation](#installation)
    - [Example Deployment](#example-deployment)
  - [Configuration](#configuration)
    - [Command Line Arguments](#command-line-arguments)
    - [otf-batch-validator](#otf-batch-validator)
    - [Environment Variables](#environment-variables)
    - [Logging](#logging)
    - [Variables](#variables)
      - [Lazy Loading Variables](#lazy-loading-variables)
    - [Runtime Overrides](#runtime-overrides)
    - [Lookup plugins](#lookup-plugins)
      - [Adding your own](#adding-your-own)
      - [Advanced Variables](#advanced-variables)
      - [Example Variables](#example-variables)
  - [Task Definitions](#task-definitions)
    - [Transfers](#transfers)
    - [Executions](#executions)
    - [Batches](#batches)
  - [Development](#development)
    - [Quickstart for development](#quickstart-for-development)
      - [Building and uploading to PyPi](#building-and-uploading-to-pypi)
    - [Official Addons/Plugins](#official-addonsplugins)
      - [otf-addons-aws](#otf-addons-aws)
      - [otf-addons-vault](#otf-addons-vault)
      - [otf-addons-o365](#otf-addons-o365)
    - [Developing your own addon/plugin](#developing-your-own-addonplugin)
      - [Lookup Plugins](#lookup-plugins-1)
      - [Addons](#addons)

  Open Task Framework (OTF) is a Python based framework to make it easy to run predefined file transfers and scripts/commands on remote machines.

  Currently the framework is primarily based around being able to use SSH or SFTP to communicate with remote hosts in order to manipulate files and run commands. This is done via the use of SSH keys, which must be set up in advance.

  OTF has 3 main concepts for tasks. These are:

  - Transfers
  - Executions
  - Batches

  For more details, see the [task types](docs/task-types.md) doc



  OTF can be run either as an installed script, or via a docker container

  Install via pip:

  ```shell
  pip install opentaskpy
  ```

  The `task-run` script will be added to your PATH, and you can invoke it directly.

  To run via docker, use the `Dockerfile` to create your own base image using just the standard opentaskpy library. However if you want to install addons, you'll need to customise this, to install the additional packages first, before bundling it as a Docker image.

  ```shell
  docker build -t opentaskpy -f Dockerfile . # Build the image
  docker run --rm --volume /opt/otf/cfg:/cfg --volume /var/log/otf:/logs--volume /home/<USER>/.ssh/id_rsa:/id_rsa -e OTF_SSH_KEY=/id_rsa -e OTF_LOG_DIRECTORY=/logs task-run -t <TASK NAME> -c /cfg # Run a task
  ```

  The default `opentaskpy` library is only really designed to use SSH for executions and file transfers. To do this, you need to make sure that the host/container that is running the `task-run` script has a private RSA key, that is trusted on all remote hosts that you're running against.

  An environment variable `OTF_SSH_KEY` can be used to define a default SSH key to use for all SSH connectivity. This can be overridden at the transfer/execution level by specifying a `keyFile` in the `credentials` section of the protocol definition.



  This is an example deployment for using OTF in an AWS environment, using BMC Control-M as the job scheduler. Control-M could be replaced with any job scheduler, AWS EventBridge for example, depending on your requirements.

  ![AWS Deployment](docs/aws.png)

  "Admin/Status Portal" currently does not exist, and is a placeholder for a potential further project to visualise the OTF configs, as well as including real-time job statuses from the job scheduler.



  There are several ways to customise the running of tasks.



  The following details the syntax of the `task-run` command:

  ```
  usage: task-run [-h] -t TASKID [-r RUNID] [-v VERBOSITY] [-c CONFIGDIR]

  options:
    -h, --help            show this help message and exit
    --noop                Do not attempt to run anything. Only load the config files to validate that they're OK
    -t TASKID, --taskId TASKID
                          Name of the JSON config to run
    -r RUNID, --runId RUNID
                          Unique identifier to correlate logs with. e.g. if being triggered by an external scheduler
    -v VERBOSITY, --verbosity VERBOSITY
                          Increase verbosity
    -c CONFIGDIR, --configDir CONFIGDIR
                          Directory containing task configurations
  ```

  **--noop**

  This is useful for validating the configuration is valid. It will not actually do anything, other than load the configuration files and validate that they are valid. N.B. This only works for executions and transfers.

  **-t, --taskId**

  This relates to the specific task that you want to run. It is the name of the configuration file to load (without the `.json` or `.json.j2` suffix), contained under the `CONFIGDIR`

  **-r, --runId**

  A log aggregation mechanism to bundle logs for several steps in a batch together. e.g. if you pass in `-r some_job_name`, the log files for all executions and transfers will be placed under `<logdir>/some_job_name/`

  **-v, --verbosity**

  There are 3 levels of logging, beyond the default INFO level. These are VERBOSE1 (1), VERBOSE2 (2), and DEBUG (3).

  VERBOSITY is an integer; 1, 2 or 3

  **-c, --configDir**

  The directory containing all of the config files. These are the task definition JSON files, as well as the variables Jinja2 template file.

  In order for the process to run, you must have at least one task, and a `variables.json.j2` file, even if it's just an empty object definition



  This is a script that can be used to validate the configuration of a batch. It will check that all tasks are defined consecutively, and that there are valid dependencies. It will also check that all tasks are defined in the `configDir` directory.

  It is run as follows:

  ```shell
  otf-batch-validator -c /path/to/configDir -t batch-task-name
  ```

  Full list of arguments are as follows:

  ```
  usage: otf-batch-validator [-h] -t TASKID [-v VERBOSITY] [-c CONFIGDIR]

  options:
    -h, --help            show this help message and exit
    -t TASKID, --taskId TASKID
                          Name of the JSON config to run
    -v VERBOSITY, --verbosity VERBOSITY
                          Increase verbosity: 3 - DEBUG 2 - VERBOSE2 1 - VERBOSE1
    -c CONFIGDIR, --configDir CONFIGDIR
                          Directory containing task configurations
  ```



  These are some environment variables that can be used to customise the behaviour of the application. There are some internally used variables too, but changing them without a full understanding of the code is not advised.

  - `OTF_NO_LOG` - Disable logging to file. Only log to stderr. Set to `1` to enable
  - `OTF_LOG_JSON` - Stderr logging will be in JSON format. Set to `1` to enable
  - `OTF_LOG_DIRECTORY` - Path under which log files are written
  - `OTF_RUN_ID` - (meant for internal use) An aggregator for log files. When set, all log files for a run will go under this sub directory. E.g. running a batch, all execution and transfer logs will be dropped into this sub directory, rather than a directory for each task name. This is equivalent to using `-r` or `--runId` command line arguments, which is generally preferred.
  - `OTF_SSH_KEY` - The private SSH key to use by default for all SSH connections. This is essential when using a basic docker container to trigger OTF. If not specified, it will default to use any private SSH keys available to the user executing the application.
  - `OTF_STAGING_DIR` - Staging base directory to place files before they're dropped into their final location. Default is `/tmp`
  - `OTF_BATCH_RESUME_LOG_DATE` - Allow resuming of batch runs from a specific date. This is useful if you want to rerun a batch from a specific date, especially if the failure happens just after midnight and the date is no longer the same as the original run. Date format is `YYYYMMDD`
  - `OTF_VARIABLES_FILE` - Override the default variables file. This is useful when you want to use the same job definitions, but point at a different environment with different for example. Multiple files can be specified comma-separated. If variables appear in more than one file, they will be resolved from the last entry found.
  - `OTF_PARAMIKO_ULTRA_DEBUG` - Enables the hidden `ultra_debug` option for Paramiko. This will log all SSH communications to the console, and can be very verbose, so be careful when using this. Set to `1` to enable (This is for SFTP only)
  - `OTF_LAZY_LOAD_VARIABLES` - Enables lazy loading of variables. This will only load variables that are used by the task definition. This can be useful if you have a large number of variables, and you only need a few of them.



  By default, OTF will log to a directory called `logs` in the current working directory. For the docker containers, unless overridden by `OTF_LOG_DIRECTORY`, it will write to `/logs` using a symlink at `/app/logs`



  Variables can exist at a global level, and also on a per-task basis.

  You must always have a `variables.json.j2` file defined at the root of your `configDir`.

  Variables can be used using the Jinja2 template syntax within task definitions. They can also be nested.

  Individual tasks can have their own local variables too



  By default, all variables are loaded whenever the variables file is loaded. This can be slow if you have a large number of variables, or there are variables that some tasks use that others don't. To avoid this, you can set the `OTF_LAZY_LOAD_VARIABLES` environment variable to `1`. This will only load variables that are used by the task definition at runtime.



  Sometimes you might want to override the current date, or something specific about a file transfer when you manually run a task. This can be done using environment variables.

  Standard global variables can be overridden simply by setting an environment variable that matches the name of the variable you want to override e.g. `export DD=01`
  In the log output, you'll see something like this:

  ```
  Overriding global variable (DD: 05) with environment variable (01)
  ```

  To override task specific values, you can use the following format in the environment variable name:
  `OTF_OVERRIDE_<TASK_TYPE>_<ATTRIBUTE>_<ATTRIBUTE>_<ATTRIBUTE>`

  e.g. `OTF_OVERRIDE_TRANSFER_SOURCE_HOSTNAME`

  Case doesn't matter here. For attributes that are nested within an array, you can specify the array index

  e.g. `OTF_OVERRIDE_TRANSFER_DESTINATION_0_PROTOCOL_CREDENTIALS_USERNAME`

  Again this will be logged to show you that the override is being applied.



  Static variables are useful, however sometimes you need to look up something a bit more dynamic, or secret, that you don't want to hard code into the variables file.

  There are 2 default lookup plugins available:

  - File
  - HTTP JSON

  The file plugin will load the content of a file into the variable e.g.

  ```jinja
  "{{ lookup('file', path='/tmp/variable_lookup.txt') }}"
  ```

  The HTTP JSON plugin will perform a very basic HTTP GET request, expecting a JSON response. The value to extract is defined by a jsonpath e.g.

  ```jinja
  "{{ lookup('http_json', url='https://jsonplaceholder.typicode.com/posts/1', jsonpath='$.title') }}"
  ```

  This will hit the typicode.com side, and extract the title attribute from from the returned JSON file



  OTF will look for plugins that are either available as an installed module (under the `opentaskpy.plugins.lookup` namespace), or dropped in a `plugins` under the config directory.

  An example Python module might be: `opentaskpy.plugins.lookup.aws.ssm`. This can then be referenced as a variable in a template like so:

  ```jinja
  "{{ lookup('aws.ssm', name='my_test_param') }}"
  ```

  Alternatively a lookup plugin could be placed under `cfg/plugins` named `my_lookup.py`, and used in a template:

  ```jinja
  "{{ lookup('my_lookup', name='my_param') }}"
  ```



  Some variables, such as access tokens or refresh tokens for OAuth might need to be updated as part of a transfer, if a new refresh_token is issued for example. This can be achieve by using the `cacheableVariables` attribute in the task definition.

  By default only "file" based cacheable variables are supported, but like lookup plugins and addons, it is possible to add functionality for your own.

  Cacheable variables should be defined using an equivalent caching plugin to the lookup plugin that is used by the template to retrieve it. For example the following task definition shows the "dummy" handler being used, where an "access_token" is retrieved using the file plugin. When the dummy handler updates the access_token, it uses the file caching plugin to write the updated variable to the same file:

  ```json
  {
    "task_id": 1234,
    "type": "transfer",
    "source": {
      "accessToken": "{{ lookup('file', path='/tmp/cacheable_variable.txt') }}",
      "protocol": { "name": "opentaskpy.remotehandlers.dummy" }
    },
    "cacheableVariables": [
      {
        "variableName": "source.accessToken",
        "cachingPlugin": "file",
        "cacheArgs": {
          "file": "/tmp/cacheable_variable.txt"
        }
      }
    ]
  }
  ```

  The `cacheableVariables` attribute is a list of objects, each containing the following attributes:

  - `variableName` - The name of the variable to cache. This should be defined using dot notation with reference to the base of the task definition. e.g. `source.accessToken`. This also supports array indexing, e.g. `source.destinations[0].hostname` (though this is a very unlikely use case)
  - `cachingPlugin` - The name of the caching plugin to use. If anything other than "file" is used, the plugin must be available in the `opentaskpy.config.variablecaching` namespace, and fully qualified.
  - `cacheArgs` - A dictionary of arguments to pass to the caching plugin. This should be a dictionary or arguments required by the caching plugin, excluding the updated value itself.



  Below are examples of some useful variables to start with:

  ```json
  "YYYY": "{{ now().strftime('%Y') }}",
  "MM": "{{ now().strftime('%m') }}",
  "DD": "{{ now().strftime('%d') }}",
  "TODAY": "{{ YYYY }}{{ MM }}{{ DD }}",
  "MONTH_SHORT": "{{ now().strftime('%b') }}",
  "DAY_SHORT": "{{ now().strftime('%a') }}",
  "PREV_DD": "{{ (now()|delta_days(-1)).strftime('%d') }}",
  "PREV_MM": "{{ (now()|delta_days(-1)).strftime('%m') }}",
  "PREV_YYYY": "{{ (now()|delta_days(-1)).strftime('%Y') }}"
  ```

  Usage:

  ```json
  "fileRegex": "somefile.*{{ YYYY }}\\.txt"
  ```

  `now` is added by OTF, it will return a `datetime` object aligned to whatever timezone the worker is running. If you need the UTC time, then you can use `utc_now` instead.



  Task definitions are validated using the JSON Schemas defined within `src/opentaskpy/config/schemas/`. These are split up to make them more readable. The top level schema for each task type is defined within the `schemas.py` file, one level above.

  At a later date, I plan to automate the creation of the JSON schema documentation.

  The task definitions themselves live under the `cfg` directory, and any number of sub directories under there to allow for grouping of tasks by whatever you like. Definitions can be either a plain JSON file, or a Jinja2 template. If a template is used, it must have the `.j2` suffix. JSON files may also use internal variables, this is not supported when using `.j2` task definitions.



  Transfers consist of a `source` definition, and an optional `destination`.

  The easiest way to see usage is to look at the examples under the `examples` directory

  Below is an example of all the options available for a transfer:

  ```json
  {
    "type": "transfer",
    "source": {
      "hostname": "{{ HOST_A }}",
      "directory": "/tmp/testFiles/src",
      "fileRegex": ".*\\.txt",
      "fileWatch": {
        "timeout": 15,
        "directory": "/tmp/testFiles/src",
        "fileRegex": "fileWatch\\.txt"
      },
      "logWatch": {
        "timeout": 15,
        "directory": "/tmp/testFiles/src",
        "log": "log{{ YYYY }}Watch1.log",
        "contentRegex": "someText[0-9]",
        "tail": true
      },
      "conditionals": {
        "size": {
          "gt": 10,
          "lt": 20
        },
        "age": {
          "gt": 60,
          "lt": 600
        }
      },
      "postCopyAction": {
        "action": "move",
        "destination": "/tmp/testFiles/archive"
      },
      "protocol": {
        "name": "ssh",
        "credentials": {
          "username": "{{ SSH_USERNAME }}"
        }
      }
    },
    "destination": [
      {
        "hostname": "{{ HOST_B }}",
        "directory": "/tmp/testFiles/dest",
        "permissions": {
          "group": "operator"
        },
        "protocol": {
          "name": "ssh",
          "credentials": {
            "username": "{{ SSH_USERNAME }}"
          }
        }
      },
      {
        "hostname": "{{ HOST_B }}",
        "directory": "/tmp/testFiles/dest",
        "transferType": "pull",
        "rename": {
          "pattern": "^(.*)\\.txt$",
          "sub": "\\1-2.txt"
        },
        "protocol": {
          "name": "ssh",
          "credentials": {
            "username": "{{ SSH_USERNAME }}",
            "transferUsername": "{{ SSH_USERNAME }}"
          }
        }
      }
    ]
  }
  ```

  An explanation of what's going on in the order it will handled:

  1. Tail the log file matching named: `/tmp/testFiles/src/log{{ YYYY }}Watch1.log` for lines matching containing the regex `someText[0-9]`, for up to 15 seconds, before giving up.
  2. Poll for a file matching the regex `/tmp/testFiles/src/fileWatch\.txt` for up to 15 seconds.
  3. Find all files matching the regex `/tmp/testFiles/src/.*\.txt`, with the conditions that the are >10B and <20B in size, as well as being older than 60 seconds, but newer than 600 seconds since last modification
  4. Transfer the files that were found to 2 destinations.
     1. The first destination is a simple SCP from `HOST_A` to `HOST_B` where the file is placed under `/tmp/testFiles/dest`. The group ownership of the file(s) is then set to `operator`
     2. The second destination is done via a pull from the destination server into the same directory. The SCP connects to `HOST_A` as `transferUsername`. Once the file has been retrieved, it is renamed using the following regex match `^(.*)\.txt$` and substitution `\1-2.txt`
  5. Transferred files are moved into `/tmp/testFiles/archive` on `HOST_A`



  Executions are the simplest task to configure. They consist of a list of hosts to run on, the username to run/connect as, and the command to run.

  Executions do not currently have a timeout, so can in theory run forever, or until they are killed. If a timeout is required, either use a wrapper script on the host the command is being executed on, or they should be wrapped inside a batch.

  ```json
  {
    "type": "execution",
    "hosts": ["{{ HOST_A }}"],
    "directory": "/tmp/testFiles/src",
    "command": "touch touchedFile.txt",
    "protocol": {
      "name": "ssh",
      "credentials": {
        "username": "{{ SSH_USERNAME }}"
      }
    }
  }
  ```

  The above is running the command `touch touchedFile.txt` on `{{ HOST_A }}`, from within the `/tmp/testFiles/src` directory.

  If multiple `hosts` are defined, a thread is spawned in parallel for each host. If the command fails on any of the hosts in the list, it will cause the task run to fail, once all processes have returned a result.



  Batches are a little more complex. They do not contain any task definitions, only the list, and order of execution for each task.

  A batch task can have multiple options set that determine the execution order and conditions, as well as how failures and task reruns are handled.

  Each task in a batch has an `order_id`, this is a unique ID for each task, and is primarily used to define dependencies.

  `dependencies` can be applied to any task, and are simply a list of other tasks that must be completed before it is triggered.

  `continue_on_fail` is a boolean that defines whether a failure would cause the whole batch to fail immediately (after existing tasks have finished executing), or whether following steps get run. This defaults to false if not defined.

  `retry_on_rerun` is a boolean that determines whether a successful task is run a second time following a failed run. If a batch exits with a failure, and then the script is reun later on that same day, by default only the steps that failed will be run. All steps can be forced to run by setting this to true

  `timeout` specifies the number of seconds a task is allowed to be running before it gets terminated. This counts as a failure. The default timeout, if not specified is 300 seconds.

  As a batch task runs, it writes out the status of each sub task to it's log file. If a failure occurs, and the batch is rerun with the same arguments, it will attempt to resume from the point of failure. To determine the previous state, the batch handler will look at only logs that are from the current date. This is tp ensure that if something failed at 1am yesterday, but hasn't been rerun, we won't try to recover from the point of failure. Sometimes you might want to recover regardless, this can be done by passing in the date of the log files that you want to recover from, using the environment variable `OTF_BATCH_RESUME_LOG_DATE` in the format `YYYYMMDD`. This will instruct the batch handler to look at logs with that date instead.



  This repo has been primarily configured to work with GitHub Codespaces devcontainers, though it can obviously be used directly on your machine too.

  Dev and runtime packages are defined via pipenv, with a `requirements.txt` for the runtime package requirements



  - Clone this repo
  - pip install pipenv
  - pipenv --python 3.10 && pipenv install && cd src && pipenv install --editable .



  ```bash
  python3 -m build
  python3 -m twine upload --repository testpypi dist/*
  ```



  Here's a list of official addons:



  Provides transfer and execution addons:

  - Remote handler for interacting with AWS S3 buckets
  - Remote handler for executing AWS Lambda functions

  Lookup plugins:

  - Support for AWS SSM Parameter Store for retrieving global variables

  Caching Plugins:

  - Support for caching variables to AWS Secrets Manager/Parameter Store



  Lookup plugins:

  - Support for lookup of global variables from Hashicorp Vault



  Provides transfer addons:

  - Remote handler for interacting with Microsoft SharePoint Online



  When using external libraries, be sure to add `opentaskpy.otflogging.set_log_file("<PACKAGE>")` somewhere to ensure that any additional logs from the 3rd party library make their way into the OTF logs.



  Plugins are very simple. They simply need a `run` function, and to return the required variable based on a list of kwargs provided within the config template.

  3 examples are bundled by default. The simplest of which is the `random` plugin, which takes 2 numbers and returns a random number between the 2.

  They should either be installed as a python package and accessible to load as a module, or stored within the config directory under a `plugins` directory.

  They must sit under the `opentaskpy.plugins.lookup` namespace. The filename must match the name of the plugin being references from the template lookup function.



  Addons allow you to write your own interfaces with other types of remote systems. This could be a custom database provider to allow you to run stored procedures on demand, or something like AWS to perform custom transfers

  Addons can either be a transfer type, or execution, and must follow the same rules. They should implement all of the functions in the abstract `RemoteTransferHandler` or `RemoteExecutionHandler` class, or return a `NotImplementedError` exception.

  You should also ensure that you define an appropriate JSON schema, and include those under the `opentaskpy.addons.XXXX.remotehandlers.schemas` directory

  Addons can technically be named under any namespace, but must be referred to using the full package name in the task definition e.g. `opentaskpy.addons.aws.remotehandlers.lambda.LambdaExecution`


pkgId: acb4ef736ddeca7be9689b8ce4aea4944209bda948804afc37dcbf6085681f80
name: python-opentelemetry-instrumentation-rq-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for opentelemetry-instrumentation-rq
url: https://github.com/K-T-Ng/opentelemetry-instrumentation-rq
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opentelemetry-instrumentation-rq-0.0.7-1.src.rpm
location_href: Packages/python-opentelemetry-instrumentation-rq-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  This library provides an OpenTelemetry Instrumentation library for Python RQ (Redis Queue). It enables distributed tracing and monitoring of tasks produced and processed by RQ workers, making it easier to gain insights into your application's performance and behavior.

  🚧 This project is currently under active development. Some features may not yet be supported. 🚧



  Automatic tracing when
  * Task producing, via `rq.queue.Queue._enqueue`
  * Task execution, via `rq.job.Job.perform`
  * Callback function execution after a job succeeds, fails, or stops, via `rq.job.Job.execute_*_callback`


  - [ ] Enqueue Tracing
      - [ ] Support span linking for job dependencies.
      - [x] Add tracing for `rq.queue.Queue._enqueue` (not worked for schedlue job).
      - [x] Add support for enqueue functions used by the RQ scheduler.
  - [x] Consumer Tracing
      - [x] Add tracing for the outer layer `rq.worker.Worker.perform_job` to visualize the execution time for the entire fork process.
      - [x] Add tracing for the inner layer `rq.job.Job.perform`.
      - [x] Add tracing for the inner layer `handle_job_*`  to visualize post-processing after job execution.
  - [ ] Improved Clarity
      - [ ] Refine span names and attributes for better readability and understanding.
  - [ ] Adjust the dependencies version by testing the lower limit by github action.


  Install this package with `pip`:
  ```
  pip install opentemeletry_instrumentation_rq
  ```



  In your RQ producer or worker code, initialize the OpenTelemetry RQ instrumentation:
  ```python
  from opentelemetry_instrumentation_rq import RQInstrumentor

  RQInstrumentator().instrument()
  ```


  This project is licensed under the [MIT License](./LICENSE).


pkgId: 8a111a808361702cac5273507e09ce773dc6ffe71a4e913439a6c89f4bd4d8bc
name: python-openwebifpy-help
arch: noarch
version: 4.3.0
epoch: 0
release: 1
summary: Development documents and examples for openwebifpy
url: https://github.com/autinerd/openwebifpy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openwebifpy-4.3.0-1.src.rpm
location_href: Packages/python-openwebifpy-help-4.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![openwebifpy on PyPI](https://img.shields.io/pypi/v/openwebifpy.svg)](https://pypi.python.org/pypi/openwebifpy)

  Provides a python interface to interact with a device running OpenWebIf

  - Free software: MIT license
  - OpenWebif API docs: https://github.com/E2OpenPlugins/e2openplugin-OpenWebif/wiki/OpenWebif-API-documentation



  - Basic control of an Enigma2 box running OpenWebif.
  - Ability to send messages to the screen.


pkgId: ea579ea708bd6e07f917204fb740859b609e44cb8fb334a60980838b494170cc
name: python-openyieldtables-help
arch: noarch
version: 2.60.0
epoch: 0
release: 1
summary: Development documents and examples for openyieldtables
url: https://github.com/treely/openyieldtables
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-openyieldtables-2.60.0-1.src.rpm
location_href: Packages/python-openyieldtables-help-2.60.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://cdn.tree.ly/assets/v4/yield-tables/logo_white_background.svg" alt="Yield Tables logo" width="280"/>

  [![PyPI - Version](https://img.shields.io/pypi/v/openyieldtables)](https://pypi.org/project/openyieldtables/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openyieldtables)](https://pypi.org/project/openyieldtables/) ![Test](https://github.com/github/docs/actions/workflows/test.yml/badge.svg) [![Documentation Status](https://readthedocs.org/projects/openyieldtables/badge/?version=latest)](https://openyieldtables.readthedocs.io/en/latest/?badge=latest)

  An open source Python library for yield tables.



  Download the latest version of the library from [PyPI](https://pypi.org/project/openyieldtables/):

  ```bash
  pip install openyieldtables
  ```

  Import the library and load a yield table:

  ```python
  from openyieldtables.yieldtables import (
      get_yield_table,
      get_yield_tables_meta,
  )


  yield_tables_meta = get_yield_tables_meta()


  yield_table_data = get_yield_table(1)
  ```



  You can find the documentation
  [here](https://openyieldtables.readthedocs.io/en/latest/).



  We are happy about every contribution! Please follow our
  [contribution guideline](https://github.com/treely/openyieldtables/blob/main/CONTRIBUTING.md).



  `openyieldtables` is maintained by [Tree.ly](https://tree.ly) and
  [FMM](https://www.fmm.at/).


pkgId: 7f7cb475f2dcdc8a36d9a5910156e8cea10b30c83cbce70f5265d82372d74a45
name: python-opmentis-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for opmentis
url: https://github.com/OpMentis-Ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opmentis-0.2.2-1.src.rpm
location_href: Packages/python-opmentis-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  Opmentis is a Python package designed to manage user registrations within a decentralized application, allowing users to register as miners or validators. This package simplifies the process of user registration by providing a single function that can handle different user roles based on the presence of a stake.



  - **User Registration**: Simplified user registration that supports different roles (miner or validator).
  - **Scalable and Secure**: scalable and secure data storage.



  Install Opmentis using pip:

  ```bash
  pip install opmentis
  ```




  To register a new user as a miner:



  ```python
  from opmentis import get_active_lab, register_user


  active_lab = get_active_lab()
  print("Active Lab Information:", active_lab)



  wallet_address = "your_wallet_address"
  labid = "your_lab_id"
  role_type = "miner"
  register_response = register_user(wallet_address, labid, role_type)
  print("Registration Response:", register_response)

  ```



  To check miners data:

  ```python
  from opmentis import userdata, userpoint, request_reward_payment, check_user_balance


  miner_wallet_address = "miner_wallet_address"
  labid = "your_lab_id"
  userdata(labid=labid, wallet_address=miner_wallet_address)

  labid = "your_lab_id"
  userpoint(labid, miner_wallet_address)


  request_amount = 250
  print(request_reward_payment(labid, miner_wallet_address,request_amount))

  print(check_user_balance(labid, miner_wallet_address))

  ```

  To end the current chat and update your points for the session, use the following code:

  ```python
  from opmentis import endchat


  endchat()

  ```


  Contributions to Opmentis will be welcomed soon.




  For more information and updates, contact the project maintainers @admin@opmentis.xyz


pkgId: 86d637a7a31c405566f0c02c30e1ce73e9671d47cbe3acebbb3aafd202a9bb74
name: python-opperai-help
arch: noarch
version: 0.26.2
epoch: 0
release: 1
summary: Development documents and examples for opperai
url: https://pypi.org/project/opperai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opperai-0.26.2-1.src.rpm
location_href: Packages/python-opperai-help-0.26.2-1.noarch.rpm
checksum_type: sha256
description:
  This is the Opper Python SDK. See below for getting started, and the [docs](https://docs.opper.ai) for more information. The SDK has builtin documentation and examples in function docstrings, which should be visible in your code editor as you are using the functions.



  ```bash
  pip install opperai
  ```





  - `OPPER_API_KEY` environment variable is read by the SDK if no `api_key` is provided to the `Client` object.



  ```python
  from typing import List

  from opperai import Index, Opper, trace
  from opperai.types import DocumentIn
  from opperai.types.indexes import DocumentIn, RetrievalResponse
  from pydantic import BaseModel


  class Answer(BaseModel):
      steps: List[str]


  class QuestionAndContext(BaseModel):
      question: str
      context: List[RetrievalResponse]


  @trace
  def answer_question(index: Index, question: str) -> Answer:
      results = index.query(question, 1, None)

      result, response = opper.call(
          name="answer_question",
          instructions="Answer the question and provide the steps to do so",
          input=QuestionAndContext(question=question, context=results),
          output_type=Answer,
      )
      response.span.save_metric("artificial_score", 5)

      return result


  @trace
  def translate(answer: Answer, language: str) -> str:
      result, _ = opper.call(
          name="translate",
          instructions="Translate the answer to the given language",
          input=answer,
          output_type=Answer,
      )
      return result


  qna = [
      {
          "question": "I cannot log in to my account",
          "answer": "Use the reset password feature by clicking on 'Forgot password?' and then follow the instructions from email",
          "id": "1",
      },
      {
          "question": "How can I see my invoices?",
          "answer": "Go to the billing section and click on 'Invoices'",
          "id": "2",
      },
      {
          "question": "How can I add a new user to my account?",
          "answer": "Upgrade account and add the user to your account",
          "id": "3",
      },
  ]

  opper = Opper()


  def index_qna(qnas: list[dict]):
      index = opper.indexes.create("qna")

      for qna in qnas:
          index.add(
              DocumentIn(
                  key=qna["id"],
                  content=f"question: {qna['question']}\nanswer: {qna['answer']}",
                  metadata={
                      "id": qna["id"],
                  },
              )
          )

      return index


  def run():
      index = index_qna(qna)

      question = "How can I see my invoices?"

      with opper.traces.start("answer_question") as trace:
          answer = answer_question(index, question)
          print(answer)


  run()
  ```



  See examples in our [documentation](https://docs.opper.ai)
  and [examples](https://github.com/opper-ai/opper-python/tree/main/examples) folder.


pkgId: 7e23a6271c607098a4e6c3ace8081ed1f26ab35c714e56720bbf4bd1ba59c9ec
name: python-opstool-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for opstool
url: https://github.com/yexiang1992/opstool
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-opstool-1.0.6-1.src.rpm
location_href: Packages/python-opstool-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  *Pre-Processing, Post-Processing, and Visualization Tailored for OpenSeesPy*

  [![pypi](https://img.shields.io/pypi/v/opstool)](https://pypi.org/project/opstool/)
  [![Downloads](https://static.pepy.tech/badge/opstool)](https://pepy.tech/project/opstool)
  [![Documentation Status](https://readthedocs.org/projects/opstool/badge/?version=latest)](https://opstool.readthedocs.io/en/latest/?badge=latest)
  [![github stars](https://img.shields.io/github/stars/yexiang1992/opstool?style=social)](https://github.com/yexiang1992/opstool)
  [![GitHub License](https://img.shields.io/github/license/yexiang1992/opstool?style=flat)](https://img.shields.io/github/license/yexiang1992/opstool?style=flat)
  [![code grade](https://img.shields.io/codefactor/grade/github/yexiang1992/opstool)](https://www.codefactor.io/repository/github/yexiang1992/opstool)

  ``opstool`` is a powerful and user-friendly package designed to simplify and enhance structural analysis workflows
  with [OpenSees](https://opensees.berkeley.edu/) and [OpenSeesPy](https://openseespydoc.readthedocs.io/en/latest/).
  It provides advanced tools for preprocessing, postprocessing, and visualization, making structural
  simulations more efficient and accessible.

  The package is still under development.
  To use, install `opstool` from [opstool-PyPI](https://pypi.org/project/opstool/):

  ```bash
  pip install --upgrade opstool
  ```

  The restriction on the python version mainly depends on `openseespy`,
  it is recommended that you use [Anaconda](https://www.anaconda.com/) to avoid library version incompatibilities.



  **Latest**: See [https://opstool.readthedocs.io/en/latest/](https://opstool.readthedocs.io/en/latest/).

  **Stable**: See [https://opstool.readthedocs.io/en/stable/](https://opstool.readthedocs.io/en/stable/)

  > 📌 **Note:** Since an opstool version **v1.0.1**, the API and features have undergone significant changes and upgrades. As a result, it feels more like a new library, and you should take some time to familiarize yourself with the new interface usage.



  1. **Preprocessing Tools**:
     - *Fiber Section Meshing*: Generate detailed fiber meshes for various geometries.
     - *GMSH Integration*: Import and convert [Gmsh](https://gmsh.info/) models, including geometry, mesh, and physical groups.
     - *Unit System Management*: Ensure consistency with automatic unit conversions.
     - *Mass Generation*: Automate lumped mass calculations.
  2. **Postprocessing Capabilities**:
     - Easy retrieval and interpretation of analysis results using [xarray](https://docs.xarray.dev/en/stable/index.html#).
  3. **Visualization**:
     - Powered by [Pyvista](https://docs.pyvista.org/) (VTK-based) and [Plotly](https://plotly.com/python/) (web-based).
     - Nearly identical APIs for flexible visualization of model geometry, modal analysis, and simulation results.
     - Supports most common OpenSees elements.
  4. **Intelligent Analysis**:
     - Features like automatic step size adjustment and algorithm switching to optimize simulation workflows.
     - Moment-Curvature Analysis: Generate moment-curvature curves for various sections.



  - **Efficiency**: Streamlines complex workflows, reducing time spent on repetitive tasks.
  - **Flexibility**: Provides nearly identical interfaces for different visualization engines.
  - **Accessibility**: Makes advanced structural analysis tools like OpenSeesPy more approachable to users of all levels.

  ``opstool`` is actively evolving, with continuous additions of new features planned for the future.
  With ``opstool``, you can focus on what matters most:
  understanding and solving your structural engineering challenges.
  Whether you are building models, visualizing results, or interpreting data,
  ``opstool`` is your go-to solution for OpenSeesPy workflows.



  This software is published under the [GPLv3 license](https://www.gnu.org/licenses/gpl-3.0.en.html).


