# packages

pkgId: 5f54bd7affad0d0eb555b84554f902deaff2769aa9619b35fa940d6a6a16ff24
name: python-hoardy-web-sas-help
arch: noarch
version: 1.8.0
epoch: 0
release: 1
summary: Development documents and examples for hoardy-web-sas
url: https://oxij.org/software/hoardy-web/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hoardy-web-sas-1.8.0-1.src.rpm
location_href: Packages/python-hoardy-web-sas-help-1.8.0-1.noarch.rpm
checksum_type: sha256
description:
  `hoardy-web-sas` is a very simple archiving server for the [`Hoardy-Web` Web Extension browser add-on](https://github.com/Own-Data-Privateer/hoardy-web/tree/master/extension/) (also [there](https://oxij.org/software/hoardy-web/tree/master/extension/)).

  I.e. this is the thing you run and then paste the URL of into the `Server URL` setting of the `Hoardy-Web` add-on.

  This is not the most feature-rich thing for doing that, [`hoardy-web serve`](https://github.com/Own-Data-Privateer/hoardy-web/tree/master/tool/) (also [there](https://oxij.org/software/hoardy-web/tree/master/tool/)) is much more powerful.
  But, `hoardy-web serve` is not at all simple and it depends on quite a lot of things.
  Meanwhile, this `hoardy-web-sas` thing is less than 250 lines of pure Python that only uses the Python\'s standard library and nothing else.
  You could be running it already.



  This was made for easy [Quickstart](https://github.com/Own-Data-Privateer/hoardy-web/tree/master/README.md#quickstart) (also [there](https://oxij.org/software/hoardy-web/tree/master/README.md#quickstart)) that also [does reliable archiving](https://oxij.org/software/hoardy-web/tree/master/extension/page/help.org#faq-unsafe).





  - Install `Python 3`:

    - On Windows: [Download and install Python from the official website](https://www.python.org/downloads/windows/).
    - On a conventional POSIX system like most GNU/Linux distros and MacOS X: Install `python3` via your package manager. Realistically, it probably is installed already.



  - On a Windows system with unconfigured `PATH`, install with:

    ``` bash
    pip install hoardy-web-sas
    ```
    and run as
    ``` bash
    python3 -m hoardy_web_sas --help
    ```

  - On a conventional POSIX system or on a Windows system with configured `PATH` environment variable, install it with:

    ``` bash
    pip install hoardy-web-sas
    ```
    and run as
    ``` bash
    hoardy-web-sas --help
    ```

  - Alternatively, run without installing:

    ``` {.bash}
    ./hoardy-web-sas.py --help
    ```

  - Alternatively, on a system with [Nix package manager](https://nixos.org/nix/)

    ``` {.bash}
    nix-env -i -f ./default.nix
    hoardy-web-sas --help
    ```

    Though, in this case, you'll probably want to do the first command from the parent directory, to install everything all at once.



  ```
  usage: hoardy_web_sas.py [-h] [--version] [--host HOST] [--port PORT] [-t ROOT] [--compress | --no-compress] [--default-bucket NAME] [--ignore-buckets] [--no-print]

  Simple archiving server for Hoardy-Web. Dumps each request to `<ROOT>/<bucket>/<year>/<month>/<day>/<epoch>_<number>.wrr`.

  options:
    -h, --help            show this help message and exit
    --version             show program's version number and exit
    --host HOST           listen on what host/IP; default: `127.0.0.1`
    --port PORT           listen on what port; default: `3210`
    -t ROOT, --to ROOT, --archive-to ROOT, --root ROOT
                          path to dump data into; default: `pwebarc-dump`
    --compress            compress new archivals before dumping them to disk; default
    --no-compress, --uncompressed
                          dump new archivals to disk without compression
    --default-bucket NAME, --default-profile NAME
                          default bucket to use when no `profile` query parameter is supplied by the extension; default: `default`
    --ignore-buckets, --ignore-profiles
                          ignore `profile` query parameter supplied by the extension and use the value of `--default-bucket` instead
    --no-print, --no-print-cbors
                          don't print parsed representations of newly archived CBORs to stdout even if `cbor2` module is available

  ```


pkgId: 12d67b77bceceaa580852b424729c0dfb6177bb86beaa5c040b56490e4ceb0a6
name: python-holobench-help
arch: noarch
version: 1.33.0
epoch: 0
release: 1
summary: Development documents and examples for holobench
url: https://pypi.org/project/holobench/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-holobench-1.33.0-1.src.rpm
location_href: Packages/python-holobench-help-1.33.0-1.noarch.rpm
checksum_type: sha256
description:
   

  [![Ci](https://github.com/dyson-ai/bencher/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/dyson-ai/bencher/actions/workflows/ci.yml?query=branch%3Amain)
  ![Read the Docs](https://img.shields.io/readthedocs/bencher)
  [![Codecov](https://codecov.io/gh/dyson-ai/bencher/branch/main/graph/badge.svg?token=Y212GW1PG6)](https://codecov.io/gh/dyson-ai/bencher)
  [![GitHub issues](https://img.shields.io/github/issues/dyson-ai/bencher.svg)](https://GitHub.com/dyson-ai/bencher/issues/)
  [![GitHub pull-requests merged](https://badgen.net/github/merged-prs/dyson-ai/bencher)](https://github.com/dyson-ai/bencher/pulls?q=is%3Amerged)
  [![PyPI](https://img.shields.io/pypi/v/holobench)](https://pypi.org/project/holobench/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/holobench)](https://pypistats.org/packages/holobench)
  [![License](https://img.shields.io/pypi/l/bencher)](https://opensource.org/license/mit/)
  [![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://www.python.org/downloads/)
  [![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh)



  ```bash
  pip install holobench
  ```



  Bencher is a tool to make it easy to benchmark the interactions between the input parameters to your algorithm and its resulting performance on a set of metrics.  It calculates the [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of a set of variables

  Parameters for bencher are defined using the [param](https://param.holoviz.org/) library  as a config class with extra metadata that describes the bounds of the search space you want to measure.  You must define a benchmarking function that accepts an instance of the config class and return a dictionary with string metric names and float values.

  Parameters are benchmarked by passing in a list N parameters, and an N-Dimensional tensor is returned.   You can optionally sample each point multiple times to get back a distribution and also track its value over time.  By default the data will be plotted automatically based on the types of parameters you are sampling (e.g, continuous, discrete), but you can also pass in a callback to customize plotting.

  The data is stored in a persistent database so that past performance is tracked.



  The input types should also be of one of the basic datatypes (bool, int, float, str, enum, datetime) so that the data can be easily hashed, cached and stored in the database and processed with seaborn and xarray plotting functions. You can use class inheritance to define hierarchical parameter configuration class types that can be reused in a bigger configuration classes.

  Bencher is designed to work with stochastic pure functions with no side effects.  It assumes that when the objective function is given the same inputs, it will return the same output +- random noise.  This is because the function must be called multiple times to get a good statistical distribution of it and so each call must not be influenced by anything or the results will be corrupted.



      Enumerate a list of all input parameter combinations
      for each set of input parameters:
          pass the inputs to the objective function and store results in the N-D array

          get unique hash for the set of inputs parameters
          look up previous results for that hash
          if it exists:
              load historical data
              combine latest data with historical data

          store the results using the input hash as a key
      deduce the type of plot based on the input and output types
      return data and plot




  if you have [pixi](https://github.com/prefix-dev/pixi/) installed you can run a demo example with:

  ```bash
  pixi run demo
  ```

  An example of the type of output bencher produces can be seen here:

  https://dyson-ai.github.io/bencher/




  Most of the features that are supported are demonstrated in the examples folder.

  Start with example_simple_float.py and explore other examples based on your data types:
  - example_float.py: More complex float operations
  - example_float2D.py: 2D float sweeps
  - example_float3D.py: 3D float sweeps
  - example_categorical.py: Sweeping categorical values (enums)
  - example_strings.py: Sweeping categorical string values
  - example_float_cat.py: Mixing float and categorical values
  - example_image.py: Output images as part of the sweep
  - example_video.py: Output videos as part of the sweep
  - example_filepath.py: Output arbitrary files as part of the sweep
  - and many others




  API documentation can be found at https://bencher.readthedocs.io/en/latest/

  More documentation is needed for the examples and general workflow.


pkgId: 970857af0bda752c666fb42468fc8df0a45eccbde87615cfe33925a6a4047154
name: python-homematicip-help
arch: noarch
version: 1.1.5
epoch: 0
release: 1
summary: Development documents and examples for homematicip
url: https://github.com/hahn-th/homematicip-rest-api
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-homematicip-1.1.5-1.src.rpm
location_href: Packages/python-homematicip-help-1.1.5-1.noarch.rpm
checksum_type: sha256
description:
  A **Python 3** wrapper for the homematicIP REST API (Access Point Based)
  Since there is no official documentation about this API everything was
  done via reverse engineering. Use at your own risk.

  Any help from the community through e.g. pull requests would be highly appreciated.

  [![PyPI download month](https://img.shields.io/pypi/dm/homematicip.svg)](https://pypi.python.org/pypi/homematicip/) [![PyPI version fury.io](https://badge.fury.io/py/homematicip.svg)](https://pypi.python.org/pypi/homematicip/) [![Discord](https://img.shields.io/discord/537253254074073088.svg?logo=discord&style=plastic)](https://discord.gg/mZG2myJ) [![CircleCI](https://circleci.com/gh/hahn-th/homematicip-rest-api.svg?style=shield)](https://circleci.com/gh/hahn-th/homematicip-rest-api) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/homematicip)



  If you want to get in contact with me or need help with the library, you can get in touch with me via discord. There is a **[discord server](https://discord.gg/mZG2myJ)** and my discord tag is **agonist#6159**



  There is a new documentation site unter https://hahn-th.github.io/homematicip-rest-api which is still under construction.



  :heart: If you want to say thank you or want to support me, you can do that via PayPal.
  [https://paypal.me/thomas08154711](https://paypal.me/thomas08154711?country.x=DE&locale.x=de_DE)



  Kudos and a big thank you to @coreGreenberet, who created this library.



  Just run **pip install -U homematicip** to get the package



  Each push on the master branch will trigger a build. That way you can test the latest version of the library with your systems.
  Just run `pip install -U homematicip --pre` to get the package.



  If you missing a device which is not implemented yet, open an issue and append a dump of your configuration to it using https://gist.github.com. To create a dump use the CLI: `python hmip_cli.py --dump-configuration --anonymize`. See [Usage](#usage) for more instructions.





  First run `python hmip_generate_auth_token.py` (from the command line) to get an auth token for your access point. it will generate a “config.ini” in your current directory.



  You can send commands to homematicIP using the `hmip_cli.py` script. To get an overview, use -h or --help param. To address devices, use the argument -d in combination with the 24-digit ID (301400000000000000000000) from --list-devices.

  A few examples:

  - `hmip_cli --help` to get help
  - `hmip_cli --list-devices` to get a list of your devices.
  - `hmip_cli -d <id-from-device-list> --toggle-garage-door` to toogle the garage door with HmIP-WGC.
  - `hmip_cli --list-events` to listen to events and changes in your homematicIP system
  - `hmip_cli -d <id> --set-lock-state LOCKED --pin 1234` to lock a door with HmIP-DLD
  - `hmip_cli --dump-configuration --anonymize` to dump the current config and anonymize it.



  - hmip_cli.py for listing devices, groups, securityJournal; setting labels, turning switches on/off
  - Sample Projects are under ./homematicip-samples



  - [x] Generate authentication token
  - [x] Read current state of the Environment
  - [x] Weather
  - [x] Location
  - [x] Basic Informations( apversion, pinAssigned, timeZone, … )
  - [x] Devices (partly)
  - [x] Client
  - [x] Groups



  - [x] ALPHA-IP-RBG (Alpha IP Wall Thermostat Display)
  - [x] ALPHA-IP-RBGa (ALpha IP Wall Thermostat Display analog)
  - [ ] ELV-SH-AI8 (Alarmline Interface 8x Inputs) \*powered by HmIP
  - [ ] ELV-SH-BS2 (Switch Actuator for brand switches 2x channels) \*powered by HmIP
  - [ ] ELV-SH-GVI (Garden valve interface) \*powered by HmIP
  - [ ] ELV-SH-IRS8 (Infared Remote control - 8x channels) \*powered by HmIP
  - [ ] ELV-SH-SW1-BAT (2x Actuator Switch for 30V/1A with 2xAA Batteries) \*powered by HmIP
  - [ ] ELV-SH-WUA (Dimming Actuator, 0-10/1-10-V-Control inputs, 8A 230V) \*powered by HmIP
  - [ ] ELV-SH-WSC (2x Servo Controls, 5v - 12V) \*powered by HmIP
  - [x] HMIP-ASIR (Alarm Siren - indoor)
  - [x] HMIP-ASIR-B1 (Alarm Siren - indoor) _Silvercrest Edition_
  - [x] HMIP-ASIR-2 (Alarm Siren - indoor) New Version
  - [x] HMIP-ASIR-O (Alarm Siren - outdoor)
  - [x] HMIP-BBL (Blind Actuator for brand switches)
  - [ ] HMIP-BBL-2 (Blind Actuator for brand switches) New Version
  - [x] HMIP-BDT (Dimming Actuator for brand switches)
  - [x] HMIP-BRC2 (Remote Control for brand switches – 2x channels)
  - [x] HMIP-BROLL (Shutter Actuator - brand-mount)
  - [ ] HMIP-BROLL-2 (Shutter Actuator - brand-mount) New Version
  - [x] HMIP-BSL (Switch Actuator for brand switches – with signal lamp)
  - [x] HMIP-BSM (Brand Switch and Meter Actuator)
  - [ ] HMIP-BSM-I (Brand Switch and Meter Actuator, International)
  - [x] HMIP-BWTH (Wall Thermostat Display with switching output – for brand switches, 230V)
  - [ ] HMIP-BWTH24 (Wall Thermostat Display with switching output – for brand switches, 24V)
  - [x] HMIP-DBB (Doorbell Push-Button)
  - [x] HMIP-DLD (Door Lock Drive)
  - [x] HMIP-DLS (Door Lock Sensor)
  - [x] HmIP-DRG-DALI (Dali Gateway - readonly at the moment)
  - [x] HMIP-DRBLI4 (Blind Actuator for DIN rail mount – 4 channels)
  - [x] HMIP-DRSI1 (Switch Actuator for DIN rail mount – 1x channel)
  - [x] HMIP-DRDI3 (Dimming Actuator Inbound 230V – 3x channels, 200W per channel) electrical DIN rail
  - [x] HMIP-DRSI4 (Switch Actuator for DIN rail mount – 4x channels)
  - [x] HMIP-DSD-PCB (Door Signal Dector PCB)
  - [x] HMIP-eTRV (Heating-Thermostat with Display)
  - [x] HMIP-eTRV-2 (Heating-Thermostat with Display) New Version
  - [ ] HMIP-eTRV-2 I9F (Heating-Thermostat with Display) New Version
  - [ ] HMIP-eTRV-2-UK (UK Version not tested, but it should work)
  - [x] HMIP-eTRV-B (Heating-Thermostat basic with Display)
  - [ ] HMIP-eTRV-B-2 (Heating-Thermostat basic with Display) New Version
  - [ ] HMIP-eTRV-B-2 R4M (Heating-Thermostat basic with Display) New Version
  - [ ] HMIP-eTRV-B-UK (UK Version not tested, but it should work)
  - [x] HMIP-eTRV-B1 (Heating-Thermostat basic with Display) _Silvercrest Edition_
  - [x] HMIP-eTRV-C (Heating-Thermostat compact without display)
  - [x] HMIP-eTRV-C-2 (Heating-Thermostat compact without display) New Version
  - [ ] HmIP-eTRV-CL (Heating-thermostat compact with dispay)
  - [x] HMIP-eTRV-E (Heating-Thermostat Design Evo _New Generation_, white)
  - [ ] HMIP-eTRV-E-A (Heating-Thermostat Design Evo _New Generation_, anthracite)
  - [ ] HMIP-eTRV-E-S (Heating-Thermostat Design Evo _New Generation_, silver)
  - [x] HMIP-FAL230-C6 (Floor Heating Actuator – 6x channels, 230V)
  - [x] HMIP-FAL230-C10 (Floor Heating Actuator – 10x channels, 230V)
  - [x] HMIP-FAL24-C6 (Floor Heating Actuator – 6x channels, 24V)
  - [x] HMIP-FAL24-C10 (Floor Heating Actuator – 10x channels, 24V)
  - [x] HMIP-FALMOT-C12 (Floor Heating Actuator – 12x channels, motorised)
  - [x] HMIP-FBL (Blind Actuator - flush-mount)
  - [x] HMIP-FCI1 (Contact Interface flush-mount – 1x channel)
  - [x] HMIP-FCI6 (Contact Interface flush-mount – 6x channels)
  - [x] HMIP-FDT (Dimming Actuator - flush-mount)
  - [x] HMIP-FROLL (Shutter Actuator - flush-mount)
  - [x] HMIP-FSI16 (Switch Actuator with Push-button Input 230V, 16A)
  - [x] HMIP-FSM (Switch Actuator and Meter 5A – flush-mount)
  - [x] HMIP-FSM16 (Switch Actuator and Meter 16A – flush-mount)
  - [ ] HMIP-FWI (Wiegand Interface)
  - [x] HMIP-HAP (Cloud Access Point)
  - [x] HMIP-HAP-B1 (Cloud Access Point) _Silvercrest Edition_
  - [x] HMIP-HDM1 (Hunter Douglas & erfal window blinds
  - [ ] HMIP-HDRC (Hunter Douglas & erfal window blinds remote control)
  - [ ] HMIP-K-DRBLI4 (Blinds Actuator – 4x channels, 230V, 2,2A / 500W per channel) electrical DIN rail
  - [ ] HMIP-K-DRSI1 (Actuator Inbound 230V – 1x channel) electrical DIN rail
  - [ ] HMIP-K-DRDI3 (Dimming Actuator Inbound 230V – 3x channels, 200W per channel) electrical DIN rail
  - [ ] HMIP-K-DRSI4 (Switch Actuator – 4x channels, 16A per channel) electrical DIN rail
  - [x] HMIP-KRCA (Key Ring Remote Control & Alarm)
  - [x] HMIP-KRC4 (Key Ring Remote Control - 4x buttons)
  - [ ] HMIP-MIO16-PCB (Multi Analog/Digitial Interface - Switch Circuit Board)
  - [x] HMIP-MIOB (Multi IO Box for floor heating & cooling)
  - [x] HMIP-MOD-HO (Garage Door Module for Hörmann)
  - [x] HMIP-MOD-OC8 (Open Collector Module Receiver - 8x)
  - [x] HMIP-MOD-RC8 (Open Collector Module Sender - 8x)
  - [x] HMIP-MOD-TM (Garage Door Module for Novoferm and Tormatic door operators)
  - [ ] HMIP-MP3P (Combination Signalling Device MP3)
  - [ ] HMIP-P-DRG-DALI (DALI Lights Gateway)
  - [x] HMIP-PCBS (Switch Circuit Board - 1x channel)
  - [x] HMIP-PCBS2 (Switch Circuit Board - 2x channels)
  - [x] HMIP-PCBS-BAT (Switch Circuit Board with Battery - 1x channel)
  - [x] HMIP-PDT (Plugable Dimmer)
  - [ ] HMIP-PDT-UK (UK Version not tested, but it should work)
  - [x] HMIP-PMFS (Plugable Power Supply Monitoring)
  - [x] HMIP-PS (Plugable Switch)
  - [ ] HMIP-PS-2 (Plugable Switch) New Version
  - [x] HMIP-PSM (Plugable Switch Measuring, Type F - Standard for Homematic)
  - [ ] HMIP-PSM-2 (Plugable Switch Measuring, Type F - Standard for Homematic) New Version
  - [x] HMIP-PSM-CH (Plugable Switch Measuring, Type J)
  - [ ] HMIP-PSM-IT (Type L not tested, but it should work)
  - [ ] HMIP-PSM-PE (Type E not tested, but it should work)
  - [ ] HMIP-PSM-UK (Type G not tested, but it should work)
  - [x] HMIP-RC8 (Remote Control - 8x buttons)
  - [ ] HMIP-RCB1 (Remote Control - 1x button)
  - [x] HMIP-RGBW (RGB Led Controller - Readonly at the moment)
  - [x] HMIP-SAM (Acceleration Sensor)
  - [x] HMIP-SCI (Contact Interface Sensor)
  - [x] HMIP-SCTH230 (CO2, Temperature and Humidity Sensor 230V)
  - [ ] HMIP-SFD (Fine Dust Sensor)
  - [x] HMIP-SLO (Light Sensor - outdoor)
  - [x] HMIP-SMI (Motion Detector with Brightness Sensor - indoor)
  - [x] HMIP-SMI55 (Motion Detector with Brightness Sensor and Remote Control - 2x buttons)
  - [ ] HMIP-SMI55-2 (Motion Detector with Brightness Sensor and Remote Control - 2x buttons) New Version
  - [x] HMIP-SMO (Motion Detector with Brightness Sensor - outdoor)
  - [ ] HMIP-SMO-2 (Motion Detector with Brightness Sensor - outdoor) New Version
  - [x] HMIP-SMO-A (Motion Detector with Brightness Sensor - outdoor, anthracite)
  - [ ] HMIP-SMO-A-2 (Motion Detector with Brightness Sensor - outdoor, anthracite) New Version
  - [x] HMIP-SPDR (Passage Sensor with Direction Recognition)
  - [x] HMIP-SPI (Presence Sensor - indoor)
  - [x] HMIP-SRH (Window Rotary Handle Sensor)
  - [x] HMIP-SRD (Rain Sensor)
  - [x] HMIP-STE2-PCB (Temperature Difference Sensors - 2x sensors)
  - [x] HMIP-STH (Temperature and Humidity Sensor without display - indoor)
  - [x] HMIP-STHD (Temperature and Humidity Sensor with display - indoor)
  - [x] HMIP-STHO (Temperature and Humidity Sensor - outdoor)
  - [x] HMIP-STHO-A (Temperature and Humidity Sensor – outdoor, anthracite)
  - [x] HMIP-STV (Inclination and vibration Sensor)
  - [x] HMIP-SWD (Water Sensor)
  - [x] HMIP-SWDM (Door / Window Contact - magnetic)
  - [ ] HMIP-SWDM-2 (Door / Window Contact - magnetic) New Version
  - [x] HMIP-SWDM-B2 (Door / Window Contact - magnetic) _Silvercrest Edition_
  - [x] HMIP-SWDO (Shutter Contact Optical)
  - [ ] HMIP-SWDO-2 (Shutter Contact Optical) New Version
  - [x] HMIP-SWDO-I (Shutter Contact Optical Invisible)
  - [x] HMIP-SWDO-PL (Shutter Contact Optical Plus)
  - [ ] HMIP-SWDO-PL-2 (Shutter Contact Optical Plus) New Version
  - [x] HMIP-SWO-B (Weather Sensor - Basic)
  - [x] HMIP-SWO-PL (Weather Sensor – Plus)
  - [x] HMIP-SWO-PR (Weather Sensor – Pro)
  - [x] HMIP-SWSD (Smoke Detector)
  - [ ] HMIP-USBSM (USB Switching Measurement Actuator)
  - [x] HMIP-WGC (Garage Door Button)
  - [x] HMIP-WHS2 (Switch Actuator for heating systems – 2x channels)
  - [ ] HMIP-WKP (Keypad)
  - [x] HMIP-WLAN-HAP (WLAN Access Point)
  - [x] HMIP-WRC2 (Wall-mount Remote Control - 2x buttons)
  - [x] HMIP-WRC6 (Wall-mount Remote Control - 6x buttons)
  - [x] HMIP-WRCC2 (Wall-mount Remote Control – flat)
  - [ ] HMIP-WRCD (Wall-mount Remote Control - E-Paper-Status display)
  - [ ] HMIP-WRCR (Wall-mount Remote Control - Rotary)
  - [ ] HMIP-WT (Wall Mounted Thermostat without adjusting wheel) #probably only prototype for WTH-B and was not released
  - [x] HMIP-WTH (Wall Mounted Thermostat Pro with Display)
  - [ ] HMIP-WTH-1 (Wall Mounted Thermostat Pro with Display _Newest Version_ - successor of WTH-2 - really)
  - [x] HMIP-WTH-2 (Wall Mounted Thermostat Pro with Display)
  - [x] HMIP-WTH-B (Wall Mounted Thermostat basic without adjusting wheel)
  - [ ] HMIP-WTH-B-2 (Wall Mounted Thermostat basic without adjusting wheel) New Version
  - [ ] HMIP-WUA (Dimming Actuator, 0-10/1-10-V-Control inputs, 8A 230V)



  - [x] HMIPW-DRAP (Homematic IP Wired Access Point)
  - [ ] HMIPW-BRC2 (Homematic IP Wired Remote Control for brand switches – 2x channels)
  - [x] HMIPW-DRBL4 (Homematic IP Wired Blinds Actuator – 4x channels)
  - [x] HMIPW-DRD3 (Homematic IP Wired Dimming Actuator – 3x channels)
  - [x] HMIPW-DRS4 (Homematic IP Wired Switch Actuator – 4x channels)
  - [ ] HMIPW-DRI16 (Homematic IP Wired Inbound module – 16x channels)
  - [x] HMIPW-DRI32 (Homematic IP Wired Inbound module – 32x channels)
  - [x] HMIPW-DRS8 (Homematic IP Wired Switch Actuator – 8x channels)
  - [ ] HMIPW-FAL24-C6 (Homematic IP Wired Floor Heating Actuator – 6x channels, 24V)
  - [ ] HMIPW-FAL24-C10 (Homematic IP Wired Floor Heating Actuator – 10x channels, 24V)
  - [ ] HMIPW-FAL230-C6 (Homematic IP Wired Floor Heating Actuator – 6x channels, 230V)
  - [ ] HMIPW-FAL230-C10 (Homematic IP Wired Floor Heating Actuator – 10x channels, 230V)
  - [x] HMIPW-FALMOT-C12 (Homematic IP Wired Floor Heating Actuator – 12x channels, motorised)
  - [x] HMIPW-FIO6 (Homematic IP Wired IO Module flush-mount – 6x channels)
  - [ ] HMIPW-SCTHD (Homematic IP Wired CO2, Temperature and Humidity Sensor with Display)
  - [x] HMIPW-SMI55 (Homematic IP Wired Motion Detector with Brightness Sensor and Remote Control - 2x buttons)
  - [ ] HMIPW-SPI (Homematic IP Wired Presence Sensor - indoor)
  - [ ] HMIPW-STH (Homematic IP Wired Temperature and Humidity Sensor without display - indoor)
  - [ ] HMIPW-STHD (Homematic IP Wired Temperature and Humidity Sensor with display - indoor)
  - [ ] HMIPW-WGD (Homematic IP Wired Wall-mount Glas Display - black edition)
  - [ ] HMIPW-WGD-PL (Homematic IP Wired Wall-mount Glas Display Play - black edition)
  - [x] HMIPW-WRC2 (Homematic IP Wired Wall-mount Remote Control - 2x channels)
  - [x] HMIPW-WRC6 (Homematic IP Wired Wall-mount Remote Control - 6x channels)
  - [ ] HMIPW-WTH (Homematic IP Wired Wall Mounted Thermostat Pro with Display)



  It’s also possible to use push notifications based on a websocket connection:

  ```python
      
      def print_events(event_list):
          for event in event_list:
              print("EventType: {} Data: {}".format(event["eventType"], event["data"]))


      
      config = homematicip.find_and_load_config_file()
      home = Home()
      home.set_auth_token(config.auth_token)
      home.init(config.access_point)

      
      home.onEvent += print_events
      home.enable_events()

      try:
          while True:
              time.sleep(1)
      except KeyboardInterrupt:
          print("Interrupt.")
  ```



  The scripts will look for a config.ini in 3
  different locations depending on your OS. Copy the file to one of these
  locations so that it will be accessible for the scripts.

  - General
    - current working directory
  - Windows
    - %APPDATA%\\homematicip-rest-api
    - %PROGRAMDATA%\\homematicip-rest-api
  - Linux
    - ~/.homematicip-rest-api/
    - /etc/homematicip-rest-api/
  - MAC OS
    - ~/Library/Preferences/homematicip-rest-api/
    - /Library/Application Support/homematicip-rest-api/


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

  The honcho-ai library provides convenient access to the Honcho 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 [docs.honcho.dev](https://docs.honcho.dev). The full API of this library can be found in [api.md](https://github.com/plastic-labs/honcho-python/tree/main/api.md).



  ```sh

  pip install honcho-ai
  ```



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

  ```python
  import os
  from honcho import Honcho

  client = Honcho(
      api_key=os.environ.get("HONCHO_API_KEY"),  # This is the default and can be omitted
      
      environment="local",
  )

  app = client.apps.create(
      name="x",
  )
  print(app.id)
  ```

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



  Simply import `AsyncHoncho` instead of `Honcho` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from honcho import AsyncHoncho

  client = AsyncHoncho(
      api_key=os.environ.get("HONCHO_API_KEY"),  # This is the default and can be omitted
      
      environment="local",
  )


  async def main() -> None:
      app = await client.apps.create(
          name="x",
      )
      print(app.id)


  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`.



  List methods in the Honcho 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 honcho import Honcho

  client = Honcho()

  all_users = []

  for user in client.apps.users.list(
      app_id="REPLACE_ME",
  ):
      
      all_users.append(user)
  print(all_users)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from honcho import AsyncHoncho

  client = AsyncHoncho()


  async def main() -> None:
      all_users = []
      
      async for user in client.apps.users.list(
          app_id="REPLACE_ME",
      ):
          all_users.append(user)
      print(all_users)


  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.apps.users.list(
      app_id="REPLACE_ME",
  )
  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.items)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.apps.users.list(
      app_id="REPLACE_ME",
  )

  print(f"page number: {first_page.page}")  # => "page number: 1"
  for user in first_page.items:
      print(user.id)


  ```



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

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

  All errors inherit from `honcho.APIError`.

  ```python
  import honcho
  from honcho import Honcho

  client = Honcho()

  try:
      client.apps.create(
          name="x",
      )
  except honcho.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except honcho.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except honcho.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 honcho import Honcho


  client = Honcho(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).apps.create(
      name="x",
  )
  ```



  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 honcho import Honcho


  client = Honcho(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).apps.create(
      name="x",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/plastic-labs/honcho-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 `HONCHO_LOG` to `info`.

  ```shell
  $ export HONCHO_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 honcho import Honcho

  client = Honcho()
  response = client.apps.with_raw_response.create(
      name="x",
  )
  print(response.headers.get('X-My-Header'))

  app = response.parse()  # get the object that `apps.create()` would have returned
  print(app.id)
  ```

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

  The async client returns an [`AsyncAPIResponse`](https://github.com/plastic-labs/honcho-python/tree/main/src/honcho/_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.apps.with_streaming_response.create(
      name="x",
  ) 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 honcho import Honcho, DefaultHttpxClient

  client = Honcho(
      
      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/plastic-labs/honcho-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 honcho
  print(honcho.__version__)
  ```



  Python 3.8 or higher.



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


pkgId: a5e69cb6127bdec0dcdf2cfae4016d41a088583277dc23e43e27b88da8f31b56
name: python-honeybee-core-help
arch: noarch
version: 1.60.6
epoch: 0
release: 1
summary: Development documents and examples for honeybee-core
url: https://github.com/ladybug-tools/honeybee-core
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-honeybee-core-1.60.6-1.src.rpm
location_href: Packages/python-honeybee-core-help-1.60.6-1.noarch.rpm
checksum_type: sha256
description:
  ![Honeybee](https://www.ladybug.tools/assets/img/honeybee.png)

  [![Build Status](https://github.com/ladybug-tools/honeybee-core/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/honeybee-core/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/honeybee-core/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/honeybee-core)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Honeybee is a collection of Python libraries to create representations of buildings
  following [honeybee-schema](https://github.com/ladybug-tools/honeybee-schema/wiki).

  This package is the core library that provides honeybee's common functionalities.
  To extend these functionalities you should install available Honeybee extensions or write
  your own.

  Here are a number of frequently used extensions for Honeybee:

  - [honeybee-radiance](https://github.com/ladybug-tools/honeybee-radiance): Adds daylight simulation to Honeybee.
  - [honeybee-energy](https://github.com/ladybug-tools/honeybee-energy): Adds Energy simulation to Honeybee.
  - [honeybee-display](https://github.com/ladybug-tools/honeybee-display): Adds VTK visualization to Honeybee.




  To install the core library use:

  `pip install -U honeybee-core`

  To check if Honeybee command line interface is installed correctly use `honeybee viz` and you
  should get a `viiiiiiiiiiiiizzzzzzzzz!` back in response! :bee:




  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/honeybee-core.git



  git clone https://github.com/ladybug-tools/honeybee-core.git
  ```
  2. Install dependencies:
  ```console
  cd honeybee-core
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest ./tests
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./honeybee
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 9de12582031dcda906f515453dc3e343dfdcabd269672273376595dd0b627a19
name: python-honeybee-energy-help
arch: noarch
version: 1.110.1
epoch: 0
release: 1
summary: Development documents and examples for honeybee-energy
url: https://github.com/ladybug-tools/honeybee-energy
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-honeybee-energy-1.110.1-1.src.rpm
location_href: Packages/python-honeybee-energy-help-1.110.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Honeybee](http://www.ladybug.tools/assets/img/honeybee.png)

  [![Build Status](https://github.com/ladybug-tools/honeybee-energy/workflows/CI/badge.svg)](https://github.com/ladybug-tools/honeybee-energy/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/honeybee-energy/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/honeybee-energy)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Honeybee extension for energy simulation.

  Honeybee-energy leverages the [EnergyPlus](https://github.com/NREL/EnergyPlus)
  simulation engine and the [OpenStudio](https://github.com/NREL/OpenStudio)
  SDK in order to add energy simulation properties and capabilities to
  [honeybee-core](https://github.com/ladybug-tools/honeybee-core). The package also
  uses the [honeybee-openstudio-gem](https://github.com/ladybug-tools/honeybee-openstudio-gem)
  to translate honeybee Models to OpenStudio format.

  All of these dependencies are contained within the [honeybee-energy Docker image](https://hub.docker.com/r/ladybugtools/honeybee-energy)

  Honeybee-energy is also used by other honeybee extensions that translate honeybee
  models to building energy simulation engines, including [honeybee-doe2](https://github.com/ladybug-tools/honeybee-doe2).



  `pip install -U honeybee-energy`

  If you want to also include the standards library of typical ProgramTypes and
  ConstructionSets use:

  `pip install -U honeybee-energy[standards]`

  To check if the command line interface is installed correctly use `honeybee-energy --help`.





  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/honeybee-energy



  git clone https://github.com/ladybug-tools/honeybee-energy
  ```
  2. Install dependencies:
  ```console
  cd honeybee-energy
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./honeybee_energy
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 1145105def70053f04ab058d062738c40399a4b83e284d6c05856984714f438a
name: python-honeybee-radiance-help
arch: noarch
version: 1.66.144
epoch: 0
release: 1
summary: Development documents and examples for honeybee-radiance
url: https://github.com/ladybug-tools/honeybee-radiance
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-honeybee-radiance-1.66.144-1.src.rpm
location_href: Packages/python-honeybee-radiance-help-1.66.144-1.noarch.rpm
checksum_type: sha256
description:
  ![Honeybee](https://www.ladybug.tools/assets/img/honeybee.png)

  [![Build Status](https://github.com/ladybug-tools/honeybee-radiance/workflows/CI/badge.svg)](https://github.com/ladybug-tools/honeybee-radiance/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/honeybee-radiance/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/honeybee-radiance)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/)
  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)
  [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/)
  [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)

  Radiance extension for honeybee.

  Honeybee-radiance adds Radiance simulation functionalities to honeybee for daylight/radiation simulation.



  `pip install -U honeybee-radiance`

  To check if the command line interface is installed correctly use `honeybee-radiance --help`.



  [API documentation](https://www.ladybug.tools/honeybee-radiance/docs/)



  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/honeybee-radiance



  git clone https://github.com/ladybug-tools/honeybee-radiance
  ```
  2. Install dependencies:
  ```console
  cd honeybee-radiance
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./honeybee_radiance
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: aa7e4fa61da82302842a07cc9d500d19b723d01ed37d5dbb1ea6c55b23bc8078
name: python-honeybee-radiance-postprocess-help
arch: noarch
version: 0.4.493
epoch: 0
release: 1
summary: Development documents and examples for honeybee-radiance-postprocess
url: https://github.com/ladybug-tools/honeybee-radiance-postprocess
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-honeybee-radiance-postprocess-0.4.493-1.src.rpm
location_href: Packages/python-honeybee-radiance-postprocess-help-0.4.493-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/ladybug-tools/honeybee-radiance-postprocess/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/honeybee-radiance-postprocess/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/honeybee-radiance-postprocess/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/honeybee-radiance-postprocess)

  [![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/)



  Library and CLI for postprocessing of Radiance results and matrices.


  ```console
  pip install honeybee-radiance-postprocess
  ```


  ```python
  import honeybee_radiance_postprocess

  ```




  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/honeybee-radiance-postprocess



  git clone https://github.com/ladybug-tools/honeybee-radiance-postprocess
  ```
  2. Install dependencies:
  ```console
  cd honeybee-radiance-postprocess
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytest tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./honeybee_radiance_postprocess
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 771db7747e2da4a5efaa2bec07a9c64f3f5422516e41aaee15db7661bfe06151
name: python-hopp-help
arch: noarch
version: 3.1
epoch: 0
release: 1
summary: Development documents and examples for hopp
url: https://pypi.org/project/hopp/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hopp-3.1-1.src.rpm
location_href: Packages/python-hopp-help-3.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/hopp.svg)](https://badge.fury.io/py/hopp)
  ![CI Tests](https://github.com/NREL/HOPP/actions/workflows/ci.yml/badge.svg)
  [![image](https://img.shields.io/pypi/pyversions/hopp.svg)](https://pypi.python.org/pypi/hopp)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)

  As part of NREL's [Hybrid Energy Systems Research](https://www.nrel.gov/wind/hybrid-energy-systems-research.html), this
  software assesses optimal designs for the deployment of utility-scale hybrid energy plants, particularly considering wind,
  solar and storage.



  - Python version 3.10, and 3.11 only (PySAM 4.2 is incompatible with 3.12)



  1. HOPP is available as a PyPi package:

      ```bash
      pip install HOPP
      ```



  1. Using Git, navigate to a local target directory and clone repository:

      ```bash
      git clone https://github.com/NREL/HOPP.git
      ```

  2. Navigate to `HOPP`

      ```bash
      cd HOPP
      ```

  3. Create a new virtual environment and change to it. Using Conda and naming it 'hopp':

      ```bash
      conda create --name hopp python=3.11 -y
      conda activate hopp
      ```

  4. Install HOPP and its dependencies:

      ```bash
      conda install -y -c conda-forge coin-or-cbc=2.10.8 glpk
      ```

      Note if you are on Windows, you will have to manually install Cbc: https://github.com/coin-or/Cbc.

      - If you want to just use HOPP:

         ```bash
         pip install .
         ```

      - If you want to work with the examples:

         ```bash
         pip install ".[examples]"
         ```

      - If you also want development dependencies for running tests and building docs:

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

  5. The functions which download resource data require an NREL API key. Obtain a key from:

      [https://developer.nrel.gov/signup/](https://developer.nrel.gov/signup/)

  6. To set up the `NREL_API_KEY` and `NREL_API_EMAIL` required for resource downloads, you can create Environment Variables called `NREL_API_KEY` and `NREL_API_EMAIL`. Otherwise, you can keep the key in a new file called ".env" in the root directory of this project.

      Create a file ".env" that contains the single line:

      ```bash
      NREL_API_KEY=key
      NREL_API_EMAIL=your.name@email.com
      ```

  7. Verify setup by running tests:

      ```bash
      pytest tests/hopp
      ```

  8. To set up `NREL_API_KEY` for resource downloads, first refer to section 6 and 7 above. But for the `.env` file method,
     the file should go in the working directory of your Python project, e.g. directory from where you run `python`.



  The [Examples](./examples/) contain Jupyter notebooks and sample YAML files for common usage scenarios in HOPP. These are actively maintained and updated to demonstrate HOPP's capabilities. For full details on simulation options and other features, see the [documentation](https://hopp.readthedocs.io/en/latest/).



  Interested in improving HOPP? Please see the [Contributing](./CONTRIBUTING.md) section for more information.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2024, Alliance for Sustainable Energy, LLC All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * 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 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: f6b54ce754d3711a81e676fcac718fdd64b2ba9ddba39c3ad8e14d1ea222be89
name: python-horiba-sdk-help
arch: noarch
version: 0.5.4
epoch: 0
release: 1
summary: Development documents and examples for horiba-sdk
url: https://github.com/ThatsTheEnd/horiba-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-horiba-sdk-0.5.4-1.src.rpm
location_href: Packages/python-horiba-sdk-help-0.5.4-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  [![build](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/actions/workflows/build.yml/badge.svg)](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/actions/workflows/build.yml)
  [![PyPI - Version](https://img.shields.io/pypi/v/horiba-sdk)](https://pypi.org/project/horiba-sdk/)
  [![Python Version](https://img.shields.io/pypi/pyversions/horiba-sdk.svg)](https://pypi.org/project/horiba-sdk/)
  [![Dependencies Status](https://img.shields.io/badge/dependencies-up%20to%20date-brightgreen.svg)](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/pulls?utf8=%E2%9C%93&q=is%3Apr%20author%3Aapp%2Fdependabot)

  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Security: bandit](https://img.shields.io/badge/security-bandit-green.svg)](https://github.com/PyCQA/bandit)
  [![Pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/blob/master/.pre-commit-config.yaml)
  [![Semantic Versions](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--versions-e10079.svg)](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/releases)
  [![License](https://img.shields.io/github/license/HORIBAEzSpecSDK/horiba-python-sdk)](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/blob/master/LICENSE)
  ![Coverage Report](assets/images/coverage.svg)
  [![Documentation Status](https://readthedocs.org/projects/horiba-python-sdk/badge/?version=latest)](https://horiba-python-sdk.readthedocs.io/en/latest/?badge=latest)


  </div>

  ___

  ⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️

  > [!WARNING]
  > This SDK is under development and not yet released.

  > [!IMPORTANT]
  > For this python code to work, the SDK from Horiba has to be purchased, installed and licensed.
  > The code in this repo and the SDK are under development and not yet released for public use!

  ⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️⬆️

  ___


  `horiba-sdk` is a package that provides source code for the development of custom applications that include interaction with Horiba devices, namely monochromators and multichannel detectors (e.g. CCD cameras).
  Future versions of this package will include access to more devices. The SDK exists for several programming languages:
  - Python (this repo)
  - [C#](https://github.com/HORIBAEzSpecSDK/dotnet-sdk)
  - [C++](https://github.com/HORIBAEzSpecSDK/cpp-sdk)
  - [LabVIEW](https://github.com/HORIBAEzSpecSDK/labview-sdk)



  To use this package, the following conditions must be met:
  * Python `>=3.9` is installed
  * ICL.exe installed as part of the `Horiba SDK`, licensed and activated. The Horiba SDK can be purchased by contacting the [Horiba Support](https://www.horiba.com/int/scientific/contact/) and sending a message to the `Scientific` business segment, specifying `no division` and selecting the `sales` department
  *
    <details>
    <summary>To make sure that the USB devices do not get disconnected, uncheck the following boxes in the properties</summary>

    ![generic usb hub properties](docs/source/images/generic_usb_hub_properties.png)

    </details>



  <details>
  <summary>Video of the steps below</summary>

  ![first steps in python](docs/source/images/python_first_steps.gif)

  </details>

  1. (Optional but recommended) Work in a virtual environment:

     Navigate to the (empty) project folder you want to work and run:

     ```bash
     python -m venv .
     ```

     Activate the virtual environment:

     <details>
     <summary>Windows</summary>

     ```powershell
     .\Scripts\activate
     ```
     </details>

     <details>
     <summary>Unix</summary>

     ```bash
     source ./bin/activate
     ```
     </details>

     *Note: do deactivate it, simply run `deactivate`.*


  1. Install the sdk:

     ```bash
     pip install horiba-sdk
     ```

     or install with `Poetry`

     ```bash
     poetry add horiba-sdk
     ```

  2. Create a file named `center_scan.py` and copy-paste the content of
     [`examples/asynchronous_examples/center_scan.py`](examples/asynchronous_examples/center_scan.py)

  3. Install the required library for plotting the graph in the example:

     ```bash
     pip install matplotlib
     ```

     or install with `Poetry`

     ```bash
     poetry add matplotlib
     ```

  4. Run the example with:

     ```bash
     python center_scan.py
     ```


  The files in the folder [examples/asynchronous_examples/](examples/asynchronous_examples) can be used as a starting point for a custom application.


  The files in the folder [tests/test_single_devices](tests/test_single_devices) can be used to explore further functionality.


  This SDK is based on Websocket communication. The nature of this communication is asynchronous by its design.
  The way this SDK uses websockets is to send requests to the underlying `instrument control layer (ICL)` and get a (nearly immediate) reply back.
  This is true even for commands that longer to execute, e.g. to move the mono or to acquire data from the CCD. The way this is handled is by sending an acknowledgement back that the command is received and being processed. The user has then to inquire if `mono_isBusy` to see when the hardware is free to receive the next command.
  That means that every `async` function can be `awaited` immediately and handled just like any other function.
  To learn more about async and await, [check out this introduction](https://www.pythontutorial.net/python-concurrency/python-async-await/) or [take a deeper dive here](https://medium.com/@danielwume/an-in-depth-guide-to-asyncio-and-await-in-python-059c3ecc9d96).




  The functionality is distributed over two parts, the `instrument control layer (ICL)` and the `github source code`. This split is shown in the following image:
  ![SDK Split](docs/SDK_Overview_Dark.png#gh-dark-mode-only "SDK Split")
  ![SDK Split](docs/SDK_Overview_Dark.png#gh-light-mode-only "SDK Split")

  The ICL itself is sold and distributed by Horiba. The source code to communicate with the ICL and drive the instruments is located in this repo for Python, but can be also found for C#, C++ and LabVIEW as described above.
  The communication between SDK and ICL is websocket based. I.e. in essence the ICL is steered by a `command and control` pattern where commands and their replies are JSON commands.





  1. Clone the repo:

    ```bash
    git clone https://github.com/HORIBAEzSpecSDK/horiba-python-sdk.git
    cd horiba-python-sdk
    ```

  2. If you don't have `Poetry` installed run:

  ```bash
  make poetry-download
  ```

  3. Initialize poetry and install `pre-commit` hooks:

  ```bash
  make install
  make pre-commit-install
  ```

  4. Run the codestyle:

  ```bash
  make codestyle
  ```

  5. To push local changes to the remote repository, run:

  ```bash
  git add .
  git commit -m "feat: add new feature xyz"
  git push
  ```

  <!-- ### Set up bots -->

  <!-- - Set up [Dependabot](https://docs.github.com/en/github/administering-a-repository/enabling-and-disabling-version-updates#enabling-github-dependabot-version-updates) to ensure you have the latest dependencies. -->
  <!-- - Set up [Stale bot](https://github.com/apps/stale) for automatic issue closing. -->



  Want to know more about Poetry? Check [its documentation](https://python-poetry.org/docs/).

  <details>
  <summary>Details about Poetry</summary>
  <p>

  Poetry's [commands](https://python-poetry.org/docs/cli/#commands) are very intuitive and easy to learn, like:

  - `poetry add numpy@latest`
  - `poetry run pytest`
  - `poetry publish --build`

  etc
  </p>
  </details>



  Building a new version of the application contains steps:

  - Bump the version of your package `poetry version <version>`. You can pass the new version explicitly, or a rule such as `major`, `minor`, or `patch`. For more details, refer to the [Semantic Versions](https://semver.org/) standard.
  - Update the `CHANGELOG.md` with `git-changelog -B auto -Tio CHANGELOG.md`
  - Make a commit to `GitHub`.
  - Create a tag and push it. The release is automatically triggered on tag push:

    ```bash
    git tag vX.Y.Z # where the version MUST match the one you indicated before
    git push --tags
    ```



  [`Makefile`](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/blob/master/Makefile) contains a lot of functions for faster development.

  <details>
  <summary>1. Installation of Poetry</summary>
  <p>

  To download and install Poetry run:

  ```bash
  make poetry-download
  ```

  To uninstall

  ```bash
  make poetry-remove
  ```

  </p>
  </details>

  <details>
  <summary>2. Install all dependencies and pre-commit hooks</summary>
  <p>

  Install requirements:

  ```bash
  make install
  ```

  Pre-commit hooks could be installed after `git init` via

  ```bash
  make pre-commit-install
  ```

  </p>
  </details>

  <details>
  <summary>3. Codestyle</summary>
  <p>

  Automatic formatting uses `pyupgrade`, `isort` and `black`.

  ```bash
  make codestyle


  make formatting
  ```

  Codestyle checks only, without rewriting files:

  ```bash
  make check-codestyle
  ```

  > Note: `check-codestyle` uses `isort`, `black` and `darglint` library

  Update all dev libraries to the latest version using one comand

  ```bash
  make update-dev-deps
  ```
  </p>
  </details>

  <details>
  <summary>4. Code security</summary>
  <p>

  ```bash
  make check-safety
  ```

  This command launches `Poetry` integrity checks as well as identifies security issues with `Safety` and `Bandit`.

  ```bash
  make check-safety
  ```


  </p>
  </details>

  <details>
  <summary>5. Type checks</summary>
  <p>

  Run `mypy` static type checker

  ```bash
  make mypy
  ```

  </p>
  </details>

  <details>
  <summary>6. Tests with coverage badges</summary>
  <p>

  Run `pytest`

  Unix:

  ```bash
  make test
  ```

  Windows:

  ```powershell
  poetry run pytest -c pyproject.toml --cov-report=html --cov=horiba_sdk tests/
  ```

  For the hardware tests run the following:

  Windows:

  ```powershell
  $env:HAS_HARDWARE="true"



  poetry run pytest -c pyproject.toml --cov-report=html --cov=horiba_sdk tests/
  ```

  Unix:

  ```bash
  HAS_HARDWARE="true"



  make test
  ```

  </p>
  </details>

  <details>
  <summary>7. All linters</summary>
  <p>

  Of course there is a command to ~~rule~~ run all linters in one:

  ```bash
  make lint
  ```

  the same as:

  ```bash
  make test
  make check-codestyle
  make mypy
  make check-safety
  ```

  </p>
  </details>

  <details>
  <summary>8. Docker</summary>
  <p>

  ```bash
  make docker-build
  ```

  which is equivalent to:

  ```bash
  make docker-build VERSION=latest
  ```

  Remove docker image with

  ```bash
  make docker-remove
  ```

  More information [about docker](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/tree/master/docker).

  </p>
  </details>

  <details>
  <summary>9. Cleanup</summary>
  <p>
  Delete pycache files

  ```bash
  make pycache-remove
  ```

  Remove package build

  ```bash
  make build-remove
  ```

  Delete .DS_STORE files

  ```bash
  make dsstore-remove
  ```

  Remove .mypycache

  ```bash
  make mypycache-remove
  ```

  Or to remove all above run:

  ```bash
  make cleanup
  ```
  </p>
  </details>



  The latest documentation can be found at
  [horiba-python-sdk.readthedocs.io](https://horiba-python-sdk.readthedocs.io/en/latest/).
  In order to build it locally, run the following in the `docs/` folder:

  ```bash
  make html
  ```

  The documentation will then be built under `docs/build/html/`.

  Documentation is built each time a commit is pushed on `main` or for pull
  requests. When release tags are created in the repo, readthedocs will also tag
  the documentation accordingly




  [![License](https://img.shields.io/github/license/HORIBAEzSpecSDK/horiba-python-sdk)](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/blob/master/LICENSE)

  This project is licensed under the terms of the `MIT` license. See [LICENSE](https://github.com/HORIBAEzSpecSDK/horiba-python-sdk/blob/master/LICENSE) for more details.



  ```bibtex
  @misc{horiba-python-sdk,
    author = {ZühlkeEngineering},
    title = {'horiba-python-sdk' is a package that provides source code for the development with Horiba devices},
    year = {2023},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/HORIBAEzSpecSDK/horiba-python-sdk}}
  }
  ```




  This project was generated with [`python-package-template`](https://github.com/TezRomacH/python-package-template)


pkgId: 095c46838fe30ce4147606adfd9c9b3f44d84f50982087c2c73b63a24c468042
name: python-hot_restart-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for hot_restart
url: https://pypi.org/project/hot_restart/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hot_restart-0.2.2-1.src.rpm
location_href: Packages/python-hot_restart-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  Restart debugging your program in the function that failed.

  Installation:
  ```
  pip install hot_restart
  ```

  `hot_restart` currently has no required dependencies outside the standard library.
  If `pydevd` is already imported, `hot_restart` will use it to allow debugging
  in VS Code (and other IDEs using `pydevd` / `debugpy`).



  Wrap any function you expect to crash in `@hot_restart.wrap`:

  ```python
  import hot_restart

  @hot_restart.wrap
  def my_func():
      ...

  @hot_restart.wrap_class
  class MyClass:

      def forward(self, x):
          super().forward(x * 2)
  ```

  Alternatively, call `hot_restart.wrap_module()` after your functions and
  classes are defined.

  When a wrapped function crashes, hot_restart will open a post mortem debugger
  in the wrapped function, with the rest of the stack still live above that
  function call.

  Then you can modify the source code of your crashing function, and (c)ontinue
  from the debugger, and hot_restart will reload the source of that function (and
  only that function).

  You can use `@hot_restart.no_wrap` to indicate that a function or class should
  not be wrapped.

  `hot_restart` uses AST transformations to find new definitions, to avoid
  causing "import-time" side effects, and to match line numbers with the real
  source code while keeping each version of a function (except the initial load)
  in its own source file.



  You can also trigger a full module reload with `hot_restart.reload_module()`.
  This may trigger "import-time" side effects and duplicate (i.e. conflicting)
  class definitions. To avoid restarting your main function when reloading your
  main module, check `hot_restart.is_restarting_module()`.

  `hot_restart` uses source re-writing to handle the common cases, and does not
  patch the byte-code of functions.
  This limits `hot_restart` from handling adding new variables to a closure or
  adding methods to existing class instances, but simplifies the implementation.


  `hot_restart` generates a surrogate source file to compile.
  This avoids import-time side effects on reload, but means that line numbers may
  become slightly different than the source on disk.
  When using pdb, by default the source of the reloaded file will be set to the surrogate source file, ensuring that line numbers in pdb match the executed code.
  In other debuggers (or when `hot_restart.DEBUG_ORIGINAL_PATH_RELOADED_CODE` is
  True), the original source will be used.
  This may result in line numbers in the executed code not matching line numbers in the debugger.



  hot_restart rewrites `super()` into `super(<classname>, <first argument>)` in
  reloaded source (original source is loaded intact). This prevents methods from
  acquiring a closure variable `__class__`, which would break in many cases, but
  slightly changes lookup behavior if the class is redefined.



  `hot_restart` will patch in old closure variables into newly defined functions,
  as long as `hot_restart.wrap` is the innermost decorator. However, functions
  cannot add new closure variables without a full module reload. Functions can
  still gain new arguments.

  For nested functions, `hot_restart.wrap_module()` cannot find the inner
  function, so `hot_restart.wrap()` must be used manually.

  If `hot_restart.wrap` is not the inner-most decorator, then closure variables
  will be lost.




  If you just want more complete hot reloading (for example, the ability to add
  new methods to existing instances of classes), you should consider
  [jurigged](https://github.com/breuleux/jurigged). You should also be able to
  use `jurigged` with `hot_restart`. If you want to use `jurigged`'s code
  reloading with `hot_restart`'s function restarting, you can disable
  `hot_restart`'s automatic code reloading by setting:

  ```
  hot_restart.RELOAD_ON_CONTINUE = False
  ```

  This module implements a workflow similar to "edit-and-continue".
  If you're looking for a more maximalist implementation of this workflow with IDE integration, you may be interested in [Reloadium](https://reloadium.io/).

  Although these useful alternatives exist, I created `hot_restart` because
  I found it difficult to debug failures in those systems.
  `hot_restart` intentionally implements a more minimal set of reloading routines
  that I can easily wrap my head around.


pkgId: 1005b3f2e31b3f54234c936a7f125beb23fd6e52a499cdb429f8966203cbc6ef
name: python-howso-engine-help
arch: noarch
version: 32.1.0
epoch: 0
release: 1
summary: Development documents and examples for howso-engine
url: https://pypi.org/project/howso-engine/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-howso-engine-32.1.0-1.src.rpm
location_href: Packages/python-howso-engine-help-32.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="left">
  <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://cdn.howso.com/img/howso/1/svg/logo-gradient-light.svg" width="33%">
   <source media="(prefers-color-scheme: light)" srcset="https://cdn.howso.com/img/howso/1/svg/logo-gradient-dark.svg" width="33%">
   <img alt="Howso" src="https://cdn.howso.com/img/howso/1/png/logo-gradient-light-bg.png" width="33%">
  </picture>
  </div>

  The Howso Engine&trade; is a natively and fully explainable ML engine, serving as an alternative to black box AI neural networks. Its core functionality gives users data exploration and machine learning capabilities through the creation and use of Trainees that help users store, explore, and analyze the relationships in their data, as well as make understandable, debuggable predictions. Howso leverages an instance-based learning approach with strong ties to the [k-nearest neighbors algorithm](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm) and [information theory](https://en.wikipedia.org/wiki/Information_theory) to scale for real world applications.

  At the core of Howso is the concept of a Trainee, a collection of data elements that comprise knowledge. In traditional ML, this is typically referred to as a model, but a Trainee is original training data coupled with metadata, parameters, details of feature attributes, with data lineage and provenance. Unlike traditional ML, Trainees are designed to be versatile so that after a single training instance (no re-training required!), they can:

  - Perform **classification** on any target feature using any set of input features
  - Perform **regression** on any target feature using any set of input features
  - Perform **online and reinforcement learning**
  - Perform **anomaly detection** based on any set of features
  - Measure **feature importance** for predicting any target feature
  - Identify **counterfactuals**
  - Understand **increases and decreases in accuracy** for features and individual cases
  - **Forecast** time series
  - **Synthesize** data that maintains the same feature relationships of the original data while maintaining privacy
  - **And more!**

  Furthermore, Trainees are auditable, debuggable, and editable.

  - **Debuggable**: Every prediction of a Trainee can be drilled down to investigate which cases from the training data were used to make the prediction.
  - **Auditable**: Trainees manage metadata about themselves including: when data is trained, when training data is edited, when data is removed, etc.
  - **Editable**: Specific cases of training data can be removed, edited, and emphasized (through case weighting) without the need to retrain.



  - [Documentation](https://docs.howso.com)
  - [Howso Engine Recipes (sample notebooks)](https://github.com/howsoai/howso-engine-recipes)
  - [Howso Playground](https://playground.howso.com)



  This Repo provides the Python interface with
  [Howso Engine](https://github.com/howsoai/howso-engine) that exposes the Howso
  Engine functionality. The Client objects directly interface with the engine API
  endpoints while the Trainee objects provides the python functionality for
  general users. Client functions may be called by the user but for most workflows
  the Trainee functionality is sufficient. Each Trainee represents an individual
  Machine Learning object or model that can perform functions like training and
  predicting, while a client may manage the API interface for multiple Trainees.



  Compatible with Python versions: 3.9, 3.10, 3.11, and 3.12.

  **Operating Systems**

  | OS      | x86_64 | arm64 |
  | ------- | ------ | ----- |
  | Windows | Yes    | No    |
  | Linux   | Yes    | Yes   |
  | MacOS   | Yes    | Yes   |



  To install the current release:

  ```bash
  pip install howso-engine
  ```

  You can verify your installation is working by running the following command in
  your python environment terminal:

  ```bash
  verify_howso_install
  ```

  See the Howso Engine
  [Install Guide](https://docs.howso.com/getting_started/installing.html) for
  additional help and troubleshooting information.



  The Howso Engine is designed to support users in the pursuit of many different
  machine learning tasks using Python.

  Below is a very high-level set of steps recommended for using the Howso Engine:

  1. Define the feature attributes of the data (Feature types, bounds, etc.)
  2. Create a Trainee and set the feature attributes
  3. Train the Trainee with the data
  4. Call Analyze on the Trainee to find optimal hyperparameters
  5. Explore your data!

  Once the Trainee has been given feature attributes, trained, and analyzed, then
  the Trainee is ready to be used for all supported machine learning tasks. At
  this point one could start making predictions on unseen data, investigate the
  most noisy features, find the most anomalous training cases, and much more.

  Please see the [User Guide](https://docs.howso.com/en/release-latest/user_guide/index.html) for
  basic workflows as well as additional information about:

  - Anomaly detection
  - Classification
  - Regression
  - Time-series forecasting
  - Feature importance analysis
  - Reinforcement learning
  - Data synthesis
  - Prediction auditing
  - Measuring model performance (global or conditional)
  - Bias mitigation
  - Trainee editing
  - ID-based privacy

  There is also a set of basic [Jupyter notebooks](https://jupyter.org/) to run
  that provides a
  [complete set of examples](https://docs.howso.com/examples/index.html) of how
  to use Howso Engine.



  [License](LICENSE.txt)



  [Contributing](CONTRIBUTING.md)

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


pkgId: 8772a459f056dcb432eee5e6692a3365acd8e87ace9f1f870b991bd70e39ff85
name: python-howso-visuals-help
arch: noarch
version: 1.4.13
epoch: 0
release: 1
summary: Development documents and examples for howso-visuals
url: https://pypi.org/project/howso-visuals/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-howso-visuals-1.4.13-1.src.rpm
location_href: Packages/python-howso-visuals-help-1.4.13-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains several utility functions for plotting data that are both input to and output from
  [Howso Engine](https://github.com/howsoai/howso-engine). In particular, highlighting:

  - Model drift
  - Feature importances
  - Interpretable predictions
  - Entire datasets



  Simply install with pip:

  ```.bash
  python -m pip install howso-visuals
  ```

  Or, to install for development, clone this repository and install it editably:

  ```.bash
  git clone github.com/howsoai/howso-visuals
  cd howso-visuals
  python -m pip install -e .[dev]
  ```



  [License](LICENSE.txt)



  [Contributing](CONTRIBUTING.md)

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


pkgId: 315a98dd68270107f24983bff5c27fdec8abc208e0627837b9812b0be1a7a770
name: python-hox-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for hox
url: https://github.com/usedToBeTomas/hox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hox-1.2.0-1.src.rpm
location_href: Packages/python-hox-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  from hox import *
  import utils

  model = Model.create([Layer(784, 144, Relu()), Layer(144, 10, Sigmoid())])

  X, Y, x, y = utils.mnist()

  indices = np.random.permutation(len(X))
  X, Y = X[indices], Y[indices]

  model.train(X, Y, epochs = 1, rate = 2, batch_size = 16)

  model.save("mnist")
  ```

  ```python
  from hox import *
  import utils

  model = Model.load("mnist")

  X, Y, x, y = utils.mnist()

  counter = 0
  for i in range(len(x)):
      if np.argmax(model.forward(x[i])) == y[i]:
          counter +=1
  print(str((counter*100)/len(y)) + "% accuracy")
  ```


pkgId: c1613213d764e45eff1ee2f22578af56182d3ef1b1ce387200d64ce1b67219c8
name: python-hpcflow-new2-help
arch: noarch
version: 0.2.0a190
epoch: 0
release: 1
summary: Development documents and examples for hpcflow-new2
url: https://pypi.org/project/hpcflow-new2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hpcflow-new2-0.2.0a190-1.src.rpm
location_href: Packages/python-hpcflow-new2-help-0.2.0a190-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://hpcflow.github.io/docs/stable/_static/images/logo-v2.png" width="250" alt="hpcFlow logo"/>
  </div>



  ![PyPI - Version](https://img.shields.io/pypi/v/hpcflow-new2) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hpcflow-new2)

  **hpcFlow manages your scientific workflows**

  Documentation: [https://hpcflow.github.io/docs](https://hpcflow.github.io/docs)



  hpcFlow development is funded by [UKAEA](https://www.gov.uk/government/organisations/uk-atomic-energy-authority), and was initially developed using funding from the [LightForm](https://lightform.org.uk/) EPSRC programme grant ([EP/R001715/1](https://gow.epsrc.ukri.org/NGBOViewGrant.aspx?GrantRef=EP/R001715/1)).

  <img src="docs/source/_static/images/UKAEA_logo.png" width="90"/>
  <br/><br/>
  <img src="https://lightform-group.github.io/wiki/assets/images/site/lightform-logo.png" width="150"/>


pkgId: 27226727e7306fa3d004594e71e9e6e5c89f3c246529766a16cc4abcb0bef345
name: python-hra_jupyter_widgets-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for hra_jupyter_widgets
url: https://github.com/x-atlas-consortia/hra-jupyter-widgets
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hra_jupyter_widgets-0.4.1-1.src.rpm
location_href: Packages/python-hra_jupyter_widgets-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  - [hra\_jupyter\_widgets](#hra_jupyter_widgets)
    - [Table of Contents](#table-of-contents)
    - [Installation](#installation)
    - [Usage](#usage)
    - [Development installation](#development-installation)

  ```sh
  pip install hra_jupyter_widgets
  ```

  HRA Jupyter Widgets are designed to be used from python notebooks. See [usage.ipynb](usage.ipynb) for examples on how to use them from notebooks. You can also open it directly from colab here:
  <a target="_blank" href="https://colab.research.google.com/github/x-atlas-consortia/hra-jupyter-widgets/blob/main/usage.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>

  Create a virtual environment and and install hra_jupyter_widgets in *editable* mode with the
  optional development dependencies:
  ```sh
  python -m venv .venv
  source .venv/bin/activate
  pip install -e ".[dev]"
  ```
  Open [usage.ipynb](usage.ipynb) in JupyterLab, VS Code, or your favorite editor
  to start developing. Changes made in `src/hra_jupyter_widgets/static/` will be reflected
  in the notebook.


pkgId: bdae9ed6d00c16704b1d4f3e6b579145d45101b6337931fa6036b4dacd0c3979
name: python-hsfs-help
arch: noarch
version: 3.7.9
epoch: 0
release: 1
summary: Development documents and examples for hsfs
url: https://github.com/logicalclocks/feature-store-api
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hsfs-3.7.9-1.src.rpm
location_href: Packages/python-hsfs-help-3.7.9-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://community.hopsworks.ai"><img
      src="https://img.shields.io/discourse/users?label=Hopsworks%20Community&server=https%3A%2F%2Fcommunity.hopsworks.ai"
      alt="Hopsworks Community"
    /></a>
      <a href="https://docs.hopsworks.ai"><img
      src="https://img.shields.io/badge/docs-HSFS-orange"
      alt="Hopsworks Feature Store Documentation"
    /></a>
    <a href="https://pypi.org/project/hsfs/"><img
      src="https://img.shields.io/pypi/v/hsfs?color=blue"
      alt="PyPiStatus"
    /></a>
    <a href="https://archiva.hops.works/#artifact/com.logicalclocks/hsfs"><img
      src="https://img.shields.io/badge/java-HSFS-green"
      alt="Scala/Java Artifacts"
    /></a>
    <a href="https://pepy.tech/project/hsfs/month"><img
      src="https://pepy.tech/badge/hsfs/month"
      alt="Downloads"
    /></a>
    <a href="https://github.com/psf/black"><img
      src="https://img.shields.io/badge/code%20style-black-000000.svg"
      alt="CodeStyle"
    /></a>
    <a><img
      src="https://img.shields.io/pypi/l/hsfs?color=green"
      alt="License"
    /></a>
  </p>

  HSFS is the library to interact with the Hopsworks Feature Store. The library makes creating new features, feature groups and training datasets easy.

  The library is environment independent and can be used in two modes:

  - Spark mode: For data engineering jobs that create and write features into the feature store or generate training datasets. It requires a Spark environment such as the one provided in the Hopsworks platform or Databricks. In Spark mode, HSFS provides bindings both for Python and JVM languages.

  - Python mode: For data science jobs to explore the features available in the feature store, generate training datasets and feed them in a training pipeline. Python mode requires just a Python interpreter and can be used both in Hopsworks from Python Jobs/Jupyter Kernels, Amazon SageMaker or KubeFlow.

  The library automatically configures itself based on the environment it is run.
  However, to connect from an external environment such as Databricks or AWS Sagemaker,
  additional connection information, such as host and port, is required. For more information about the setup from external environments, see the setup section.



  Instantiate a connection and get the project feature store handler
  ```python
  import hsfs

  connection = hsfs.connection()
  fs = connection.get_feature_store()
  ```

  Create a new feature group
  ```python
  fg = fs.create_feature_group("rain",
                          version=1,
                          description="Rain features",
                          primary_key=['date', 'location_id'],
                          online_enabled=True)

  fg.save(dataframe)
  ```

  Upsert new data in to the feature group with `time_travel_format="HUDI"`".
  ```python
  fg.insert(upsert_df)
  ```

  Retrieve commit timeline metdata of the feature group with `time_travel_format="HUDI"`".
  ```python
  fg.commit_details()
  ```

  "Reading feature group as of specific point in time".
  ```python
  fg = fs.get_feature_group("rain", 1)
  fg.read("2020-10-20 07:34:11").show()
  ```

  Read updates  that occurred between specified points in time.
  ```python
  fg = fs.get_feature_group("rain", 1)
  fg.read_changes("2020-10-20 07:31:38", "2020-10-20 07:34:11").show()
  ```

  Join features together
  ```python
  feature_join = rain_fg.select_all()
                      .join(temperature_fg.select_all(), on=["date", "location_id"])
                      .join(location_fg.select_all())
  feature_join.show(5)
  ```

  join feature groups that correspond to specific point in time
  ```python
  feature_join = rain_fg.select_all()
                      .join(temperature_fg.select_all(), on=["date", "location_id"])
                      .join(location_fg.select_all())
                      .as_of("2020-10-31")
  feature_join.show(5)
  ```

  join feature groups that correspond to different time
  ```python
  rain_fg_q = rain_fg.select_all().as_of("2020-10-20 07:41:43")
  temperature_fg_q = temperature_fg.select_all().as_of("2020-10-20 07:32:33")
  location_fg_q = location_fg.select_all().as_of("2020-10-20 07:33:08")
  joined_features_q = rain_fg_q.join(temperature_fg_q).join(location_fg_q)
  ```

  Use the query object to create a training dataset:
  ```python
  td = fs.create_training_dataset("rain_dataset",
                                  version=1,
                                  data_format="tfrecords",
                                  description="A test training dataset saved in TfRecords format",
                                  splits={'train': 0.7, 'test': 0.2, 'validate': 0.1})

  td.save(feature_join)
  ```

  A short introduction to the Scala API:
  ```scala
  import com.logicalclocks.hsfs._
  val connection = HopsworksConnection.builder().build()
  val fs = connection.getFeatureStore();
  val attendances_features_fg = fs.getFeatureGroup("games_features", 1);
  attendances_features_fg.show(1)
  ```

  You can find more examples on how to use the library in our [hops-examples](https://github.com/logicalclocks/hops-examples) repository.



  Usage data is collected for improving quality of the library. It is turned on by default if the backend
  is "c.app.hopsworks.ai". To turn it off, use one of the following way:
  ```python

  import os
  os.environ["ENABLE_HOPSWORKS_USAGE"] = "false"


  import hsfs
  hsfs.disable_usage_logging()
  ```

  The source code can be found in python/hsfs/usage.py.



  Documentation is available at [Hopsworks Feature Store Documentation](https://docs.hopsworks.ai/).



  For general questions about the usage of Hopsworks and the Feature Store please open a topic on [Hopsworks Community](https://community.hopsworks.ai/).

  Please report any issue using [Github issue tracking](https://github.com/logicalclocks/feature-store-api/issues).




  If you would like to contribute to this library, please see the [Contribution Guidelines](CONTRIBUTING.md).


pkgId: f55fb1a6393b032431a6f773ee682d986fe1a76815ccfd055d266a20be9a8291
name: python-html-telegraph-poster-v2-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for html-telegraph-poster-v2
url: https://pypi.org/project/html-telegraph-poster-v2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-html-telegraph-poster-v2-0.2.1-1.src.rpm
location_href: Packages/python-html-telegraph-poster-v2-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  [![build](https://github.com/mercuree/html-telegraph-poster/actions/workflows/python-package.yml/badge.svg)](https://github.com/mercuree/html-telegraph-poster/actions/workflows/python-package.yml)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/html-telegraph-poster?master)](https://pypi.org/project/html-telegraph-poster/)



  Forked from [html-telegraph-poster](https://github.com/mercuree/html-telegraph-poster) by [mercuree](https://github.com/mercuree/).

  Added async support and fixed some bugs (Because my projects need it). New features will be added soon.

  Simple python function to post plain html text to https://telegra.ph/.
  Telegra.ph allows `<a>, <blockquote>, <br>, <em>, <figure>, <h3>, <h4>, <img>, <p>, <strong>, ` elements.
  It also supports embedded youtube and vimeo iframe tags.

  About telegram telegra.ph service https://telegram.org/blog/instant-view


  ```Shell
  pip install html-telegraph-poster-v2
  ```



  ```python
  >> > from html_telegraph_poster_v2 import TelegraphPoster
  >> > t = TelegraphPoster(use_api=True)
  >> > t.create_api_token('Elon Musk', 'Elon', 'https://www.spacex.com/')  # second and third params are optional
  {'access_token': '9f3bab568f*************', 'auth_url': 'https://edit.telegra.ph/auth/HFYo***********',
   'author_name': 'Elon', 'short_name': 'Elon Musk', 'author_url': 'https://www.spacex.com/'}
  >> > t.post(title='Just another funny joke', author='by me', text='<blockquote>Really hard way</blockquote>')
  {'path': 'Just-another-funny-joke-06-05-4', 'url': 'http://telegra.ph/Just-another-funny-joke-06-05-4'}
  ```

  ```python
  >>> t = TelegraphPoster(use_api=True, telegraph_api_url='https://api.graph.org')
  ```

  ```python
  >>> t.edit(text=t.text + '<p>some text at the end</p>')
  {'path': 'Just-another-funny-joke-06-05-4', 'url': 'http://telegra.ph/Just-another-funny-joke-06-05-4'}
  ```

  ```python
  >>> t.edit(text="<p>new text</p>", path='/Another-one-page-06-05')
  {'path': 'Another-one-page-06-05', 'url': 'http://telegra.ph/Another-one-page-06-05'}
  ```


  Actually it's a good idea to generate access token and put it inside environment variables.
  This command will generate .env file or append  TELEGRAPH_ACCESS_TOKEN at the end of it.
  Note: script will not set environment variable. You can use [python-dotenv](https://github.com/theskumar/python-dotenv),
  set it manually or hardcode it when call `TelegraphPoster(access_token='access_token_string')`
  ```Shell
  python -m html_telegraph_poster_v2.create_account "Elon Musk" "Elon" "https://www.spacex.com/"
  ```



  Since telegra.ph is not support media uploading anymore, you can configure an image/video storage service.

  Current supported services:

  - AWS S3
  - GitHub

  ```

  Utils module provides ability to make some pre-process steps before document is passed to the converter.


  ```python
  from html_telegraph_poster_v2.utils import DocumentPreprocessor

  dp = DocumentPreprocessor(html_string)
  dp.upload_all_images()
  dp.get_processed_html()  # this should return html string with uploaded and replaced image urls
  ```
  Optionally you can pass base_url if the document contains images with relative paths
  ```python
  dp.upload_all_images(base_url='https://example.com')
  dp.get_processed_html()
  ```



  - [ ] rewrite the command line interface for simple usage
  - [ ] add automated test pipeline
  - [ ] add more services for media uploading
    - [ ] imgur
    - [ ] google drive


pkgId: 7bdac59e91b23a96903bdcf7a0d8b2911bcfaaf45bf4ac9fb8d7d975f0200828
name: python-htmlobj-help
arch: noarch
version: 1.30.0
epoch: 0
release: 1
summary: Development documents and examples for htmlobj
url: https://pypi.org/project/htmlobj/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-htmlobj-1.30.0-1.src.rpm
location_href: Packages/python-htmlobj-help-1.30.0-1.noarch.rpm
checksum_type: sha256
description:
  `htmlobj` allows you to easily create complex HTML (or XML, xHTML) using nothing but Python code.  It is an alternative to using templates in web frameworks, which usually have their own language syntax.

  ``` py
  from htmlobj import HTML
  h = HTML("html")
  h.head.title("My Page")  # can chain tags if only 1 subitem
  with h.body:  # use `with` for multiple subitems
      h.p.u("Paragraph 1 underlined")
      with h.p("Paragraph 2 ", class_="p2"):  # add attributes too
          h.b("bold")
          h.text(", not bold") # add additional text
  print(h)
  ```
  Which outputs:
  ```html
  <html>
  <head>
  <title>My Page</title>
  </head>
  <body>
  <p><u>Paragraph 1 underlined</u></p>
  <p class="p2">Paragraph 2 <b>bold</b>, not bold</p>
  </body>
  </html>
  ```
  Note that the `class_` attribute has a trailing underscore because `class` is a Python keyword.

  `htmlobj` is a re-packaging of [html3](https://github.com/pavelliavonau/html3/),  with further Python 3 modernization and additional functionality added.
  One added feature is creating an `htmlobj.HTML` instance from existing html, either as a string (`HTML.from_html`), or from a url (`HTML.from_url`):
  ``` py
  h = HTML.from_url("https://example.com/")
  ```
  This will often be used in combination with another new feature, `HTML.codify`, to *generate Python code* using `htmlobj`, for you.  Start with a page that is similar to what you want to create, then modify as needed, e.g. to programatically fill in data for that page.
  ``` py
  print(h.codify())
  ```
  which gives output like:
  ```
  h = HTML()
  with h.html:
      with h.head:
          h.title("Example Domain")
          h.meta(charset="utf-8")
          h.meta(http-equiv="Content-type", content="text/html; charset=utf-8")
  ```
  You can then copy this output as a starting point for you own code, to make a webpage similar to the one passed to `from_url`.
  Note:  you can also achieve a `from_url` / `codify` combination from the command line by running `htmlobj.html_parser` with `python -m`:
  ```
  python -m htmlobj.html_parser https://example.com > my_code.py
  ```

  ```
  pip install htmlobj
  ```

  See [Getting Started](https://darcymason.github.io/htmlobj/getting_started/) for more examples and detailed usage information.


pkgId: a8fc89567054936029716705fcb1f37a1c84bf0e6bdd6a3e35d9b6144485d7e5
name: python-httpdiff-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for httpdiff
url: https://pypi.org/project/httpdiff/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-httpdiff-0.1.2-1.src.rpm
location_href: Packages/python-httpdiff-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A library written for finding differences between HTTP responses.

  - [Disclaimer](https://github.com/WillIWas123/HTTPDiff#disclaimer)
  - [About](https://github.com/WillIWas123/HTTPDiff#about)
  - [Usecases](https://github.com/WillIWas123/HTTPDiff#usecases)
  - [Installation](https://github.com/WillIWas123/HTTPDiff#installation)
  - [How it all works](https://github.com/WillIWas123/HTTPDiff#how_it_all_works)
  - [Example usage](https://github.com/WillIWas123/HTTPDiff#example-usage)
  - [Todo](https://github.com/WillIWas123/HTTPDiff#todo)
  - [Tips](https://github.com/WillIWas123/HTTPDiff#tips)



  - This is considered to be a beta release, and may contain bugs and unintentional behavior. Consider yourself warned!



  [HTTPDiff](https://github.com/WillIWas123/HTTPDiff) is a library built for finding differences between responses.

  A lot of web pentesting tools suck, using regexes or hardcoded values to determine whether something is different. These methods will produce false-positives no matter how much you tweak those values. [HTTPDiff](https://github.com/WillIWas123/HTTPDiff) attempts to use a more dynamic way of differentiation responses, attempting to reduce the false-positives produced during a scan.

  By sending multiple requests with a known outcome, it is possible to calibrate a baseline of how the application normally behaves. [HTTPDiff](https://github.com/WillIWas123/HTTPDiff) can then be used to find deviations from the default behavior. [HTTPDiff](https://github.com/WillIWas123/HTTPDiff) will analyze every part of the response; the status code, reason, headers, body, response time, and even errors.




  - Want to create a SQL injection scanner? Send a bunch of payloads with random strings for calibration, then send pairs of payloads (e.g. ' or '1'='1 and ' or '1'='2) and check for differences!

  - If you want to brute-force endpoints and directories on a web application, you can start by sending a series of requests to known invalid endpoints. The baseline can now be used to determine if any other endpoints behave in a similar way, or are somehow different. ~~Go to [WebCD](https://github.com/WillIWas123/WebCD) for a good example on how to utilize this library.~~ <- This is a work in progress, be patient.





  ```python3 -m pip install httpdiff```



  Here comes some details of how the library is built, feel free to skip this section if you're not interested:




  1. The Baseline object takes a response object as a parameter (among others), multiple Blobs are created, one for headers, reason (status code + message), response time, body etc.
  2. The input bytes are split on multiple characters `,.; and whitespaces`. A list of these bytes are stored as the original lines.
  3. A new response is inputted, the bytes are similarly split on the same characters.
  4. Levenshtein's algorithm (similar to `git diff`) is used to generate opcodes describing how to transform the original lines to the new lines.
  5. Using these opcodes it is possible to relatively accurately determine the location of each Item, track replacements, insertions, deletions etc.
  6. A check for multiple properties are done, if all the lines in an Item have the same property it's stored as a method to analyze the lines in the future. A property in this case is a way to compare or measure a line.
  7. If there are no properties that can be used, the Item is going to be ignored in any future diffing.
  8. Repeat from step 3.




  1. A new response is inputted, the bytes are similarly split on the same characters as before.
  2. Opcodes are generated in a similar manner as before.
  3. Each line is compared against its respective Item, verifying the new line has the same properties as all the previous lines in the Item.
  4. If the line does not contain one of the stored properties, a Diff is created.
  5. (Optional) Find differences in two responses with expected different outcomes and compare the diffs.



  Go visit [WebCD](https://github.com/WillIWas123/WebCD) to see an awesome content discovery tool utilizing [HTTPDiff](https://github.com/WillIWas123/HTTPDiff).

  Here's a small example script showing how [HTTPDiff](https://github.com/WillIWas123/HTTPDiff) can be used:

  ```python
  import requests
  from httpdiff import Response, Baseline, remove_reflection
  import string
  import random

  def calibrate_baseline(baseline):
      value = "".join(random.choice(string.ascii_letters) for _ in range(random.randint(3,15)))
      for _ in range(10):
          resp = requests.get(f"https://someurl/endpoint?param={value}")
          httpdiff_resp = Response(resp)
          baseline.add_response(httpdiff_resp)

  def scan(baseline):
      
      payload1 = "' or '1111111111'='1111111111"
      resp = requests.get(f"https://someurl/endpoint?param={payload1}")
      httpdiff_resp1 = Response(resp)
      


      
      payload2 = "' or '1111111111'='2222222222"
      resp = requests.get(f"https://someurl/endpoint?param={payload2}")
      httpdiff_resp2 = Response(resp)

      
      remove_reflection(httpdiff_resp1,httpdiff_resp2,payload1,payload2)

      diffs = list(baseline.is_diff(httpdiff_resp1))
      diffs2 = list(baseline.is_diff(httpdiff_resp2))
      if diffs != diffs2:
        print(f"Vulnerable to SQL Injection!")

  def main():
      baseline = Baseline()
      calibrate_baseline(baseline)
      scan(baseline)

  if __name__ == "__main__":
    main()
  ```




  - Implement more property checks for Items
  - Improve method for diffing integer ranges
  - Properly handle errors
  - Make it easier to "overwrite" functions in order to create custom calibration and diffing methods.
  - Do a lot more testing with this tool, bugs may still be present.
  - Multiple TODO's are scattered around the code, these will be addressed some time in the future.



  Some tips for successfully creating your own scanner of some sort:

  - Use random values of random length when calibrating a baseline
  - Use cachebusters
  - Repeat one set of values during calibration (to ensure potential cache hits are included in the baseline)
  - Use relatively long values for values that are arbitrary (for removing reflection with better accuracy)
  - Verify the baseline upon a positive result
  - Verify the same payload a couple of times upon a positive result to verify it's not a fluke
  - Create an issue if you catch any mistakes in the library
  - Tell others about [HTTPDiff](https://github.com/WillIWas123/HTTPDiff)


pkgId: 42af66f7655c69e16132d8668442fdd590dcac20eef166a222c9f6b4745444c3
name: python-httpfluent-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for httpfluent
url: https://httpfluent.docs.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-httpfluent-0.1-1.src.rpm
location_href: Packages/python-httpfluent-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/httpfluent.svg)](https://pypi.org/project/httpfluent/)
  [![Build Status](https://travis-ci.org/systemd/httpfluent.svg?branch=master)](https://travis-ci.org/systemd/httpfluent)



  httpfluent is a powerful web tool designed for developers who need robust, flexible, and fast access to online resources. Whether you're automating web scraping, performing API interactions, or integrating web services, httpfluent makes it all easy and efficient.



  - Automatic handling of SSL certificates
  - Seamless integration with any web service
  - Persistent sessions with cookies
  - Support for a wide range of content types
  - Secure authentication options
  - Easy file uploads and downloads
  - Comprehensive error handling
  - Detailed response information
  - Proxy and timeout support
  - Streaming for large downloads
  - Built-in support for cryptography



  You can install httpfluent using `pip`:

  ```bash
  $ pip install httpfluent
  ```


pkgId: 6e0d53ebd998677c3e3566b688eec033f0f574dd448aca24f3b4b9c591953ebd
name: python-httpx-structlog-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for httpx-structlog
url: https://github.com/r-m-n/httpx-structlog
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-httpx-structlog-0.1.1-1.src.rpm
location_href: Packages/python-httpx-structlog-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/httpx-structlog)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/httpx-structlog)




  Сustom httpx client that logs all requests and responses with structlog.



  Install using `pip`:

  ```shell
  $ pip install httpx-structlog
  ```



  ```python
  from httpx_structlog import AsyncLoggingClient, LoggingClient







  with LoggingClient() as client:
      client.get("https://httpbin.org/uuid")



  async with AsyncLoggingClient() as client:
      await client.get("https://httpbin.org/uuid")
  ```



  ```json
  {
      "duration": 0.49533109995536506,
      "event": "httpx request",
      "host": "httpbin.org",
      "method": "GET",
      "path": "/uuid",
      "request_body": "",
      "request_headers": {
          "accept": "*/*",
          "accept-encoding": "gzip, deflate",
          "connection": "keep-alive",
          "host": "httpbin.org",
          "user-agent": "python-httpx/0.27.0"
      },
      "request_query": "",
      "response_body": "{\n  \"uuid\": \"36a2c551-8632-4712-8b56-d3e21819c04e\"\n}\n",
      "response_headers": {
          "access-control-allow-credentials": "true",
          "access-control-allow-origin": "*",
          "connection": "keep-alive",
          "content-length": "53",
          "content-type": "application/json",
          "date": "Sat, 13 Jul 2024 12:22:17 GMT",
          "server": "gunicorn/19.9.0"
      },
      "response_status": 200
  }
  ```


pkgId: a662147fee5db024ca230771bdcadd86c897bda547c8552e04013189d707bc5f
name: python-hubaxle-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for hubaxle
url: https://pypi.org/project/hubaxle/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hubaxle-0.1.8-1.src.rpm
location_href: Packages/python-hubaxle-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  Exposes an HTTP API for controlling the GL Hub.

  There are several primary functions:

  - Update the configuration files which the GL Runtime is consuming
  - Monitor status of the GL Runtime
  - Discover and set up cameras that are accessible to the hub



  - `poetry run discover-cameras` - discover cameras on the local network
  - `poetry run launch-service` - start the hubaxle service




  1. Set up a user by setting the `HUB_LOGINS` env var to `username:password`
     Either do this through the balena dashboard, or by running
  ```
  docker compose up -e HUB_LOGINS="username:password" hubaxle
  ```

  2. Open the port on the hubaxle container.  (port 8000 inside the container, port 80 on the host)

  3. Open `/admin/` page, and authenticate with your login

  4. Create a config entry called `runtime.yaml`
  5. Watch as the glruntime container does what you tell it to!



  ```
  poetry run pytest
  ```



  If it's awkward to set the `HUB_LOGINS` env var, you can also run

  ```
  ./src/manage.py createsuperuser
  ```

  from the hubaxle container, and then you can log in with the credentials you set.


  Using DRF-spectacular, we completely auto-generate the Open-api spec and then in turn use that to autogenerate a client library using Openapi-generator. We then provide a thin wrapper around the client library to make it easier to use.

  To generate the api-spec and the client library, inside the src directory run:

  ```
  make generate-api
  ```

  A couple of notes:
  - This means that schema.yaml should NEVER be manually edited.
  - Inside the autogenerated client library, we generate classes with the exact same name as the the Django models, and, by default, the exact same fields. Note this if there are any fields that you want to keep private.
  However, this model provides increased clarity, the data that you send in as a request maps extremely directly onto the model that the backend deals with


pkgId: 6f8ff2c7086eb0c1880b53f3bc24e4001b0437e15240557dbbe6cc10e451fbf2
name: python-hud-sdk
arch: noarch
version: 0.2.9
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/hud-sdk/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hud-sdk-0.2.9-1.src.rpm
location_href: Packages/python-hud-sdk-0.2.9-1.noarch.rpm
checksum_type: sha256
rpm_license:
  **Hud Technology Inc ("Hud") IDE/SDK License**   ANY AND ALL USE OF HUD'S PROPRIETARY SOLUTIONS KNOWN AS HUD SDKS, HUD IDE EXTENSIONS AND PLUGINS AND WEB APPLICATIONS ("**SOLUTION**") IS SUBJECT TO: (I) FULL REGISTRATION AT [HTTPS://APP.HUD.IO](https://app.hud.io/); (II) ACCEPTANCE OF THE HUD LICENSE TERMS EMAILED TO YOUR ORGANIZATION BY HUD UPON COMPLETION OF THE REGISTRATION ("**TERMS**") AND (II) INSTALLATION IN FULL OF THE SOLUTION. IF YOU DO NOT AGREE TO THE TERMS, PLEASE DO NOT USE THE SOLUTION.  Without derogating from the foregoing:  Until final registration, installation and acceptance of the Terms you may not use the Solution in any manner whatsoever including without limitation: modify, enhance, create derivative works, decompile, dissemble, reverse engineer, commercialize, make publicly available, distribute, copy, reproduce, rent, lease, lend, use, translate, reproduce, publish, market, license, sublicense, assign, sell, pledge, resell or otherwise use the Solution in any manner. Hud’s privacy practices are governed by Hud's Privacy Policy available at https://www.hud.io/privacy-policy.  THE SOLUTION IS HUD PROPRIETARY AND CONFIDENTIAL. THE SOLUTION AND ALL IMPROVEMENTS, ENHANCEMENTS, FEEDBACK AND DERIVATIVES THEREOF AND ALL INTELLECTUAL PROPERTY RIGHTS IN CONNECTION THEREWITH ("**HUD IPR**") ARE EXCLUSIVELY OWNED BY HUD AND/OR ITS LICENSORS. THIS AGREEMENT DOES NOT CONVEY TO YOU ANY RIGHT, TITLE OR INTEREST IN THE HUD IPR. HUD ITS AFFILIATES, OFFICERS, LICENSORS AND/OR SUPPLIERS SHALL NOT BE LIABLE UNDER ANY LEGAL THEORY WHETHER CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES WHATSOEVER.  Notwithstanding anything to the contrary, any third-party software provided as part of or with the Solution is solely governed by its respective license terms made available to you as part of the download process and/or clicking “install” for the respective part of the Solution in any of the following: [https://pypi.org/project/hud-sdk/](https://pypi.org/project/hud-sdk/#description)


pkgId: 33c41d972385f58e7b2f9273ef63d8b33967e9a9f9fb9d25e33d3ced5f21d987
name: python-huggingface-hub-help
arch: noarch
version: 0.26.5
epoch: 0
release: 1
summary: Development documents and examples for huggingface-hub
url: https://github.com/huggingface/huggingface_hub
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-huggingface-hub-0.26.5-1.src.rpm
location_href: Packages/python-huggingface-hub-help-0.26.5-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://hf.co/docs/huggingface_hub" target="_blank">https://hf.co/docs/huggingface_hub</a>


pkgId: abb7620c0eced937e9e3cd4a8ee2ff12921de967f8232a5341670383604f7e48
name: python-hugr-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for hugr
url: https://pypi.org/project/hugr/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hugr-0.10.0-1.src.rpm
location_href: Packages/python-hugr-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  [![build_status][]](https://github.com/CQCL/hugr/actions)
  [![codecov][]](https://codecov.io/gh/CQCL/hugr)
  The Hierarchical Unified Graph Representation (HUGR, pronounced _hugger_) is the
  common representation of quantum circuits and operations in the Quantinuum
  ecosystem.
  This library provides a pure-python implementation of the HUGR data model, and
  a low-level API for constructing HUGR objects.
  The API documentation for this package is [here](https://cqcl.github.io/hugr/).
  This library is intended to be used as a dependency for other high-level tools.
  See [`guppylang`][] and [`tket2`][] for examples of such tools.
  The HUGR specification is [here](https://github.com/CQCL/hugr/blob/main/specification/hugr.md).
    [`guppylang`]: https://pypi.org/project/guppylang/
    [`tket2`]: https://github.com/CQCL/tket2

  The package name is `hugr`. It can be installed from PyPI:
  ```bash
  pip install hugr
  ```
  The current releases are in alpha stage, and the API is subject to change.

  TODO

  TODO

  TODO

  This project is licensed under Apache License, Version 2.0 ([LICENSE][] or http://www.apache.org/licenses/LICENSE-2.0).
    [build_status]: https://github.com/CQCL/hugr/actions/workflows/ci-py.yml/badge.svg?branch=main
    [codecov]: https://img.shields.io/codecov/c/gh/CQCL/hugr?logo=codecov
    [LICENSE]: https://github.com/CQCL/hugr/blob/main/LICENCE
    [CHANGELOG]: https://github.com/CQCL/hugr/blob/main/hugr-py/CHANGELOG.md

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


pkgId: 14b148a131c7bc47f48085dc125a783f344bb9cb09b039b7bd544c6d739982d7
name: python-hui-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for hui
url: https://github.com/slonser/hui
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hui-0.1.1-1.src.rpm
location_href: Packages/python-hui-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  This is an alpha version of an application for identifying a server-side HTML parser.



  ```python
  from hui.identify import Identifier
  import requests

  def handler(payload):
      return requests.get("http://localhost:3005/sanitize",params={"html":payload}).text

  a = Identifier(handler=handler)
  print(a.identify())
  print(a.ALLOWED_TAGS)
  ```


  ```
  pip install hui
  ```


pkgId: 0e31203753e717d8c37f69dfc1f2a9aa9bf3f22738f142f4421df9f51d7f4494
name: python-human-keyboard-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for human-keyboard
url: https://github.com/luishacm/human-keyboard
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-human-keyboard-0.1.0-1.src.rpm
location_href: Packages/python-human-keyboard-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **Human-Keyboard** is a Python library that simulates human typing behavior. It generates keystrokes with realistic timing delays, introduces common typing errors, and corrects them as a human would. This can be useful for creating automated typing simulations, testing typing interfaces, or generating realistic typing data for research purposes.



  - **Simulated Typing Speed**: Set the Words Per Minute (WPM) to match different typing speeds.
  - **Error Simulation**: Introduces realistic typing errors such as typos, double letters, skipped letters, and swapped letters.
  - **Error Correction**: Automatically corrects errors after a delay, simulating human error correction.
  - **Fatigue Modeling**: Simulates typing fatigue over time, affecting typing speed and error rate.
  - **Customizable Parameters**: Adjust various parameters to model different typing behaviors.
  - **Support for Special Characters**: Correct handling of capital letters, numbers, punctuation, and special symbols.



  You can install **Human-Keyboard** using `pip` (after uploading it to PyPI):

  ```bash
  pip install human-keyboard
  ```

  Alternatively, clone the repository and install it manually:

  ```bash
  git clone https://github.com/luishacm/human-keyboard.git
  cd human-keyboard
  pip install .
  ```





  ```python
  from human_keyboard import HumanKeyboard


  model = HumanKeyboard()


  text = "The quick brown fox jumps over the lazy dog."


  model.type_text(text, real_time=True)
  ```



  You can customize the typing behavior by adjusting the parameters:

  ```python
  model = HumanKeyboard(
      wpm=100,             # Words per minute
      error_rate=0.05,     # Error rate (5%)
      thinking_delay=200,  # Delay when starting new words (in ms)
      fatigue_max=1.5,     # Maximum fatigue multiplier
      
  )

  text = "This is a test with custom parameters."
  model.type_text(text, real_time=True)
  ```



  If you want to generate the typed text without simulating real-time typing (useful for testing):

  ```python
  model.type_text(text, real_time=False)
  ```



  ```python

  model = HumanKeyboard(
      wpm=80,
      error_rate=0.1,
      fatigue_max=2.0,
      fatigue_increase=0.002,
      fatigue_recovery=0.001,
  )

  text = "HumanKeyboard simulates realistic typing behavior over time, including errors and fatigue."
  model.type_text(text, real_time=True)
  ```



  You can adjust the following parameters when creating a `HumanKeyboard` instance:

  - **wpm** (`float`): Base words per minute.
  - **error_rate** (`float`): Base error rate (0-1).
  - **thinking_delay** (`float`): Base delay (ms) when starting new words.
  - **fatigue_max** (`float`): Maximum fatigue multiplier.
  - **fatigue_increase** (`float`): Rate of fatigue increase per keystroke.
  - **fatigue_recovery** (`float`): Rate of fatigue recovery per second.
  - **punctuation_multiplier** (`float`): Timing multiplier for punctuation.
  - **number_multiplier** (`float`): Timing multiplier for numbers.
  - **space_multiplier** (`float`): Timing multiplier for spaces.
  - **shift_delay** (`float`): Additional delay (ms) for shifted characters.
  - **correction_delay** (`float`): Base delay (ms) before error correction.
  - **backspace_delay** (`float`): Base delay (ms) between backspaces.
  - **distance_matrix** (`dict`): Custom keyboard distance matrix.



  - Python 3.6 or higher
  - `numpy`
  - `keyboard` (requires root access on Linux and might require accessibility permissions on macOS)



  **Windows Users**: The `keyboard` module requires you to run the script with administrator privileges.

  **macOS Users**: You might need to enable accessibility permissions for Python in System Preferences.

  **Linux Users**: The `keyboard` module requires the script to be run as root. Alternatively, you can use the `uinput` module or adjust your system settings to allow non-root keyboard input.



  - **Safety**: Be cautious when using this library, as it simulates keyboard input that can interfere with your current tasks. Ensure that you have the focus on the intended window or application.
  - **Permissions**: Depending on your operating system, you might need special permissions or run your script with elevated privileges.
  - **Ethical Use**: Use this library responsibly and ethically. Do not use it for malicious purposes or to automate tasks without proper authorization.



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



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


pkgId: 00c2bd835a8de91b989224d1017fb462c98faef5f42fff5e963a39148ffadea2
name: python-humanfirst-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for humanfirst
url: https://github.com/zia-ai/humanfirst-module
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-humanfirst-2.0.1-1.src.rpm
location_href: Packages/python-humanfirst-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Humanfirst module package


  It contains classes and API functions

  **humanfirst.objects** - A set of helper classes and methods for describing, validating and interacting with HFOBjects that make up the HF JSON format

  **humanfirst.apis** - Examples of how to the call the HumanFirst APIs


pkgId: 76c789ebe4b0b420e077aeff851fc8333ac29e05a50435be272409156e6ab619
name: python-humanlayer-help
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: Development documents and examples for humanlayer
url: https://github.com/humanlayer/humanlayer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-humanlayer-0.6.3-1.src.rpm
location_href: Packages/python-humanlayer-help-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Wordmark Logo of HumanLayer](./docs/images/wordmark-light.svg)

  </div>

  **HumanLayer**: A python toolkit to enable AI agents to communicate with humans in tool-based and asynchronous workflows. By incorporating humans-in-the-loop, agentic tools can be given access to much more powerful and meaningful tool calls and tasks.

  Bring your LLM (OpenAI, Llama, Claude, etc) and Framework (LangChain, CrewAI, etc) and start giving your AI agents safe access to the world.

  <div align="center">

  <h3>

  [Homepage](https://www.humanlayer.dev/) | [Get Started](https://humanlayer.dev/docs/quickstart-python) | [Discord](https://humanlayer.dev/discord

  </h3>

  [![GitHub Repo stars](https://img.shields.io/github/stars/humanlayer/humanlayer)](https://github.com/humanlayer/humanlayer)
  [![License: Apache-2](https://img.shields.io/badge/License-Apache-green.svg)](https://opensource.org/licenses/Apache-2)
  [![PyPi Version](https://img.shields.io/pypi/v/humanlayer?color=006dad)](https://pypi.org/project/humanlayer/)
  [![NPM Version](https://img.shields.io/npm/v/humanlayer?color=ea2039)](https://www.npmjs.com/package/humanlayer)

  <img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=fcfc0926-d841-47fb-b8a6-6aba3a6c3228" />

  </div>



  - [Getting Started](#getting-started)
  - [Why HumanLayer?](#why-humanlayer)
  - [Key Features](#key-features)
  - [Examples](#examples)
  - [Roadmap](#roadmap)
  - [Contributing](#contributing)
  - [License](#license)



  To get started, check out [Getting Started](https://humanlayer.dev/docs/quickstart-python), watch the [Getting Started Video](https://www.loom.com/share/7c65d48d18d1421a864a1591ff37e2bf), or jump straight into one of the [Examples](./examples/):

  - 🦜⛓️ [LangChain](./examples/langchain/)
  - 🚣‍ [CrewAI](./examples/crewai/)
  - 🦾 [ControlFlow](./examples/controlflow/)
  - 🧠 [Raw OpenAI Client](./examples/openai_client/)

  <div align="center">
  <a target="_blank" href="https://youtu.be/5sbN8rh_S5Q"><img width="60%" alt="video thumbnail showing editor" src="https://www.humanlayer.dev/video-thumb.png"></a>
  </div>



  HumanLayer supports either Python or Typescript / JS.

  ```shell
  pip install humanlayer
  ```

  ```python
  from humanlayer import HumanLayer
  hl = HumanLayer()

  @hl.require_approval()
  def send_email(to: str, subject: str, body: str):
      """Send an email to the customer"""
      ...




  run_llm_task(
      prompt="""Send an email welcoming the customer to
      the platform and encouraging them to invite a team member.""",
      tools=[send_email],
      llm="gpt-4o"
  )
  ```

  <div align="center"><img style="width: 400px" alt="A screenshot of slack showing a human replying to the bot" src="https://www.humanlayer.dev/hl-slack-oct11.png"></div>

  For Typescript, install with npm:

  ```
  npm install humanlayer
  ```

  More python and TS examples in the [framework specific examples](./examples) or the [Getting Started Guides](https://humanlayer.dev/docs/frameworks) to get hands on.



  You can also use `hl.human_as_tool()` to bring a human into the loop for any reason. This can be useful for debugging, asking for advice, or just getting a human's opinion on something.

  ```python


  from humanlayer import HumanLayer
  hl = HumanLayer()
  contact_a_human = hl.human_as_tool()

  def send_email(to: str, subject: str, body: str):
      """Send an email to the customer"""
      ...



  run_llm_task(
      prompt="""Send an email welcoming the customer to
      the platform and encouraging them to invite a team member.

      Contact a human for collaboration and feedback on your email
      draft
      """,
      tools=[send_email, contact_a_human],
      llm="gpt-4o"
  )
  ```

  See the [examples](./examples) for more advanced human as tool examples, and workflows that combine both concepts.



  Functions and tools are a key part of [Agentic Workflows](https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance). They enable LLMs to interact meaningfully with the outside world and automate broad scopes of impactful work. Correct and accurate function calling is essential for AI agents that do meaningful things like book appointments, interact with customers, manage billing information, write+execute code, and more.

  [![Tool Calling Loop from Louis Dupont](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*r8rEqjGZs_e6dibWeaqaQg.png)](https://louis-dupont.medium.com/transforming-software-interactions-with-tool-calling-and-llms-dc39185247e9)
  _From https://louis-dupont.medium.com/transforming-software-interactions-with-tool-calling-and-llms-dc39185247e9_

  **However**, the most useful functions we can give to an LLM are also the most risky. We can all imagine the value of an AI Database Administrator that constantly tunes and refactors our SQL database, but most teams wouldn't give an LLM access to run arbitrary SQL statements against a production database (heck, we mostly don't even let humans do that). That is:

  <div align="center">
  <h3><blockquote>Even with state-of-the-art agentic reasoning and prompt routing, LLMs are not sufficiently reliable to be given access to high-stakes functions without human oversight</blockquote></h3>
  </div>

  To better define what is meant by "high stakes", some examples:

  - **Low Stakes**: Read Access to public data (e.g. search wikipedia, access public APIs and DataSets)
  - **Low Stakes**: Communicate with agent author (e.g. an engineer might empower an agent to send them a private Slack message with updates on progress)
  - **Medium Stakes**: Read Access to Private Data (e.g. read emails, access calendars, query a CRM)
  - **Medium Stakes**: Communicate with strict rules (e.g. sending based on a specific sequence of hard-coded email templates)
  - **High Stakes**: Communicate on my Behalf or on behalf of my Company (e.g. send emails, post to slack, publish social/blog content)
  - **High Stakes**: Write Access to Private Data (e.g. update CRM records, modify feature toggles, update billing information)

  <div align="center"><img style="width: 600px" alt="Image showing the levels of function stakes stacked on top of one another" src="./docs/images/function_stakes.png"></div>

  The high stakes functions are the ones that are the most valuable and promise the most impact in automating away human workflows. But they are also the ones where "90% accuracy" is not acceptable. Reliability is further impacted by today's LLMs' tendency to hallucinate or craft low-quality text that is clearly AI generated. The sooner teams can get Agents reliably and safely calling these tools with high-quality inputs, the sooner they can reap massive benefits.

  HumanLayer provides a set of tools to _deterministically_ guarantee human oversight of high stakes function calls. Even if the LLM makes a mistake or hallucinates, HumanLayer is baked into the tool/function itself, guaranteeing a human in the loop.

  <div align="center"><img style="width: 400px" alt="HumanLayer @require_approval decorator wrapping the Commnicate on my behalf function" src="./docs/images/humanlayer_require_approval.png"></div>

  <div align="center">
  <h3><blockquote>
  HumanLayer provides a set of tools to *deterministically* guarantee human oversight of high stakes function calls
  </blockquote></h3>
  </div>



  _Read More: [OpenAI's RealTime API is a step towards outer-loop agents](https://theouterloop.substack.com/p/openais-realtime-api-is-a-step-towards)_

  Between `require_approval` and `human_as_tool`, HumanLayer is built to empower the next generation of AI agents - Autonomous Agents, but it's just a piece of the puzzle. To clarify "next generation", we can summarize briefly the history of LLM applications.

  - **Gen 1**: Chat - human-initiated question / response interface
  - **Gen 2**: Agentic Assistants - frameworks drive prompt routing, tool calling, chain of thought, and context window management to get much more reliability and functionality. Most workflows are initiated by humans in single-shot "here's a task, go do it" or rolling chat interfaces.
  - **Gen 3**: Autonomous Agents - no longer human initiated, agents will live in the "outer loop" driving toward their goals using various tools and functions. Human/Agent communication is Agent-initiated rather than human-initiated.

  ![gen2 vs gen 3 agents](./docs/images/gen-2-gen-3-agents.png)

  Gen 3 autonomous agents will need ways to consult humans for input on various tasks. In order for these agents to perform actual useful work, they'll need human oversight for sensitive operations.

  These agents will require ways to contact one or more humans across various channels including chat, email, sms, and more.

  While early versions of these agents may technically be "human initiated" in that they get kicked off on a regular schedule by e.g. a cron or similar, the best ones will be managing their own scheduling and costs. This will require toolkits for inspecting costs and something akin to `sleep_until`. They'll need to run in orchestration frameworks that can durably serialize and resume agent workflows across tool calls that might not return for hours or days. These frameworks will need to support context window management by a "manager LLM" and enable agents to fork sub-chains to handle specialized tasks and roles.

  Example use cases for these outer loop agents include [the linkedin inbox assistant](./examples/langchain/04-human_as_tool_linkedin.py) and [the customer onboarding assistant](./examples/langchain/05-approvals_and_humans_composite.py), but that's really just scratching the surface.



  - **Require Human Approval for Function Calls**: the `@hl.require_approval()` decorator blocks specific function calls until a human has been consulted - upon denial, feedback will be passed to the LLM
  - **Human as Tool**: generic `hl.human_as_tool()` allows for contacting a human for answers, advice, or feedback
  - **OmniChannel Contact**: Contact humans and collect responses across Slack, Email, Discord, and more
  - **Granular Routing**: Route approvals to specific teams or individuals
  - **Bring your own LLM + Framework**: Because HumanLayer is implemented at tools layer, it supports any LLM and all major orchestration frameworks that support tool calling.



  You can test different real life examples of HumanLayer in the [examples folder](./examples/):

  - 🦜⛓️ [LangChain Math](./examples/langchain/01-math_example.py)
  - 🦜⛓️ [LangChain Human As Tool](./examples/langchain/03-human_as_tool.py)
  - 🚣‍ [CrewAI Math](./examples/crewai/crewai_math.py)
  - 🦾 [ControlFlow Math](./examples/controlflow/controlflow_math.py)
  - 🧠 [Raw OpenAI Client](./examples/openai_client/01-math_example.py)



  | Feature                                                                            | Status              |
  | ---------------------------------------------------------------------------------- | ------------------- |
  | Require Approval                                                                   | ⚙️ Beta             |
  | Human as Tool                                                                      | ⚙️ Beta             |
  | CLI Approvals                                                                      | ⚙️ Beta             |
  | CLI Human as Tool                                                                  | ⚙️ Beta             |
  | Slack Approvals                                                                    | ⚙️ Beta             |
  | Langchain Support                                                                  | ⚙️ Beta             |
  | CrewAI Support                                                                     | ⚙️ Beta             |
  | [GripTape Support](./examples/griptape)                                            | ⚗️ Alpha            |
  | [GripTape Builtin Tools Support](./examples/griptape/02-decorate-existing-tool.py) | 🗓️ Planned          |
  | Controlflow Support                                                                | ⚗️ Alpha            |
  | Custom Response options                                                            | ⚗️ Alpha            |
  | Open Protocol for BYO server                                                       | 🗓️ Planned          |
  | Composite Contact Channels                                                         | 🚧 Work in progress |
  | Async / Webhook support                                                            | 🗓️ Planned          |
  | SMS/RCS Approvals                                                                  | 🗓️ Planned          |
  | Discord Approvals                                                                  | 🗓️ Planned          |
  | Email Approvals                                                                    | ⚙️ Beta             |
  | LlamaIndex Support                                                                 | 🗓️ Planned          |
  | Haystack Support                                                                   | 🗓️ Planned          |



  The HumanLayer SDK and docs are open-source and we welcome contributions in the form of issues, documentation, pull requests, and more. See [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.



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

  Shouts out to [@erquhart](https://github.com/erquhart) for this one

  <div align="center">
  <img width="360" src="https://github.com/user-attachments/assets/849a7149-daff-43a7-8ca9-427ccd0ae77c" />
  </div>



  The HumanLayer SDK in this repo is licensed under the Apache 2 License.



  <img width="500" src="./docs/images/humanlayer-qr.png" alt="qr code to this repo">


pkgId: 0b074cfd5233d7e1a4feceee6297b6719131211904632ea1a5be5a99da952f53
name: python-humatron-python-sdk-help
arch: noarch
version: 1.3.7
epoch: 0
release: 1
summary: Development documents and examples for humatron-python-sdk
url: http://humatron.ai/build/python_worker_sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-humatron-python-sdk-1.3.7-1.src.rpm
location_href: Packages/python-humatron-python-sdk-help-1.3.7-1.noarch.rpm
checksum_type: sha256
description:
  This project provides a Python SDK library designed for Humatron developers. The library includes:

  - Worker developers section
  - REST channel client developers section



  - Request and Response Classes: Python classes for handling API interactions efficiently.
  - Abstract Helper Classes: Simplify asynchronous logic processing.
  - REST Utility Methods: Offer helpful functions for working with REST APIs.



  - REST channel client synchronous and asynchronous implementations.



  ```bash
  pip install humatron-python-sdk
  ```

  Depends on API section usage following libraries must be installed:



  - `locked-dict`, version >= `2023.10.22`, mandatory.
      - `pip install locked-dict`.
  - `flask`, version >= `3.0.3`, optional.
      - `pip install flask`.



  - `requests`, version >= `2.32.3`, mandatory.
      - `pip install requests`.



  - Examples: Visit the examples section on the [Humatron website](https://humatron.ai) for practical use cases and
    demonstrations.
  - Test Sections: Review the test sections in the documentation to understand how to implement and use the library's
    features.



  - `rm -rf dist/*`
  - `pip list --format=freeze > requirements.txt`
  - `python setup.py sdist bdist_wheel`
  - `twine upload --repository testpypi dist/*` or `twine upload --repository pypi dist/*`



  - `./make-doc.sh <version>`

    Example: `./make-doc.sh 1.2.0`

  <br />
  <img src="https://humatron.ai/images/logo_64x64.png" alt="Humatron Logo">


pkgId: edc5509ad92e79156c4b2c109608534b46e5f278d134e76da1461338bb02d804
name: python-humemai-help
arch: noarch
version: 2.4.1
epoch: 0
release: 1
summary: Development documents and examples for humemai
url: https://github.com/humemai/humemai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-humemai-2.4.1-1.src.rpm
location_href: Packages/python-humemai-help-2.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/614376180.svg)](https://zenodo.org/doi/10.5281/zenodo.10876440)
  [![PyPI
  version](https://badge.fury.io/py/humemai.svg)](https://badge.fury.io/py/humemai)

  <div align="center">
      <img src="./figures/humemai-with-text-below.png" alt="Image" style="width: 50%; max-width: 600px;">
  </div>

  - Built on a cognitive architecture
    - Functions as the brain 🧠 of your own agent
    - It has human-like short-term and long-term memory
  - The memory is represented as a knowledge graph
    - A graph database (JanusGraph + Cassandra) is used for persistence and fastgraph
      traversal
    - The user does not have to know graph query languages, e.g., Gremlin, since HumemAI
      handles read from / write to the database
  - The interface of HumemAI is natural language, just like a chatbot.
    - This requires the Text2Graph and Graph2Text modules, which are part of HumemAI
  - Everything is open-sourced, including the database





  The `humemai` Python package is available on the [PyPI server](https://pypi.org/project/humemai/). You can install it using `pip`:

  ```bash
  pip install humemai
  ```

  For development purposes, use:

  ```bash
  pip install 'humemai[dev]'
  ```

  **Supported Python Versions:** Python >= 3.10



  To set up Docker Compose, follow these steps:



  ```bash
  sudo apt-get update
  ```



  ```bash
  sudo apt-get install -y docker-compose
  ```



  These two modules are critical in HumemAI. At the moment, they are achieved with [LLM
  prompting](./humemai/prompt/), which is not ideal. They'll be replaced with Transformer
  and GNN based neural networks.



  - [`example-janus-agent.ipynb`](./examples/harry-potter/harry-potter-agent.ipynb):
    This Jupyter Notebook reads the Harry Potter book paragraph by paragraph and turns it
    into a knowledge graph. Text2Graph and Graph2Text are achieved with LLM prompting.
  - More to come ...



  This project uses a `docker-compose-cql-es.yml` file to set up a JanusGraph instance with Cassandra, Elasticsearch, and other supporting services.



  1. Unless you instantiate the `Humemai` class with a specified `compose_file_path`, it will always use the default `docker-compose-cql-es.yml` provided in the repository.
  2. Port numbers, container names, and other configurations are currently fixed. Future updates will make these configurable for running multiple instances on the same machine.
  3. The Docker Compose file starts four Docker containers:
     - `janusgraph`: The main JanusGraph instance.
     - `cassandra`: The backend storage for JanusGraph.
     - `elasticsearch`: The index/search backend for JanusGraph.
     - `janusgraph-visualizer`: A visualization tool for JanusGraph.
  4. Not all Docker images are the latest versions. Future work includes updating to the latest compatible versions.





  Run the following command in the same directory as the `docker-compose-cql-es.yml` file:

  ```bash
  docker-compose -f docker-compose-cql-es.yml up -d
  ```



  Verify the running containers:

  ```
  docker ps
  ```

  You should see containers named:

  - `jce-janusgraph`
  - `jce-cassandra`
  - `jce-elastic`
  - `jce-visualizer`



  - **JanusGraph Gremlin Server:** Accessible at `localhost:8182`.
  - **Elasticsearch:** Accessible at `localhost:9200`.
  - **Visualizer:** Accessible at `http://localhost:3000`.



  To stop the services:

  ```bash
  docker-compose -f docker-compose-cql-es.yml down
  ```



  If you want to remove the containers and associated volumes:

  ```bash
  docker-compose -f docker-compose-cql-es.yml down --volumes
  ```



  - Make port numbers, container names, and other configurations customizable.
  - Update Docker images to the latest compatible versions.
  - Add support for running multiple instances on the same machine.



  HumemAI runs four docker containers with docker-compose and one of them is visualizer.
  Open your browser and type `http://localhost:3001/`. Rename "host" to `jce-janusgraph`
  and query the graph.



  Currently this is a one-man job. [Click here to see the current
  progress](https://github.com/orgs/humemai/projects/2/).

  <!-- ## List of academic papers that use HumemAI

  - ["A Machine With Human-Like Memory Systems"](https://arxiv.org/abs/2204.01611)
  - ["A Machine with Short-Term, Episodic, and Semantic Memory
    Systems"](https://arxiv.org/abs/2212.02098)





  Click on [this link](https://humemai.github.io/humemai) to see the HTML rendered
  docstrings



  Contributions are what make the open source community such an amazing place to be learn,
  inspire, and create. Any contributions you make are **greatly appreciated**.

  1. Fork the Project
  1. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  1. Run `make test && make style && make quality` in the root repo directory, to ensure
     code quality.
  1. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
  1. Push to the Branch (`git push origin feature/AmazingFeature`)
  1. Open a Pull Request



  - [Taewoon Kim](https://taewoon.kim/)


pkgId: 524fdc8d8c8e5a9a4b4cbca56d533c81031810af19951a40b47ccb7d4b053d55
name: python-humiris-ai-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for humiris-ai
url: https://github.com/joeai-tech-org/humiris-pip-package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-humiris-ai-1.0.0-1.src.rpm
location_href: Packages/python-humiris-ai-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Please ensure you have Python (version 3.6 or higher) installed before proceeding.





  You can install Humiris using either npm or yarn:

  ```bash

  npm install humiris-ai


  yarn add humiris-ai

  ```













  For more detailed information, please refer to the [Humiris Development Documentation](https://docs.humiris.ai/development).


pkgId: 7cbef73e390a05b61b43bba8a38da3ab3f4b53c4e6a0ff9f8b67d9f24637e8ac
name: python-hvcc-help
arch: noarch
version: 0.13.0
epoch: 0
release: 1
summary: Development documents and examples for hvcc
url: https://github.com/Wasted-Audio/hvcc
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hvcc-0.13.0-1.src.rpm
location_href: Packages/python-hvcc-help-0.13.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/Wasted-Audio/hvcc/actions/workflows/build.yml/badge.svg)](https://github.com/Wasted-Audio/hvcc/actions)
  [![pypi](https://img.shields.io/pypi/v/hvcc.svg)](https://pypi.python.org/pypi/hvcc)
  [![python](https://img.shields.io/pypi/pyversions/hvcc.svg)](https://pypi.python.org/pypi/hvcc)

  `hvcc` is a python-based dataflow audio programming language compiler that generates C/C++ code and a variety of specific framework wrappers.



  Originaly created by Enzien Audio, the need for `hvcc` arose from running against performance limitations while creating interactive music and sound products for the iPhone. [Pure Data](https://puredata.info) (libpd) was the only real choice for a design tool as it was embeddable and provided a high enough abstraction level that musicians or sound designers could be creative.

  The goal was to leverage Pure Data as a design interface and statically interpret the resultant patches to generate a low-level, portable and optimised C/C++ program that would be structured to take advantage of modern hardware whilst still generating the same behaviour and audio output as Pure Data.

  It has since then been expanded to provide further support for many different platforms and frameworks, targeting game audio design, daw plugins and embedded production tools. In 2021 Wasted Audio took over maintenance of the project.



  * [Introduction](/docs/01.introduction.md)
    * [What is heavy?](/docs/01.introduction.md#what-is-heavy)
    * [Supported patch formats](/docs/01.introduction.md#supported-patch-formats)
    * [Supported platforms](/docs/01.introduction.md#supported-platforms)
    * [Supported frameworks](/docs/01.introduction.md#supported-frameworks)
    * [Licensing](/docs/01.introduction.md#licensing)
  * [Getting Started](/docs/02.getting_started.md)
  * [Generators](/docs/03.generators.md)
  * [MIDI](/docs/04.midi.md)
  * [C API](/docs/05.c.md)
  * [C++ API](/docs/06.cpp.md)
  * [Heavy Lang Info](/docs/07.heavy_lang.md)
  * [Heavy IR Info](/docs/08.heavy_ir_lang.md)
  * [Supported vanilla objects](/docs/09.supported_vanilla_objects.md)
  * [Unsupported vanilla objects](/docs/10.unsupported_vanilla_objects.md)



  hvcc has been integrated into several projects and services. This allows to easily compile patches without having to install hvcc manually.

  * [plugdata](https://plugdata.org/) - Modern interface for Pure Data. Includes a full cross-platform toolchain and targets Daisy, DPF and PD Externals.
  * [mod-cloud-builder](https://github.com/moddevices/mod-cloud-builder) - Online service for building LV2 plugins for the MOD platform.
  * [OWL Patch Library](https://www.rebeltech.org/patch-library) - Online service for building OWL plugins (uses an old fork).



  Python 3.8 up to 3.12

  * `jinja2` (for generator templating)
  * `importlib_resources` (for reading static resources)
  * `json2daisy` (for daisy integration)

  For tests:

  * `tox` (python install)
  * `numpy/scipy` (requirements-dev)
  * `midifile` (git submodule)
  * `tinywav` (git submodule)
  * `clang/clang++` (system install)



  hvcc is available from pypi.org and can be installed using python3 pip:

  `$ pip3 install hvcc`

  If you want to develop hvcc you can install it from the source directory:

  `$ git clone https://github.com/Wasted-Audio/hvcc.git`

  `$ cd hvcc/`

  `$ pip3 install -e .`



  `hvcc` requires at least one argument that determines the top-level patch file to be loaded.

  Generate a C/C++ program from `input.pd` and place the files in `~/myProject/`

  `$ hvcc ~/myProject/_main.pd`

  This command will generate the following directories:

  * `~/myProject/hv` heavylang representation of the input pd patch(es)
  * `~/myProject/ir` heavyir representation of the heavylang patch
  * `~/myProject/c` final generated C/C++ source files (this is what you would use in your project)



  As seen in the above command, typical output of `hvcc` is split into several directories that contain the intermediate files used by the compiler itself, the final generated source files, and any additional framework specific files and projects.

  The `-o` or `--out_dir` parameter will specify where the output files are placed after a successful compile.

  For example:

  `$ hvcc ~/myProject/_main.pd -o ~/Desktop/somewhere/else/`

  Will place all the generated files in `~/Desktop/somewhere/else/`.



  The `-n` or `--name` parameter can be used to easily namespace the generated code so that there are no conflicts when integrating multiple patches into the same project.

  `$ hvcc ~/myProject/_main.pd -o ~/Desktop/somewhere/else/ -n mySynth`



  Once `hvcc` has generated internal information about the patch the `-g` or `--gen` parameter can be used to specify the output files it should generate. By default it will always include `c` for the C/C++ source files and additional generators can specified for certain framework targets.

  For example:

  `$ hvcc ~/myProject/_main.pd -o ~/Desktop/somewhere/else/ -n mySynth -g unity`

  Will also generate a `unity` section in the output directory contain all the build projects and source files to compile a Unity plugin.

  It is also possible to pass a list of generators:

  `$ hvcc ~/myProject/_main.pd -o ~/Desktop/somewhere/else/ -n mySynth -g unity wwise js`

  A list of available generator options can be found [here](/docs/03.generators.md)



  `hvcc` will iterate through various directories when resolving patch objects and abstractions. The `-p` or `--search_paths` argument can be used to add additional folders for `hvcc` to look in. Note that this argument is not needed for abstractions in the same folder as the top-level patch.

  This can be handy when using a third-party patch library like [heavylib](https://github.com/Wasted-Audio/heavylib) for example.

  Simply append any folder paths after the `-p` flag like so:

  `$ hvcc ~/myProject/_main.pd -o ~/Desktop/somewhere/else/ -n mySynth -p ~/Workspace/Projects/Enzien/heavylib/ ~/Desktop/myLib/`



  `hvcc` can take extra meta-data via a supplied json file. It depends on the generator which fields are supported.



  By default all the generated source files via `hvcc` will have the following copyright text applied to the top of the file:

  `Copyright (c) 2018 Enzien Audio, Ltd.`

  This can be changed with `--copyright` parameter

  `$ hvcc ~/myProject/_main.pd -o ~/Desktop/somewhere/else/ -n mySynth --copyright "Copyright (c) Los Pollos Hermanos 2019"`



  Displays all the available parameters and options for hvcc.



  There are several places where heavy/hvcc conversation is happening:

  * [Discord](https://discord.gg/fmxJveg)
  * [IRC](https://web.libera.chat/#hvcc)
  * A number of forums:
    * [Bela](https://forum.bela.io/?q=hvcc)
    * [Rebel Technology](https://community.rebeltech.org/tags/puredata)
    * [Daisy](https://forum.electro-smith.com/c/integrations/pure-data/32)
    * [MOD](https://forum.moddevices.com/c/developers/pure-data/56)

  Or you can use the [discussions](https://github.com/Wasted-Audio/hvcc/discussions) tab of this repository


pkgId: cfd81522256b74fffd30ba7df9f96b76ba3934178378e9ee8e4fbe9b3fbe0c2b
name: python-hvmnd-api-client-help
arch: noarch
version: 4.0.0
epoch: 0
release: 1
summary: Development documents and examples for hvmnd-api-client
url: https://github.com/Smarandii/hvmnd-api-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hvmnd-api-client-4.0.0-1.src.rpm
location_href: Packages/python-hvmnd-api-client-help-4.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Python client library for the [Go API application](https://github.com/Smarandii/hvmnd-api).



  ```bash
  pip install hvmnd_api_client
  ```



  ```py
  from hvmnd_api_client import APIClient

  client = APIClient(base_url='https://localhost/api/v1')

  client.get_users()
  client.get_nodes()
  client.get_payments()
  client.create_payment_ticket(user_id=1, amount=10000)
  client.cancel_payment(id_='99999')

  ```


pkgId: ad2b0044224a676fbf933717d6bd9f159e56c544fd5533d946b1205c12684433
name: python-hvplot-help
arch: noarch
version: 0.11.1
epoch: 0
release: 1
summary: Development documents and examples for hvplot
url: https://hvplot.holoviz.org
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hvplot-0.11.1-1.src.rpm
location_href: Packages/python-hvplot-help-0.11.1-1.noarch.rpm
checksum_type: sha256
description:
  |    |    |
  | --- | --- |
  | Downloads | ![https://pypistats.org/packages/hvplot](https://img.shields.io/pypi/dm/hvplot?label=pypi) ![https://anaconda.org/pyviz/hvplot](https://pyviz.org/_static/cache/hvplot_conda_downloads_badge.svg)
  | Build Status | [![Build Status](https://github.com/holoviz/hvplot/workflows/tests/badge.svg?query=branch%3Amain)](https://github.com/holoviz/hvplot/actions?query=workflow%3Atests+branch%3Amain) |
  | Coverage | [![codecov](https://codecov.io/gh/holoviz/hvplot/branch/main/graph/badge.svg)](https://codecov.io/gh/holoviz/hvplot) |
  | Latest dev release | [![Github tag](https://img.shields.io/github/tag/holoviz/hvplot.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/hvplot/tags) [![dev-site](https://img.shields.io/website-up-down-green-red/https/holoviz-dev.github.io/hvplot.svg?label=dev%20website)](https://holoviz-dev.github.io/hvplot/) |
  | Latest release | [![Github release](https://img.shields.io/github/release/holoviz/hvplot.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/hvplot/releases) [![PyPI version](https://img.shields.io/pypi/v/hvplot.svg?colorB=cc77dd)](https://pypi.python.org/pypi/hvplot) [![hvplot version](https://img.shields.io/conda/v/pyviz/hvplot.svg?colorB=4488ff&style=flat)](https://anaconda.org/pyviz/hvplot) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/hvplot.svg?label=conda%7Cconda-forge&colorB=4488ff)](https://anaconda.org/conda-forge/hvplot) [![defaults version](https://img.shields.io/conda/v/anaconda/hvplot.svg?label=conda%7Cdefaults&style=flat&colorB=4488ff)](https://anaconda.org/anaconda/hvplot) |
  | Python | [![Python support](https://img.shields.io/pypi/pyversions/hvplot.svg)](https://pypi.org/project/hvplot/) |
  | Docs | [![gh-pages](https://img.shields.io/github/last-commit/holoviz/hvplot/gh-pages.svg)](https://github.com/holoviz/hvplot/tree/gh-pages) [![site](https://img.shields.io/website-up-down-green-red/http/hvplot.holoviz.org.svg)](https://hvplot.holoviz.org) |
  | Binder | [![Binder](https://img.shields.io/badge/launch%20v0.8.1-binder-579aca.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFkAAABZCAMAAABi1XidAAAB8lBMVEX///9XmsrmZYH1olJXmsr1olJXmsrmZYH1olJXmsr1olJXmsrmZYH1olL1olJXmsr1olJXmsrmZYH1olL1olJXmsrmZYH1olJXmsr1olL1olJXmsrmZYH1olL1olJXmsrmZYH1olL1olL0nFf1olJXmsrmZYH1olJXmsq8dZb1olJXmsrmZYH1olJXmspXmspXmsr1olL1olJXmsrmZYH1olJXmsr1olL1olJXmsrmZYH1olL1olLeaIVXmsrmZYH1olL1olL1olJXmsrmZYH1olLna31Xmsr1olJXmsr1olJXmsrmZYH1olLqoVr1olJXmsr1olJXmsrmZYH1olL1olKkfaPobXvviGabgadXmsqThKuofKHmZ4Dobnr1olJXmsr1olJXmspXmsr1olJXmsrfZ4TuhWn1olL1olJXmsqBi7X1olJXmspZmslbmMhbmsdemsVfl8ZgmsNim8Jpk8F0m7R4m7F5nLB6jbh7jbiDirOEibOGnKaMhq+PnaCVg6qWg6qegKaff6WhnpKofKGtnomxeZy3noG6dZi+n3vCcpPDcpPGn3bLb4/Mb47UbIrVa4rYoGjdaIbeaIXhoWHmZYHobXvpcHjqdHXreHLroVrsfG/uhGnuh2bwj2Hxk17yl1vzmljzm1j0nlX1olL3AJXWAAAAbXRSTlMAEBAQHx8gICAuLjAwMDw9PUBAQEpQUFBXV1hgYGBkcHBwcXl8gICAgoiIkJCQlJicnJ2goKCmqK+wsLC4usDAwMjP0NDQ1NbW3Nzg4ODi5+3v8PDw8/T09PX29vb39/f5+fr7+/z8/Pz9/v7+zczCxgAABC5JREFUeAHN1ul3k0UUBvCb1CTVpmpaitAGSLSpSuKCLWpbTKNJFGlcSMAFF63iUmRccNG6gLbuxkXU66JAUef/9LSpmXnyLr3T5AO/rzl5zj137p136BISy44fKJXuGN/d19PUfYeO67Znqtf2KH33Id1psXoFdW30sPZ1sMvs2D060AHqws4FHeJojLZqnw53cmfvg+XR8mC0OEjuxrXEkX5ydeVJLVIlV0e10PXk5k7dYeHu7Cj1j+49uKg7uLU61tGLw1lq27ugQYlclHC4bgv7VQ+TAyj5Zc/UjsPvs1sd5cWryWObtvWT2EPa4rtnWW3JkpjggEpbOsPr7F7EyNewtpBIslA7p43HCsnwooXTEc3UmPmCNn5lrqTJxy6nRmcavGZVt/3Da2pD5NHvsOHJCrdc1G2r3DITpU7yic7w/7Rxnjc0kt5GC4djiv2Sz3Fb2iEZg41/ddsFDoyuYrIkmFehz0HR2thPgQqMyQYb2OtB0WxsZ3BeG3+wpRb1vzl2UYBog8FfGhttFKjtAclnZYrRo9ryG9uG/FZQU4AEg8ZE9LjGMzTmqKXPLnlWVnIlQQTvxJf8ip7VgjZjyVPrjw1te5otM7RmP7xm+sK2Gv9I8Gi++BRbEkR9EBw8zRUcKxwp73xkaLiqQb+kGduJTNHG72zcW9LoJgqQxpP3/Tj//c3yB0tqzaml05/+orHLksVO+95kX7/7qgJvnjlrfr2Ggsyx0eoy9uPzN5SPd86aXggOsEKW2Prz7du3VID3/tzs/sSRs2w7ovVHKtjrX2pd7ZMlTxAYfBAL9jiDwfLkq55Tm7ifhMlTGPyCAs7RFRhn47JnlcB9RM5T97ASuZXIcVNuUDIndpDbdsfrqsOppeXl5Y+XVKdjFCTh+zGaVuj0d9zy05PPK3QzBamxdwtTCrzyg/2Rvf2EstUjordGwa/kx9mSJLr8mLLtCW8HHGJc2R5hS219IiF6PnTusOqcMl57gm0Z8kanKMAQg0qSyuZfn7zItsbGyO9QlnxY0eCuD1XL2ys/MsrQhltE7Ug0uFOzufJFE2PxBo/YAx8XPPdDwWN0MrDRYIZF0mSMKCNHgaIVFoBbNoLJ7tEQDKxGF0kcLQimojCZopv0OkNOyWCCg9XMVAi7ARJzQdM2QUh0gmBozjc3Skg6dSBRqDGYSUOu66Zg+I2fNZs/M3/f/Grl/XnyF1Gw3VKCez0PN5IUfFLqvgUN4C0qNqYs5YhPL+aVZYDE4IpUk57oSFnJm4FyCqqOE0jhY2SMyLFoo56zyo6becOS5UVDdj7Vih0zp+tcMhwRpBeLyqtIjlJKAIZSbI8SGSF3k0pA3mR5tHuwPFoa7N7reoq2bqCsAk1HqCu5uvI1n6JuRXI+S1Mco54YmYTwcn6Aeic+kssXi8XpXC4V3t7/ADuTNKaQJdScAAAAAElFTkSuQmCC)](https://mybinder.org/v2/gh/holoviz/hvplot/v0.8.1?urlpath=lab/tree) |
  | Support | [![Discourse](https://img.shields.io/discourse/status?server=https%3A%2F%2Fdiscourse.holoviz.org)](https://discourse.holoviz.org/c/hvplot/8) |

  [Home](https://hvplot.holoviz.org/) | [Installation instructions](#installation-instructions) | [Getting Started Guide](https://hvplot.holoviz.org/getting_started/index.html) | [Reference Guides](https://hvplot.holoviz.org/reference/index.html) | [Examples](#examples) | [License](#license) | [Support](#support--feedback)



  The API is based on the familiar Pandas `.plot` API and the innovative `.interactive` API.

  <img src="https://assets.holoviz.org/hvplot/hvplot-total-intro.gif" style="max-height:600px;border-radius:2%;">



  hvPlot

  - supports a wide range of data sources including [Pandas](http://pandas.pydata.org), [Polars](https://docs.pola.rs/), [XArray](http://xarray.pydata.org), [Dask](http://dask.pydata.org), [Streamz](http://streamz.readthedocs.io), [Intake](http://github.com/ContinuumIO/intake), [GeoPandas](http://geopandas.org) and [NetworkX](https://networkx.github.io/documentation/stable/).
  - supports the plotting backends [Bokeh](https://docs.bokeh.org/en/latest/), [Matplotlib](https://matplotlib.org/) and [Plotly](https://plotly.com/python/).
  - exposes the powerful tools from the [HoloViz](https://holoviz.org/) ecosystem in a familiar and convenient API.

  [<img src="https://hvplot.holoviz.org/_images/diagram.svg" style="max-height:400px;border-radius:2%;"/>](https://holoviz.org/)

  hvPlot is **the simplest way to benefit from the [HoloViz](https://holoviz.org/) ecosystem for data exploration**.



  Check out [this blog post](https://towardsdatascience.com/the-easiest-way-to-create-an-interactive-dashboard-in-python-77440f2511d1) to see how easy it is to create an interactive dashboard with hvPlot and Panel.

  <a href="https://towardsdatascience.com/the-easiest-way-to-create-an-interactive-dashboard-in-python-77440f2511d1"><img src="https://assets.holoviz.org/hvplot/interactive_dashboard.gif" style="max-height:600px;border-radius:2%;"></a>



  Head over to the [getting started guide](https://hvplot.holoviz.org/getting_started/index.html) for more!



  hvPlot can be installed on Linux, Windows, or Mac with ``conda``:

  ```bash
  conda install hvplot
  ```

  or with ``pip``:

  ```bash
  pip install hvplot
  ```



  Work with your data source:

  ```python
  import numpy as np
  import pandas as pd

  idx = pd.date_range('1/1/2000', periods=1000)
  df  = pd.DataFrame(np.random.randn(1000, 4), index=idx, columns=list('ABCD')).cumsum()
  ```

  Import the hvPlot extension for your data source and optionally set the plotting backend:

  ```python
  import hvplot.pandas

  ```

  Use the `.hvplot` API as you would use the Pandas or Xarray `.plot` API:

  ```python
  df.hvplot()
  ```

  [<img src="https://assets.holoviz.org/hvplot/hvplot-intro-plot.gif" style="max-height:300px;border-radius:2%;">](https://hvplot.holoviz.org/user_guide/index.html)




  Just add `.interactive` and replace your normal arguments with [Panel widgets](https://panel.holoviz.org/reference/index.html#widgets) or [Ipywidgets](https://ipywidgets.readthedocs.io/en/stable/examples/Widget%20List.html).

  ```python
  import panel as pn
  pn.extension()

  df.interactive(width=600).head(n=pn.widgets.IntSlider(start=1, end=5, value=3))
  ```

  [<img src="https://assets.holoviz.org/hvplot/hvplot-intro-interactive.gif" style="max-height:300px;border-radius:2%;">](https://hvplot.holoviz.org/user_guide/Interactive.html)



  To see the available arguments for a specific `kind` of plot run

  ```python
  hvplot.help(kind='scatter')
  ```

  In a notebook or ipython environment the usual

  - `help` and `?` will provide you with documentation.
  - `TAB` and `SHIFT+TAB` completion will help you navigate.



  hvPlot is completely free and open-source. It is licensed under the [BSD 3-Clause License](https://opensource.org/licenses/BSD-3-Clause).



  - Usage questions and showcases -> [HoloViz Community](https://holoviz.org/community.html)
  - Bug reports and feature requests -> [Github](https://github.com/holoviz/hvplot)
  - Developer discussions -> [Discord](https://discord.gg/rb6gPXbdAr)

  For more detail check out the [HoloViz Community Guide](https://holoviz.org/community.html).



  We would love to work with you no matter whether you want to contribute to issue management, PRs, documentation, blog posts, community support or social media communication.

  To get started with the code or docs check out the [Developer Guide](https://hvplot.holoviz.org/developer_guide/index.html).


pkgId: c056dba7212f1c5a1897c0187af96656862419f812c01e2f90af7515f877254b
name: python-hxrsnd-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for hxrsnd
url: https://pypi.org/project/hxrsnd/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hxrsnd-0.3.2-1.src.rpm
location_href: Packages/python-hxrsnd-help-0.3.2-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2023, The Board of Trustees of the Leland Stanford Junior University, through SLAC National Accelerator Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy). All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  (3) Neither the name of the Leland Stanford Junior University, SLAC National Accelerator Laboratory, U.S. Dept. of Energy 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, THE UNITED STATES GOVERNMENT, OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  You are under no obligation whatsoever to provide any bug fixes, patches, or upgrades to the features, functionality or performance of the source code ("Enhancements") to anyone; however, if you choose to make your Enhancements available either publicly, or directly to SLAC National Accelerator Laboratory, without imposing a separate written license agreement for such Enhancements, then you hereby grant the following license: a non-exclusive, royalty-free perpetual license to install, use, modify, prepare derivative works, incorporate into other computer software, distribute, and sublicense such Enhancements or derivative works thereof, in binary and source code form.


pkgId: 789b4331192377fa4f07de2cc4cb502616df7485a0f18e62a9e63fc081a75dc4
name: python-hybra-help
arch: noarch
version: 2024.12.1
epoch: 0
release: 1
summary: Development documents and examples for hybra
url: https://pypi.org/project/hybra/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hybra-2024.12.1-1.src.rpm
location_href: Packages/python-hybra-help-2024.12.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Logo](https://github.com/danedane-haider/HybrA-Filterbanks/assets/55834940/5a7f4ec5-86a3-47b8-bdd0-fd92943f8b1b)

  > [!WARNING]
  > Still under development.

  Provide a *pth file with a dictionary containing the following keys: auditory_filters_real, auditory_filters_imag, auditory_filters_stride, n_filters, kernel_size

  see auditory_filters_speech.pth as example

rpm_license:
  BSD 3-Clause Clear License  Copyright (c) 2024 Austrian Academy of Sciences All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the disclaimer below) 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 Austrian Academy of Sciences nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. 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: accaa18495750a2c252a3c4243129fe6f064bba2b62e6a4a570386241e1e5103
name: python-hyp3-sdk-help
arch: noarch
version: 7.0.2
epoch: 0
release: 1
summary: Development documents and examples for hyp3-sdk
url: https://github.com/ASFHyP3/hyp3-sdk
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hyp3-sdk-7.0.2-1.src.rpm
location_href: Packages/python-hyp3-sdk-help-7.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI license](https://img.shields.io/pypi/l/hyp3_sdk.svg)](https://pypi.python.org/pypi/hyp3_sdk/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/hyp3_sdk.svg)](https://pypi.python.org/pypi/hyp3_sdk/)
  [![PyPI version](https://img.shields.io/pypi/v/hyp3_sdk.svg)](https://pypi.python.org/pypi/hyp3_sdk/)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/hyp3_sdk)](https://anaconda.org/conda-forge/hyp3_sdk)
  [![Conda platforms](https://img.shields.io/conda/pn/conda-forge/hyp3_sdk)](https://anaconda.org/conda-forge/hyp3_sdk)

  [![DOI](https://zenodo.org/badge/283858964.svg)](https://zenodo.org/badge/latestdoi/283858964)

  A python wrapper around the HyP3 API

  ```python
  >>> from hyp3_sdk import HyP3
  >>> hyp3 = HyP3(username='MyUsername', password='MyPassword')

  >>> granule = 'S1A_IW_SLC__1SSV_20150621T120220_20150621T120232_006471_008934_72D8'
  >>> job = hyp3.submit_rtc_job(granule=granule, name='MyNewJob')
  >>> job = hyp3.watch(job)
  >>> job.download_files()
  ```



  In order to easily manage dependencies, we recommend using dedicated project environments
  via [Anaconda/Miniconda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html)
  or [Python virtual environments](https://docs.python.org/3/tutorial/venv.html).

  The HyP3 SDK can be installed into a conda environment with

  ```
  conda install -c conda-forge hyp3_sdk
  ```

  or into a virtual environment with

  ```
  python -m pip install hyp3_sdk
  ```



  There are 3 main classes that the SDK exposes:

  - `HyP3` to perform HyP3 operations (find jobs, refresh job information, submitting new jobs)
  - `Job` to perform operations on single jobs (downloading products, check status)
  - `Batch` to perform operations on multiple jobs at once (downloading products, check status)

  An instance of the `HyP3` class will be needed to interact with the external HyP3 API.

  ```python
  >>> from hyp3_sdk import HyP3
  >>> hyp3 = HyP3(username='MyUsername', password='MyPassword')

  >>> granule = 'S1A_IW_SLC__1SSV_20150621T120220_20150621T120232_006471_008934_72D8'
  >>> job = hyp3.submit_rtc_job(granule=granule, name='MyNewJob')
  >>> job = hyp3.watch(job)
  >>> job.download_files()
  ```



  `hyp3` has member functions for submitting new jobs:
  ```python
  rtc_job = hyp3.submit_rtc_job('granule_id', 'job_name')
  insar_job = hyp3.submit_insar_job('reference_granule_id', 'secondary_granule_id', 'job_name')
  insar_burst_job = hyp3.submit_insar_isce_burst_job('reference_granule_id', 'secondary_granule_id', 'job_name')
  autorift_job = hyp3.submit_autorift_job('reference_granule_id', 'secondary_granule_id', 'job_name')
  ```
  Each of these functions will return an instance of the `Job` class that represents a new HyP3 job request.


  To find HyP3 jobs that were run previously, you can use the `hyp3.find_jobs()`
  ```python
  batch = hyp3.find_jobs()
  ```
  This will return a `Batch` instance representing all jobs owned by you. You can also pass parameters to
  query to a specific set of jobs




  If your jobs are not complete you can use the HyP3 instance to update them, and wait from completion
  ```python
  batch = hyp3.find_jobs()
  if not batch.complete():
      
      batch = hyp3.refresh(batch)
      
      batch = hyp3.watch(batch)
  ```

  Once you have complete jobs you can download the products to your machine
  ```python
  batch.download_files()
  ```

  These operations also work on `Job` objects
  ```python
  job = hyp3.submit_rtc_job('S1A_IW_SLC__1SSV_20150621T120220_20150621T120232_006471_008934_72D8', 'MyJobName')
  job = hyp3.watch(job)
  job.download_files()
  ```



  For the full SDK API Reference, see [the HyP3 documentation](https://hyp3-docs.asf.alaska.edu/using/sdk_api/)



  Want to talk about the HyP3 SDK? We would love to hear from you!

  Found a bug? Want to request a feature?
  [Open an issue](https://github.com/ASFHyP3/hyp3-sdk/issues/new)

  General questions? Suggestions? Or just want to talk to the team?
  [Chat with us on Gitter](https://gitter.im/ASFHyP3/community)


pkgId: cfd08b868377f2b28434e218cbf9d7e38668f1db1819f2172724cb19720de992
name: python-hyp3lib-help
arch: noarch
version: 3.1.3
epoch: 0
release: 1
summary: Development documents and examples for hyp3lib
url: https://pypi.org/project/hyp3lib/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hyp3lib-3.1.3-1.src.rpm
location_href: Packages/python-hyp3lib-help-3.1.3-1.noarch.rpm
checksum_type: sha256
description:
  > [!WARNING]
  > HyP3-lib is currently undergoing a major redesign and many utilities that are no longer used by existing HyP3 plugins have been removed between version 2 and version 3. In addition, we plan to migrate some remaining functionality to other projects and to significantly refactor what remains. For this reason, **if you are using HyP3-lib we strongly recommend pinning to major versions at this time**. We further recommend not using this library in production until its version 4 release.


  The goal of this package is to provide ASF's various HyP3 plugins with a set of utilities they can use to perform common tasks. This could include tasks such as downloading Sentinel-1 orbit data, or verifying that NASA EarthData credentials are available.

  If you're a MintPy user looking to crop HyP3 products, please see our [Time Series Analysis with HyP3 and Mintpy Tutorial](https://hyp3-docs.asf.alaska.edu/tutorials/mintpy).

  If you are looking for a way to request HyP3 products via Python, we suggest checkout our [HyP3 Python SDK](https://github.com/ASFHyP3/hyp3-sdk).

  If you are looking for workflows that take advantage of our HyP3 on-demand products, we suggest checking out our [ASF Tools](https://github.com/ASFHyP3/asf-tools) Python library.


  The HyP3-lib package is licensed under the BSD 3-Clause license. See the [`LICENSE`](LICENSE) file for more details.


  We strive to create a welcoming and inclusive community for all contributors to HyP3-lib. As such, all contributors to this project are expected to adhere to our code of conduct.

  Please see [`CODE_OF_CONDUCT.md`](CODE_OF_CONDUCT.md) for the full code of conduct text.


  Contributions to the HyP3-lib library are welcome! Whether you're finding bugs, adding new features, fixing anything broken, or improving documentation, get started by submitting an issue or pull request!

  Please see [`CONTRIBUTING.md`](CONTRIBUTING.md) for more info.


  Want to talk about HyP3-lib? We would love to hear from you!

  Found a bug? Want to request a feature?
  [open an issue](https://github.com/ASFHyP3/hyp3-lib/issues/new)

  General questions? Suggestions? Or just want to talk to the team?
  [chat with us on gitter](https://gitter.im/ASFHyP3/community)


pkgId: ce68cb9c06a71febb554e87a0d8fa0f6f9b94cfb0bebdec0fcb0569c879faa94
name: python-hypergraph-db-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for hypergraph-db
url: https://github.com/iMoonLab/Hyper-DB
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hypergraph-db-0.1.0-1.src.rpm
location_href: Packages/python-hypergraph-db-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
     - Supports vertices (`v`) and hyperedges (`e`), where hyperedges can connect any number of vertices.
     - Hyperedges are represented as sorted tuples of vertex IDs, ensuring consistency and efficient operations.
     - Add, update, delete, and query vertices and hyperedges with ease.
     - Built-in methods to retrieve neighbors, incident edges, and other relationships.
     - Get neighboring vertices or hyperedges for a given vertex or hyperedge.
     - Save and load hypergraphs to/from disk using efficient serialization (`pickle`).
     - Ensures data integrity and supports large-scale data storage.


pkgId: 184eacd6e7f0b7f8857d899ea10aceb28042ac8ed79ffa79d664be75f9f977b1
name: python-hypernetx-help
arch: noarch
version: 2.3.10
epoch: 0
release: 1
summary: Development documents and examples for hypernetx
url: https://pypi.org/project/hypernetx/
rpm_license: 3-Clause BSD license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hypernetx-2.3.10-1.src.rpm
location_href: Packages/python-hypernetx-help-2.3.10-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/pnnl/HyperNetX/master/docs/source/images/harrypotter_basic_hyp.png" align="right" width="300pt">
  [![Pytest](https://github.com/pnnl/HyperNetX/actions/workflows/ci.yml/badge.svg)](https://github.com/pnnl/HyperNetX/actions/workflows/ci.yml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/PyCQA/pylint)
  [![CITATION.cff](https://github.com/pnnl/HyperNetX/actions/workflows/cff.yml/badge.svg)](https://github.com/pnnl/HyperNetX/actions/workflows/cff.yml)
  The HyperNetX library provides classes and methods for the analysis
  and visualization of complex network data modeled as hypergraphs.
  The library generalizes traditional graph metrics.
  HypernetX was developed by the Pacific Northwest National Laboratory for the
  Hypernets project as part of its High Performance Data Analytics (HPDA) program.
  PNNL is operated by Battelle Memorial Institute under Contract DE-ACO5-76RL01830.
  * Principal Developer and Designer: Brenda Praggastis
  * Development Team: Audun Myers, Mark Bonicillo
  * Visualization: Dustin Arendt, Ji Young Yun
  * Principal Investigator: Cliff Joslyn
  * Program Manager: Brian Kritzstein
  * Principal Contributors (Design, Theory, Code): Sinan Aksoy, Dustin Arendt, Mark Bonicillo, Helen Jenne, Cliff Joslyn, Nicholas Landry, Audun Myers, Christopher Potvin, Brenda Praggastis, Emilie Purvine, Greg Roek, Mirah Shi, Francois Theberge, Ji Young Yun
  The code in this repository is intended to support researchers modeling data
  as hypergraphs. We have a growing community of users and contributors.
  Documentation is available at: https://pnnl.github.io/HyperNetX
  For questions and comments contact the developers directly at: hypernetx@pnnl.gov


pkgId: bd577c241dd0b980bcd5a118514e7adb870cd195b4bec6578231ab4a01721128
name: python-hyperstack-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for hyperstack
url: https://pypi.org/project/hyperstack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hyperstack-0.2.8-1.src.rpm
location_href: Packages/python-hyperstack-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
      Leverage the Infrahub API and Hyperstack platform to easily create, manage, and scale powerful GPU virtual machines and their associated resources.   Access this SDK to automate the deployment of your workloads and streamline your infrastructure management.  To contribute, please raise an issue with a bug report, feature request, feedback, or general inquiry.


pkgId: 24439b898ea14094272eb31e2a2cbabab743a6994cc95f23c9cfe2ee4c7fd67c
name: python-hypex-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for hypex
url: https://github.com/sb-ai-lab/HypEx
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hypex-0.1.9-1.src.rpm
location_href: Packages/python-hypex-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  ![Last release](https://img.shields.io/badge/pypi-v0.1.5-darkgreen)
  [![Telegram](https://img.shields.io/badge/chat-on%20Telegram-2ba2d9.svg)](https://t.me/hypexchat)
  ![Pypi downloads](https://img.shields.io/badge/downloads-5K-1E782B)
  ![Python versions](https://img.shields.io/badge/python-3.8_|_3.9_|_3.10_|_3.11_|_3.12-blue)
  ![Pypi downloads\month](https://img.shields.io/badge/downloads\month->1K-1E782B)



  HypEx (Hypotheses and Experiments) is a comprehensive library crafted to streamline the causal inference and AB testing
  processes in data analytics. Developed for efficiency and effectiveness, HypEx employs Rubin's Causal Model (RCM) for
  matching closely related pairs, ensuring equitable group comparisons when estimating treatment effects.

  Boasting a fully automated pipeline, HypEx adeptly calculates the Average Treatment Effect (ATE), Average Treatment
  Effect on the Treated (ATT), and Average Treatment Effect on the Control (ATC). It offers a standardized interface for
  executing these estimations, providing insights into the impact of interventions across various population subgroups.

  Beyond causal inference, HypEx is equipped with robust AB testing tools, including Difference-in-Differences (
  Diff-in-Diff) and CUPED methods, to rigorously test hypotheses and validate experimental results.



  - **Faiss KNN Matching**: Utilizes Faiss for efficient and precise nearest neighbor searches, aligning with RCM for
    optimal pair matching.
  - **Data Filters**: Built-in outlier and Spearman filters ensure data quality for matching.
  - **Result Validation**: Offers multiple validation methods, including random treatment, feature, and subset
    validations.
  - **Data Tests**: Incorporates SMD, KS, PSI, and Repeats tests to affirm the robustness of effect estimations.
  - **Feature Selection**: Employs LGBM and Catboost feature selection to pinpoint the most impactful features for causal
    analysis.
  - **AB Testing Suite**: Features a suite of AB testing tools for comprehensive hypothesis evaluation.
  - **Stratification support**: Stratify groups for nuanced analysis
  - **Weights support**:  Empower your analysis by assigning custom weights to features, enhancing the matching precision
    to suit your specific research needs



  Some functions in HypEx can facilitate solving specific auxiliary tasks but cannot automate decisions on experiment
  design. Below, we will discuss features that are implemented in HypEx but do not automate the design of experiments.

  **Note:** For Matching, it's recommended not to use more than 7 features as it might result in the curse of
  dimensionality, making the results unrepresentative.



  **Feature selection** models the significance of features for the accuracy of target approximation. However, it does not
  rule out the possibility of overlooked features, the complex impact of features on target description, or the
  significance of features from a business logic perspective. The algorithm will not function correctly if there are data
  leaks.

  Points to consider when selecting features:

  * Data leaks - these should not be present.
  * Influence on treatment distribution - features should not affect the treatment distribution.
  * The target should be describable by features.
  * All features significantly affecting the target should be included.
  * The business rationale of features.
  * The feature selection function can be useful for addressing these tasks, but it does not solve them nor does it
    absolve the user of the responsibility for their selection, nor does it justify it.

  [Link to ReadTheDocs](https://hypex.readthedocs.io/en/latest/pages/modules/selectors.html#selector-classes)



  **Random Treatment** algorithm randomly shuffles the actual treatment. It is expected that the treatment's effect on the
  target will be close to 0.

  These method is not sufficiently accurate marker of a successful experiment.

  [Link to ReadTheDocs](https://hypex.readthedocs.io/en/latest/pages/modules/utils.html#validators)



  ```bash
  pip install -U hypex
  ```



  Explore usage examples and tutorials [here](https://github.com/sb-ai-lab/Hypex/blob/master/examples/tutorials/).



  ```python
  from hypex import Matcher
  from hypex.utils.tutorial_data_creation import create_test_data


  df = create_test_data(rs=42, na_step=45, nan_cols=['age', 'gender'])

  info_col = ['user_id']
  outcome = 'post_spends'
  treatment = 'treat'
  model = Matcher(input_data=df, outcome=outcome, treatment=treatment, info_col=info_col)
  results, quality_results, df_matched = model.estimate()
  ```



  ```python
  from hypex import AATest
  from hypex.utils.tutorial_data_creation import create_test_data

  data = create_test_data(rs=52, na_step=10, nan_cols=['age', 'gender'])

  info_cols = ['user_id', 'signup_month']
  target = ['post_spends', 'pre_spends']

  experiment = AATest(info_cols=info_cols, target_fields=target)
  results = experiment.process(data, iterations=1000)
  results.keys()
  ```



  ```python
  from hypex import ABTest
  from hypex.utils.tutorial_data_creation import create_test_data

  data = create_test_data(rs=52, na_step=10, nan_cols=['age', 'gender'])

  model = ABTest()
  results = model.execute(
      data=data,
      target_field='post_spends',
      target_field_before='pre_spends',
      group_field='group'
  )

  model.show_beautiful_result()
  ```



  For more detailed information about the library and its features, visit
  our [documentation on ReadTheDocs](https://hypex.readthedocs.io/en/latest/).

  You'll find comprehensive guides and tutorials that will help you get started with HypEx, as well as detailed API
  documentation for advanced use cases.



  Join our vibrant community! For guidelines on contributing, reporting issues, or seeking support, please refer to
  our [Contributing Guidelines](https://github.com/sb-ai-lab/Hypex/blob/master/.github/CONTRIBUTING.md).



  [Habr (ru)](https://habr.com/ru/companies/sberbank/articles/778774/) - discover how HypEx is revolutionizing causal
  inference in various fields.
  [A/B testing seminar](https://www.youtube.com/watch?v=B9BE_yk8CjA&t=53s&ab_channel=NoML) - Seminar in NoML about
  matching and A/B testing
  [Matching with HypEx: Simple Guide](https://www.kaggle.com/code/kseniavasilieva/matching-with-hypex-simple-guide) -
  Simple matching guide with explanation
  [Matching with HypEx: Grouping](https://www.kaggle.com/code/kseniavasilieva/matching-with-hypex-grouping) - Matching
  with grouping guide
  [HypEx vs Causal Inference and DoWhy](https://www.kaggle.com/code/kseniavasilieva/hypex-vs-causal-inference-and-dowhy) -
  discover why HypEx is the best solution for causal inference
  [HypEx vs Causal Inference and DoWhy: part 2](https://www.kaggle.com/code/kseniavasilieva/hypex-vs-causal-inference-part-2) -
  discover why HypEx is the best solution for causal inference



  Visit [this](https://www.kaggle.com/code/kseniavasilieva/hypex-vs-causal-inference-part-2) notebook ain Kaggle and
  estimate results by yourself.

  | Group size             | 32 768 | 65 536 | 131 072 | 262 144 | 524 288 | 1 048 576 | 2 097 152 | 4 194 304 |
  |------------------------|--------|--------|---------|---------|---------|-----------|-----------|-----------|
  | Causal Inference       | 46s    | 169s   | None    | None    | None    | None      | None      | None      |
  | DoWhy                  | 9s     | 19s    | 40s     | 77s     | 159s    | 312s      | 615s      | 1 235s    |
  | HypEx with grouping    | 2s     | 6s     | 16s     | 42s     | 167s    | 509s      | 1 932s    | 7 248s    |
  | HypEx without grouping | 2s     | 7s     | 21s     | 101s    | 273s    | 982s      | 3 750s    | 14 720s   |



  Have questions or want to discuss HypEx? Join our [Telegram chat](https://t.me/HypExChat) and connect with the community
  and the developers.



  HypEx stands as an indispensable resource for data analysts and researchers delving into causal inference and AB
  testing. With its automated capabilities, sophisticated matching techniques, and thorough validation procedures, HypEx
  is poised to unravel causal relationships in complex datasets with unprecedented speed and precision.


pkgId: e7dd533f43c74b63af36b15202d0b326da920097ac1a29e2829d4c8f7bfad986
name: python-hypha-help
arch: noarch
version: 0.20.44.post6
epoch: 0
release: 1
summary: Development documents and examples for hypha
url: http://github.com/amun-ai/hypha
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hypha-0.20.44.post6-1.src.rpm
location_href: Packages/python-hypha-help-0.20.44.post6-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/hypha.svg?style=popout)

  <img src="./docs/img/hypha-logo-black.svg" width="320" alt="Hypha">

  **Hypha** is a generative AI-powered application framework designed for large-scale data management, AI model serving, and real-time communication. Hypha allows the creation of computational platforms consisting of both computational and user interface components.



  - **Generative AI-Powered:** Leverage the power of generative AI to build advanced data management and AI model serving solutions.
  - **Hypha-RPC:** Utilize [hypha-rpc](https://github.com/oeway/hypha-rpc), a bidirectional remote procedure call system, enabling seamless communication and integration across distributed components.
  - **Real-Time Communication:** Support for real-time communication within virtual workspaces, similar to platforms like Zoom.
  - **Scalable and Flexible:** Connect and orchestrate various compute services, AI models, tools, and services running on distributed locations.
  - **GenAI-Powered Automation:** Build GenAI-powered automation platforms and agentic workflows, enabling fully autonomous agent systems.



  Hypha acts as a hub that connects different components through **Hypha-RPC**. Users and programmatic clients connect to the platform in virtual workspaces, where they can seamlessly make remote procedure calls (RPC) as if they are calling local functions. Developers can integrate all types of compute services, including AI models, tools, and services, across distributed locations.



  - Hypha's virtual workspaces are akin to Zoom rooms, where clients (users and programmatic) can connect and interact.
  - Within these workspaces, all clients can perform seamless RPCs, facilitating easy and efficient collaboration and computation.



  - Hypha supports the integration of various compute services, including AI models and data analytics tools.
  - These services, when connected to the platform, can be understood and orchestrated by large language models (LLMs), paving the way for creating next-generation GenAI-powered automation platforms and agentic workflows.



  - **Research Institutions:** Build integrated platforms for data management and AI-powered services.
  - **AI-Powered Automation:** Create autonomous agent systems and GenAI-powered automation platforms.
  - **Data Services:** Facilitate scalable and efficient data services and analytics through distributed computing.



  To get started with Hypha, follow the installation and setup instructions in the [documentation](https://docs.amun.ai).



  Hypha is released under the MIT License. See the [LICENSE](./LICENSE) file for more details.



  We welcome contributions from the community. Please see our [Contributing Guidelines](./CONTRIBUTING.md) for more information.



  We thank the contributors and community members who have helped make Hypha what it is today.


pkgId: 062858bcc600569abd9134d5434543d7b69a9340459bfa5fb93717df605cc515
name: python-hypothesis-torch-help
arch: noarch
version: 0.8.8
epoch: 0
release: 1
summary: Development documents and examples for hypothesis-torch
url: https://github.com/qthequartermasterman/hypothesis-torch
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hypothesis-torch-0.8.8-1.src.rpm
location_href: Packages/python-hypothesis-torch-help-0.8.8-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/hypothesis-torch.svg)](https://pypi.org/project/hypothesis-torch) ![PyPI - Downloads](https://img.shields.io/pypi/dm/hypothesis-torch)
  [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)


  Hypothesis strategies for various Pytorch structures (including tensors and modules).

  [Hypothesis](https://hypothesis.readthedocs.io/en/latest/) is a powerful property-based testing library for Python. It
  lacks built-in support for Pytorch tensors and modules, so this library provides strategies for generating them.


  `hypothesis-torch` can be installed via pip:
  ```bash
  pip install hypothesis-torch
  ```

  Optionally, you can also install the `huggingface` extra to also install the `transformers` library:
  ```bash
  pip install hypothesis-torch[huggingface]
  ```

  Strategies for generating Hugging Face transformer models are provided in the `hypothesis_torch.huggingface` module. If
  and only if `transformers` is installed when `hypothesis-torch` is imported, these strategies will be available from
  the root `hypothesis_torch` module.





  Tensors can be generated with the `tensor_strategy` function. This function takes in optional arguments for the shape,
  dtype, device, and other properties of the desired tensors. Each property can be specified as a fixed value or as a
  strategy. For example, to generate a tensor with a shape of 3x3, a dtype of `torch.float32`, and values between 0 and 1,

  ```python
  import hypothesis_torch
  from hypothesis import strategies as st
  import torch
  hypothesis_torch.tensor_strategy(dtype=torch.float32, shape=(3, 3), elements=st.floats(0, 1))
  ```

  Note that specifying other hypothesis strategies that return the same type as an argument will sample from that strategy
  while generating the tensor. For example, to generate a tensor with any dtype, specify a strategy that returns a dtype:

  ```python
  import hypothesis_torch
  from hypothesis import strategies as st
  import torch
  hypothesis_torch.tensor_strategy(dtype=st.sampled_from([torch.float32, torch.float64]), shape=(3, 3), elements=st.floats(0, 1))
  ```



  Dtypes can be generated with the `dtype_strategy` function. If no arguments are provided, this function will default to
  sampling from the set of all Pytorch dtypes.

  ```python
  import hypothesis_torch
  hypothesis_torch.dtype_strategy()
  ```

  If a set of dtypes is provided, the function will sample from that set.

  ```python
  import hypothesis_torch
  import torch
  hypothesis_torch.dtype_strategy(dtypes={torch.float32, torch.float64})
  ```



  Devices can be generated with the `device_strategy` function. If no arguments are provided, this function will default to
  sampling from the set of all available, physical devices.

  ```python
  import hypothesis_torch
  hypothesis_torch.device_strategy()
  ```

  If a set of devices is provided, the function will sample from that set.

  ```python
  import hypothesis_torch
  import torch
  hypothesis_torch.device_strategy(devices={torch.device('cuda:0'), torch.device('cpu')})
  ```

  If `allow_meta_device` is set to `True`, the strategy may also return meta devices, i.e. `torch.device('meta')`.

  ```python
  import hypothesis_torch
  hypothesis_torch.device_strategy(allow_meta_device=True)
  ```



  Various types of PyTorch modules have their own strategies.



  Activation functions can be generated with the `same_shape_activation_strategy` function.

  ```python
  import hypothesis_torch
  hypothesis_torch.same_shape_activation_strategy()
  ```



  Fully-connected neural networks can be generated with the `linear_network_strategy` function. This function takes in
  optional arguments for the input size, output size, and number of hidden layers. Each of these arguments can be
  specified as a fixed value or as a strategy. For example, to generate a fully-connected neural network with an input
  size of 10, an output size of 5, and 3 hidden layers with sizes between 5 and 10:

  ```python
  import hypothesis_torch
  from hypothesis import strategies as st
  hypothesis_torch.linear_network_strategy(input_shape=(1,10), output_shape=(1,5), hidden_layer_size=st.integers(5, 10), num_hidden_layers=3)
  ```



  Hugging Face transformer models can be generated with the `transformer_strategy` function. This function takes in any
  Hugging Face `PreTrainedModel` subclass (or a strategy that generates references `PreTrainedModel` subclasses) and
  returns an instance of that model. For example, to generate an arbitrary Llama2 model:

  ```python
  import hypothesis_torch
  import transformers
  hypothesis_torch.transformer_strategy(transformers.LlamaForCausalLM)
  ```

  The strategy also accepts `kwargs` to pass to the model constructor. These can be either fixed values or strategies to
  generate those corresponding values. For example, to generate an arbitrary Llama2 model with a hidden size between 64 and
  128, but a fixed vocabulary size of 1000:

  ```python
  import hypothesis_torch
  import transformers
  from hypothesis import strategies as st
  hypothesis_torch.transformer_strategy(transformers.LlamaForCausalLM, hidden_size=st.integers(64, 128), vocab_size=1000)
  ```

  [! Note]
      Currently, the `transformer_strategy` only accepts `kwargs` that can be passed to the constructor of the model's
      config class. Thus, it cannot currently replicate all the behavior of calling `from_pretrained` on a model class.

rpm_license:
  MIT License  Copyright (c) 2024 Andrew Sansom  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: 650f4eab0712e5e154f2ecf277dd9c3c50efdd98ded68e2b26cd0899ac8616bd
name: python-iCCF-help
arch: noarch
version: 0.3.20
epoch: 0
release: 1
summary: Development documents and examples for iCCF
url: https://j-faria.github.io/iCCF/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iCCF-0.3.20-1.src.rpm
location_href: Packages/python-iCCF-help-0.3.20-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width = "450" src="https://github.com/j-faria/iCCF/blob/main/iCCF/logo/logo.png?raw=true"/>
    <!-- <br> -->
    <!-- Line profile asymmetry indicators -->
  </p>


  An implementation of common line profile indicators
  measured from the cross-correlation function (CCF).

  [![Build Status](https://travis-ci.org/j-faria/iCCF.svg?branch=master)](https://travis-ci.org/j-faria/iCCF)
  [![License: MIT](https://img.shields.io/badge/license-MIT-informational.svg)](https://opensource.org/licenses/MIT)
  [![PyPI version](https://badge.fury.io/py/iCCF.svg)](https://pypi.org/project/iCCF/)



  Directly from PyPI
  ```
  pip install iCCF
  ```

  Or from source
  ```
  git clone https://github.com/j-faria/iCCF.git
  cd iCCF
  pip install -e .
  ```

  All the indicators are based on the works of others.
  Please cite these works if you use **iCCF**.

    - [Queloz et al 2001](https://doi.org/10.1051/0004-6361:20011308)
    - [Boisse et al 2011](https://doi.org/10.1051/0004-6361/201014354)
    - [Nardetto et al 2006](https://doi.org/10.1051/0004-6361:20054333)
    - [Figueira et al 2013](https://www.aanda.org/articles/aa/abs/2013/09/aa20779-12/aa20779-12.html)
    - [Santerne et al 2015](https://doi.org/10.1093/mnras/stv1080)
    - [Lanza et al 2018](https://doi.org/10.1051/0004-6361/201731010)




  - Similar codes were developed by Figueira et al. A&A 557, A93 (2013)
    with a Python package available [here](https://bitbucket.org/pedrofigueira/line-profile-indicators/src/master/)
    (described in Appendix A of Santos et al. A&A 566, A35 (2014))

  - A similar package (in IDL) was developed by Lanza et al. A&A 616, A155 (2018).
    It is available [here](https://www.ict.inaf.it/gitlab/antonino.lanza/HARPSN_spectral_line_profile_indicators).


pkgId: 2df3460e5467106437dce5a0894adc3ab404f78fbe65d5824fd98e9d8d9f546b
name: python-iam-actions-help
arch: noarch
version: 1.2.20241214
epoch: 0
release: 1
summary: Development documents and examples for iam-actions
url: https://github.com/constableapp/iam_actions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iam-actions-1.2.20241214-1.src.rpm
location_href: Packages/python-iam-actions-help-1.2.20241214-1.noarch.rpm
checksum_type: sha256
description:
  `iam_actions` is a python module which contains a dictionary of AWS IAM information. Ideally, it is a complete catalog of all AWS services, actions, and resource types. The information is scraped from the AWS documentation pages.

  Nightly, the scraping service runs, and publishes a new version with the date appended.

  The package is meant to be used as a consumable package, but it also contains the code to generate the definitions for packaging.

  There are three "roots" that you can consume: actions, resource_types, and services. They all currently return as dict's. *However, in a future release, it will be returned as python data structures*



  Actions is a listing of all the actions for a given service. The structure is as follows:
  ```
  {
      "service_name": {
          "action_name: {
              "access_level": access_level,
              "action": action_name,
              "condition_keys": [condition_key1, ...],
              "description": description
          }
      }
  }
  ```

  Therefore, you can find information about an action as follows

  ```
  >>> iam_actions.actions['s3']['GetObject']
  {'access_level': 'Read', 'action': 'GetObject', 'condition_keys': ['s3:AccessPointNetworkOrigin', 's3:DataAccessPointAccount', 's3:DataAccessPointArn', 's3:ExistingObjectTag/<key>', 's3:ResourceAccount', 's3:TlsVersion', 's3:authType', 's3:signatureAge', 's3:signatureversion', 's3:x-amz-content-sha256'], 'description': 'Grants permission to retrieve objects from Amazon S3', 'orphan': False, 'resources': ['object']}
  ```



  Services list information about the service. The structure is as follows:

  ```
  {
      "service_name": {
          "Actions": [action1, ...]
          "ServiceNames": [service_name1, ...]
          "ARNFormats": [arn_format1, ...]
          "ConditionKeys": [condition_key1, ...]
          "HasResource": bool
      }
  }
  ```



  Resource Types list information about the resource types for the service. The structure is as follows:

  ```
  {
      "service_name": {
          "resource_name": {
              "arn_pattern": arn_pattern,
              "condition_keys": [condition_key1, ...]
          }
      }
  }
  ```



  ```python
  import iam_actions

  print(item_actions.services)
  print(item_actions.actions)
  print(item_actions.resource_types)
  ```


pkgId: e42114cd1170bf3c62b7669fd1bad645a9216f3c41224a8b64d6e8bc2a5b0779
name: python-iam-builder-help
arch: noarch
version: 4.11.0
epoch: 0
release: 1
summary: Development documents and examples for iam-builder
url: https://pypi.org/project/iam-builder/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iam-builder-4.11.0-1.src.rpm
location_href: Packages/python-iam-builder-help-4.11.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Publish](https://github.com/moj-analytical-services/iam_builder/actions/workflows/poetry-pypi-release.yml/badge.svg)](https://github.com/moj-analytical-services/iam_builder/actions/workflows/poetry-pypi-release.yml)

  A python script to generate an IAM policy based on a yaml or json configuration.

  To install:

  ```bash

  pip install iam-builder


  pip install git+git://github.com/moj-analytical-services/iam_builder.git#egg=iam_builder
  ```

  To use the command line interface:

  ```bash
  iam_builder -c examples/iam_config.yaml -o examples/iam_policy.json
  ```

  - `-c` is the path to your iam configuration (either a yaml or json file).
  - `-o` is the path to your output iam policy (needs to be a json file).

  Or to do the same thing in python:

  ```python
  import yaml
  import json
  from iam_builder.iam_builder import build_iam_policy

  with open('examples/iam_config.yaml') as f:
    config = yaml.load(f, Loader=yaml.FullLoader)

  iam_policy = build_iam_policy(config)

  with open('examples/iam_policy.json', "w+") as f:
    json.dump(iam_policy, f, indent=4, separators=(',', ': '))
  ```

  Both scripts will create the output iam_policy seen in the [examples](examples/) folder. You can also see [more example configs](tests/test_config/) by looking in the unit tests.

  Your config file can be either a yaml or json file.

  The example yaml (`iam_config.yaml`) looks this:

  ```yaml
  iam_role_name: iam_role_name

  athena:
    write: false

  glue_job: true

  secrets: true

  secretsmanager:
    read_only:
      - test_secret

  s3:
    read_only:
      - test_bucket_read_only/*

    write_only:
      - test_bucket_write_only/*
      - test_bucket_read_only/write_only_folder/*

    read_write:
      - test_bucket_read_write/*
      - test_bucket_read_only/write_folder/*

    deny:
      - test_bucket_read_write/sensitive_table/*

  kms:
    - test_kms_key_arn

  bedrock: true
  ```

  Whilst the example json (`iam_config.json`) looks like this:

  ```json
  {
    "iam_role_name": "iam_role_name",
    "athena": {
      "write": false
    },
    "glue_job": true,
    "secrets": true,
    "s3": {
      "read_only": [
        "test_bucket_read_only/*"
      ],
      "write_only": [
        "test_bucket_write_only/*",
        "test_bucket_read_only/write_only_folder/*"
      ],
      "read_write": [
        "test_bucket_read_write/*",
        "test_bucket_read_only/write_folder/*"
      ]
    },
    "kms": ["test_kms_key_arn"],
    "bedrock": true,
    "cloudwatch_athena_query_executions": true
  }
  ```

  - **iam_role_name:** The role name of your airflow job; required if you want to run glue jobs or access secrets.

  - **athena:** Can have two keys.
    - **write**: Either `true` or `false`. If `false` then only read access to Athena (cannot create, delete or alter tables, databases and partitions). If `true` then the role will also have the ability to do stuff like CTAS queries, `DROP TABLE`, `CREATE DATABASE`, etc.
    - **dump_bucket**: The location in S3 (either an S3 path or a list of S3 paths) for temporarily storing the results of queries. This defaults to `mojap-athena-query-dump` and should not normally need changing.

  - **is_cadet_deployer:** Boolean; Gives access to a highly empowered Glue role for Create-A-Derived-Table deployments. Will fail to apply if the `iam_role_name` doesn't include `cadet` in the string. Gives the user full control over all glue and athena structures in the named account.

  - **glue_job:** Boolean; must be set to `true` to allow role to run glue jobs. If `false` or absent role will not be able to run glue jobs.

  - **secrets:** Boolean or string; must be set to `true` or `"read"` to allow role to access secrets from AWS Parameter Store, and `readwrite` to provide read/write access. If `false` or absent role will not be able to access secrets.

  - **s3:** Can have up to 4 keys: `read_only`, `write_only`, `read_write`, and `deny`. Each key describes the level of access you want your iam policy to have with each s3 path. More details below:

    - **read_only:** A list of s3 paths that the iam_role should be able to access (read only). Each item in the list should either be a path to a object or finish with `/*` to denote that it can access everything within that directory. _Note the S3 paths don't start with `s3://` in the config._

    - **write_only:** A list of s3 paths that the iam_role should be able to access (write only). Each item in the list should either be a path to a object or finish with `/*` to denote that it can access everything within that directory. _Note the S3 paths don't start with `s3://` in the config._

    - **read_write:** A list of s3 paths that the iam_role should be able to access (read and write). Each item in the list should either be a path to a object or finish with `/*` to denote that it can access everything within that directory. _Note the S3 paths don't start with `s3://` in the config._

    - **deny:** A list of s3 paths that the iam_role should _not_ be able to access. This should be used to add exceptions to wildcarded access to folders, for example excluding sensitive tables in order to provide basic access to a database. Each item in the list should either be a path to a object or finish with `/*` to denote that it can access everything within that directory. _Note the S3 paths don't start with `s3://` in the config._

  - **kms:** A list of kms arns that the iam_role should be able to access. Can call the DescribeKey, GenerateDataKey, Decrypt, Encrypt and ReEncrypt
    operations.

  - **secretsmanager:** A secret that the iam_role should be able to access. Can call the GetSecretValue, DescribeSecret and ListSecrets operations.

  - **bedrock:** Boolean; must be set to `true` to allow role to interact with Amazon Bedrock. If `false` or absent role will not be able to interact with Amazon Bedrock.

  - **cloudwatch_athena_query_executions** Boolean; must be set to `true` to allow role to read `cloudtrail-athena-events` log group. If `false` or absent role will not be able to read these cloudwatch logs.



  When updating IAM builder, make sure to change the version number in `pyproject.toml` and describe the change in `CHANGELOG.md`.

  If you have changed any dependencies in `pyproject.yaml`, run `poetry update` to update `poetry.lock`.

  Once you have created a release in GitHub, a Github Action will run to publish the release on PyPI automatically.


pkgId: 79738c835a352f19e50d390a43918778267390b4f8b2ac787b5d2fe271ad8bcb
name: python-iamdata-help
arch: noarch
version: 0.1.202412141
epoch: 0
release: 1
summary: Development documents and examples for iamdata
url: https://github.com/cloud-copilot/iam-data-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iamdata-0.1.202412141-1.src.rpm
location_href: Packages/python-iamdata-help-0.1.202412141-1.noarch.rpm
checksum_type: sha256
description:
  This is a simple package for utilizing AWS IAM data for Services, Actions, Resources, and Condition Keys. Data is embedded in the python package.

  New data is checked against the AWS IAM documentation and updated daily if there are changes.


  ```bash
  pip install iam-data
  ```


  ```python
  from iamdata import IAMData

  iam_data = IAMData()
  print(f"Data Version {iam_data.data_version()} updated at {iam_data.data_updated_at()}")
  for service_key in iam_data.services.get_service_keys():
      service_name = iam_data.services.get_service_name(service_key)
      print(f"Getting Actions for {service_name}")
      for action in iam_data.actions.get_actions_for_service(service_key):
          action_details = iam_data.actions.get_action_details(service_key, action)
          print(f"{service_key}:{action} => {action_details}")
  ```



  * `services.get_service_keys()` - Returns a list of all service keys such as 's3', 'ec2', etc.
  * `services.get_service_name(service_key)` - Returns the service name for a given service key.
  * `services.service_exists(service_key)` - Returns True if the service key exists.


  * `actions.get_actions_for_service(service_key)` - Returns an array of all actions for a given service key.
  * `actions.get_action_details(service_key, action_key)` - Returns an object with the action details such as `description`, `resourceTypes`, and `conditionKeys`.
  * `actions.action_exists(service_key, action_key)` - Returns true if the action exists.


  * `resources.get_resource_types_for_service(service_key)` - Returns an array of all resource types for a given service key.
  * `resources.get_resource_type_details(service_key, resource_type_key)` - Returns an object with the resource type details such as `description`, `arnFormat`, and `conditionKeys`.
  * `resources.resource_type_exists(service_key, resource_type_key)` - Returns true if the resource type exists.


  * `conditions.get_condition_keys_for_service(service_key)` - Returns an array of all condition keys for a given service key.
  * `conditions.get_condition_key_details(service_key, condition_key)` - Returns an object with the condition key details such as `description`, `conditionValueTypes`, and `conditionOperators`.
  * `conditions.condition_key_exists(service_key, condition_key)` - Returns true if the condition key exists.


  The version is number is formatted as `major.minor.updatedAt`. The updatedAt is the date the data was last updated in the format `YYYYMMDDX` where `X` is a counter to enable publishing more than once per day if necessary. For example version `0.1.202408291` has data updated on August 29th, 2024.

  The version can be accessed using the `data_version()` method.

  There is also `date_updated_at()` which returns the date the data was last updated.


pkgId: d65e2b5f09fe95c5bcc9988703c8a625bf52e682079acf72640057acd21ab5b1
name: python-iaparc-inference-help
arch: noarch
version: 0.6.4
epoch: 0
release: 1
summary: Development documents and examples for iaparc-inference
url: https://gitlab.com/ia-parc/public/pypi/iaparc_inference
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iaparc-inference-0.6.4-1.src.rpm
location_href: Packages/python-iaparc-inference-help-0.6.4-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/iaparc-inference.svg)](https://badge.fury.io/py/iaparc-inference)
  ![PyPI - License](https://img.shields.io/pypi/l/iaparc-inference)


  The IA Parc inference plugin allows developers to easily integrate their inference pipeline into IA Parc's production module.




  ```bash
  pip install iaparc-inference
  ```



  * If your inference pipeline support batching:

      ```python
      from iaparc_inference import IAPListener

      
      
      class MyModel:
          def __init__(self, model_path: str):
              

          def batch_query(batch: list, parameters: Optional) -> list:
              ''' execute your pipeline on a batch input
                  Note:   "parameters" is an optional argument.
                          It can be used to handle URL's query parameters
                          It's a list of key(string)/value(string) dictionaries
              '''

      if __name__ == '__main__':
          
          my_model = MyModel("path/to/my/model")

          
          listener = IAPListener(my_model.batch_query)
          
          listener.run()

      ```
  * If your inference pipeline **do not** support batching:

      ```python
      from iaparc_inference import IAPListener

      
      
      class MyModel:
          def __init__(self, model_path: str):
              

          def single_query(one_input, parameters: Optional):
              ''' execute your pipeline on a single input
                  Note:   "parameters" is an optional argument.
                          It can be used to handle URL's query parameters
                          It's a key(string)/value(string) dictionary
              '''

      if __name__ == '__main__':
          
          my_model = MyModel("path/to/my/model")

          
          listener = IAPListener(my_model.single_query, batch=1)  # Note that batch size is forced to 1 here
          
          listener.run()


  * Dynamic batching
  * Autoscalling
  * Support both synchronous and asynchronous queries
  * Data agnostic



  This project is licensed under the Apache License Version 2.0  - see the Apache [LICENSE](https://www.apache.org/licenses/LICENSE-2.0) file for details.


pkgId: 8691e0eb85bc2d383cb94e3737bef16049cd31b258accb552b2a69401d72ac56
name: python-iaptoolkit-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for iaptoolkit
url: https://pypi.org/project/iaptoolkit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iaptoolkit-0.3.1-1.src.rpm
location_href: Packages/python-iaptoolkit-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  A library of utils to ease programmatic authentication with Google IAP (and ideally other IAPs in future).


  https://pypi.org/project/iaptoolkit/



  `poetry add iaptoolkit`


  `pip install iaptoolkit`



  ```python
  import requests

  from iaptoolkit import IAPToolkit

  iaptk = IAPToolkit(google_iap_client_id="EXAMPLE_ID_123456789ABCDEF")
  allowed_domains = ["example.com", ]



  def example1(url: str):
      headers = dict()
      result = iaptk.check_url_and_add_token_header(
          url=url,
          request_headers=headers,
          valid_domains=allowed_domains
      )
      
      

      
      response = requests.request("GET", url, headers=headers)



  def example1(url: str):
      is_url_safe: bool = iaptk.is_url_safe_for_token(url=url, valid_domains=valid_domains)

      if not is_url_safe:
          raise ExampleBadURLException("This URL isn't safe to send token headers to!")

      headers = dict()
      token_is_fresh: bool = iaptk.get_token_and_add_to_headers(request_headers=headers)
      
      

      
      response = requests.request("GET", url, headers=headers)

  ```



  This project is not affiliated with Google. No trademark infringement intended.


pkgId: cab7b16377ad6d78af49c8418c1f30277a862ebf31c6761b7d8556c34956dd0e
name: python-ibek-help
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Development documents and examples for ibek
url: https://pypi.org/project/ibek/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ibek-3.1.0-1.src.rpm
location_href: Packages/python-ibek-help-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  |code_ci| |docs_ci| |coverage| |pypi_version| |black| |license|
  This tool supports building container images for Generic EPICS IOCs and
  generating IOC Instances from those Generic IOCs at container runtime. It is
  targetted at running IOCs in Kubernetes, but the images it

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 rechange_linter_to_ruff 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 {yyyy} {name of copyright owner}  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: 3ad3f6663fa8ce0f15d761101236cdf4616d02c171a9068c6dccaad1201756f9
name: python-ibm-cloud-fail-over-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for ibm-cloud-fail-over
url: https://github.com/gampel/ibm_cloud_fail_over
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ibm-cloud-fail-over-0.0.3-1.src.rpm
location_href: Packages/python-ibm-cloud-fail-over-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  ```markdown





  IBM Cloud Fail Over is a Python module designed to automate failover processes for applications hosted on IBM Cloud. This module provides essential functions to manage failover scenarios effectively, ensuring high availability and reliability.



  - **Automated Failover**: Seamlessly switch to backup resources when primary resources are unavailable.
  - **Resource Management**: Manage critical resources like Virtual IPs and Floating IPs with ease.



  You can install the IBM Cloud Fail Over module using pip. Run the following command:

  ```bash
  pip install ibm_cloud_fail_over
  ```







  This function manages the failover of a Cloud Resource Virtual IP (CR VIP).

  **Usage:**

  ```python
  from ibm_cloud_fail_over import fail_over_cr_vip


  result = fail_over_cr_vip(vpc_url='IBM Cloud VPC regional URL",
                             primary_vip='your_primary_vip',
                             secondary_vip='your_secondary_vip',
                             api_key="Optional: API key" )
  print(result)
  ```

  **Parameters:**

  | Parameter          | Type   | Description                                      |
  |--------------------|--------|--------------------------------------------------|
  | `vpc_url    `      | str    | IBM Cloud VPC regional URL.                      |
  | `primary_vip`      | str    | The primary Virtual IP to monitor.               |
  | `secondary_vip`    | str    | The secondary Virtual IP to switch to.           |
  | `api_key`          | str    | Optional needed only if you are not using trusted|
                                   profile, IBM cloud api acsess key               |

  **Returns:**

  - A confirmation message indicating the success or failure of the failover operation.



  This function manages the failover of a Floating IP.

  **Usage:**

  ```python
  from ibm_cloud_fail_over import fail_over_floating_ip


  result = fail_over_floating_ip((vpc_url='IBM Cloud VPC regional URL",
                                  master_vni_id="Virtual network inetface uuid for new active",
                                  passive_vni_id="Virtual network inetface uuid for new passive" ,
                                  fip_id="teh floating ip uuid",
                                  api_key="Optional: API key" ))
  print(result)
  ```

  **Parameters:**

  | Parameter          | Type     | Description                                      |
  |--------------------|----------|--------------------------------------------------|
  | `vpc_url    `      | str(url) | IBM Cloud VPC regional URL.                      |
  | `master_vni_id`    | str(uuid)| Virtual network inetface uuid for new active.    |
  | `passive_vni_id`   | str(uuid)| Virtual network inetface uuid for new active.    |
  | `fip_id        `   | str(uuid)| Floating IP uuid to move.    |
  | `api_key`          | str      | Optional needed only if you are not using trusted|
                                     profile, IBM cloud api acsess key               |
  **Returns:**

  - A confirmation message indicating the success or failure of the failover operation.



  If you encounter issues while using the module, consider the following:

  - **Invalid IP Addresses**: Ensure that the IP addresses provided for primary and secondary resources are valid and reachable.
  - **Network Issues**: Check your network connectivity to the IBM Cloud resources.
  - **Permissions**: Ensure that your IBM Cloud account has the necessary permissions to manage the specified resources.
  - **Required dependencies**: Enable [Instance Metada Service](https://cloud.ibm.com/docs/vpc?topic=vpc-imd-configure-service&interface=ui) on Both Enpoints
  - **Optional dependencies**: Enable [Trusted profile](https://cloud.ibm.com/docs/vpc?topic=vpc-imd-trusted-profile-metadata&interface=ui) to avoid using and api access key



  For further assistance, please check the [GitHub Issues](https://github.com/gampel/ibm_cloud_fail_over/issues) page or contact the project maintainer.



  We welcome contributions! To contribute to the project, please follow these steps:

  1. Fork the repository.
  2. Create a new branch (`git checkout -b feature/YourFeature`).
  3. Make your changes and commit them (`git commit -m 'Add some feature'`).
  4. Push to the branch (`git push origin feature/YourFeature`).
  5. Create a new Pull Request.



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



  For questions or support, please open an issue on GitHub or contact the project maintainer at [dev@gampel.net](mailto:dev@gampel.net).

  ```


pkgId: d711f7c62a724473b1a9efe91269e25415f9e44678d77e5b1cdfbed3773e8a66
name: python-ibson-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for ibson
url: https://github.com/eulersIDcrisis/ibson
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ibson-0.0.5-1.src.rpm
location_href: Packages/python-ibson-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  BSON (Binary JSON) parsing library.



  This library is designed to implement a basic BSON library with an interface
  that is similar to python's native JSON parsing library. In particular, this
  has expected usage:
  ```python
  import ibson


  obj = {
      "a": {
          "b": [1, 2, 3],
          "uuid": uuid.uuid1()
      }
  }

  buffer = ibson.dumps(obj)
  new_obj = ibson.loads(buffer)


  new_obj == obj
  ```

  This mimics the existing `bson` library for python, but also permits reading
  from and writing to (seekable) streams and files as well:
  ```python

  with open('file.bson', 'wb') as stm:
      ibson.dump(obj, stm)


  with open('file.bson', 'rb') as stm:
      new_obj = ibson.load(stm)


  new_obj == obj
  ```
  NOTE: It is important that the file is opened in binary mode, not text mode!

  Under the hood, this library is designed in a similar manner as a SAX-style
  event-driven parser; it avoids explicit recursion wherever possible and has
  calls that permit iterating over the contents using generators with an
  interface that can even permit skipping keys/fields altogether. Since the
  parsing stack is maintained separately, it can also be used to verify and
  attempt to fix some issues.



  This library works by noting that the byte offset needed in a few places to
  (de)serialize BSON is already implicitly tracked in seekable streams via the
  call to: `fp.tell()`, omitting the need to track the byte counts directly.
  In places where these byte counts are not directly accessible, the caller is
  likely already loading the content into a bytearray or binary stream that can
  become seekable anyway. When this field is needed before the value is actually
  available (i.e. the `length` of a document before the document is written),
  this simply registers the position the length needs to be written, writes out
  a placeholder value (0), then retroactively writes out these lengths when they
  finally are known, hence the need for the writable stream to also be seekable.
  (As a slight optimization, these lengths are sorted and written from the start
  to the end of the file again when the encoder is done to effectively make to
  sequential passes instead of an arbitrary number of random-access passes.)

  This library also strives to reduce memory-consumption as best as reasonable
  with an iterative parser, intentionally avoiding recursion where possible; the
  parser tracks the stack on the heap and also stores various fields internally
  so as to avoid loading everything parsed into memory when just traversing the
  document, in a manner analogous to SAX-style parsers for XML. (When decoding
  and storing the document as a python `dict`, yes, that will be in memory.)


pkgId: 62697539672192ddc31514ede76fec081871c316a72c398b0856fc53348b297d
name: python-icalcli-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for icalcli
url: https://github.com/jrvarma/icalcli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-icalcli-1.1.3-1.src.rpm
location_href: Packages/python-icalcli-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  `icalcli` - a modification of [gcalcli](https://github.com/insanum/gcalcli) - is a Python command line front-end to your Calendar. It allows you to get your agenda, view weekly and monthly calendars (ascii text graphical calendar), search for events, add new events, delete events, and edit events.

  Unlike [gcalcli](https://github.com/insanum/gcalcli) which is tied to Google Calendar, `icalcli` is agnostic to (abstracts away from) the actual backend calendar service. It relies on a backend interface which interacts with the backend calendar to perform all the CRUD (Create, Retrieve, Update and Delete) operations on the actual calendar. The package includes two backends:

  * The `etesync_backend` subpackage provides a backend interface to the [EteSync](https://www.etesync.com/) calendar (versions 1.0 and 2.0). In fact, `icalcli` was created primarily to provide a command line interface to my self hosted `EteSync` calendar.

  * The `file_backend` subpackage provides a backend interface to a calendar contained in a local `ics` file. This is useful as a viewer/editor of `ics` files. It is also useful to try out `icalci` without having any other backend configured.

  The two included backends would also be useful to those who wish to write their own backend interfaces. `icalcli` requires the calendar to be presented to it as a list of [icalendar](https://github.com/collective/icalendar) events (`VEVENT`). It is the responsibility of the backend interface to read the actual calendar and create this list of events. It must also perform all the CRUD (Create, Retrieve, Update and Delete) operations on the actual calendar.




  * [Python](http://www.python.org) (3+)
  * [dateutil](http://www.labix.org/python-dateutil)
  * [parsedatetime](https://github.com/bear/parsedatetime)
  * [icalendar](https://github.com/collective/icalendar)
  * A love for the command line!



  * [pyetesync](https://github.com/etesync/pyetesync) the python client library for `EteSync` if you want to use the `EteSync` backend.





  ```sh
  pip install icalcli
  ```

  or via `pipx`:

  ```sh
  pipx install icalcli
  ```



  ```sh
  git clone https://github.com/jrvarma/icalcli.git
  cd icalcli
  python setup.py install
  ```

  or via `pipx`:

  ```sh
  pipx install . --editable
  ```





  `icalcli` provides a series of subcommands with the following functionality:

      edit (e)               edit calendar events
      agenda (g)             get an agenda for a time period
      calw (w)               get a week-based agenda in calendar format
      cal5w (5w)             get this week / 2 past / 2 future weeks agenda in calendar format
      calm (m)               get a month agenda in calendar format
      add (a)                add a detailed event to the calendar
      search (s)             (regex) search for events
      sync (y)               sync the backend calendar
      quit (q)               quit icalcli

  By default, `icalcli` runs interactively as an REPL (Read Evaluate Print Loop). Run `icalcli --help` for more details. `icalcli <subcommand> --help` gives help on each subcommand.



  In the beginning, `icalcli` executes a configuration script which is expected to create the object `backend_interface` representing the backend interface initialized with the right authentication credentials to access the backend calendar. The configuration script is located, by default, at `~/.icalcli.py`, but this can be changed with the `-c` option.



  ```
  from icalcli import ICSInterface

  backend_interface = ICSInterface("/path/to/ics-file")

  ```



  ```
  from icalcli import ICSInterface

  backend_interface = ICSInterface(["/path/to/ics-file-1", "/path/to/ics-file-2"])

  ```



  This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.

  ```
  from icalcli import EtesyncInterface
  import base64
  import json

  conf_file = '/path/to/json-file'
  with open(conf_file, 'r') as fp:
      c = json.load(fp)
  backend_interface = EtesyncInterface(
      c['email'], c['userPassword'], c['remoteUrl'],
      c['uid'], c['authToken'],
      base64.decodebytes(c['cipher_key'].encode('ascii')))
  ```
  See the [Example code](https://github.com/jrvarma/icalcli/issues/1#issuecomment-979851222) for getting the  `uid` and `authToken` for the `etesync` calendar.



  This configuration assumes that all the credentials are stored in a plain text (`json`) file. In practice, you would use a more secure storage (perhaps, the `Gnome keyring`) or just read it from the terminal.

  ```
  from icalcli import EtebaseInterface
  import json

  conf_file = '/path/to/json-file'
  with open(conf_file, 'r') as fp:
      c = json.load(fp)

  backend_interface = EtebaseInterface(c['user'], c['server_url'], c['password'],
                                       c['calendar_uid'], silent=False)
  ```

  The `calendar_uid` can be obtained using the following code. This code assumes that the `dict c` has been populated with the credentials from the `json` file as above.

  ```
  from etebase import Client, Account, FetchOptions

  client = Client(c['user'], c['server_url'])
  etebase = Account.login(client, c['user'], c['password'])
  col_mgr = etebase.get_collection_manager()
  print({col.uid: col.meta
        for col in col_mgr.list("etebase.vevent").data})
  ```



  `icalcli` understands the `RRULE`, `RDATE`, `EXRULE`, `EXDATE` elements of the `icalendar` specification. These elements can be added while creating or editing events using `--rrule`, `--rdate`, `--exrule` and `--exdate` options.

  In most views, the instances of the recurring event are displayed. Since a recurring event can have an unlimited number of instances, searches with no start or end date can produce an unending series of events. By default therefore searches with no start or end date are limited to the previous five years and following five years. These defaults can be changed using the options ` --default_past_years` and `--default_future_years`



  The `icalendar` specification is quite large and complex, and `icalcli` implements only the most common parts of this specification. It is possible to use the `--raw_ics` option to create/edit event using raw ICS text.



  Some screenshots are available at Github:



  ![Agenda and Week Views]( https://github.com/jrvarma/icalcli/raw/master/screenshots/icalci-0-agenda-week-views.png)



  ![Adding an event](https://github.com/jrvarma/icalcli/raw/master/screenshots/icalci-1-add-event.png)



  ![Searching and editing events](https://github.com/jrvarma/icalcli/raw/master/screenshots/icalci-2-search-edit-event.png)



  ![Multi-day events](https://github.com/jrvarma/icalcli/raw/master/screenshots/icalci-3-multi-day-event.png)



  ![Month View](https://github.com/jrvarma/icalcli/raw/master/screenshots/icalci-4-month-view.png)


pkgId: 9428a08425cd8ac34dce70a74a04060d41090b86a20c16961cc3bb279ea06d7e
name: python-icecomet-help
arch: noarch
version: 3.1.5
epoch: 0
release: 1
summary: Development documents and examples for icecomet
url: https://github.com/yourusername/my_library
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-icecomet-3.1.5-1.src.rpm
location_href: Packages/python-icecomet-help-3.1.5-1.noarch.rpm
checksum_type: sha256
description:
  - [มีอะไรในไลบราลี่นี้](#มีอะไรในไลบราลี่นี้)
    - [icolor คืออะไร](#icolor-คืออะไร)
    - [iterText คืออะไร](#itertext-คืออะไร)
    - [iprint คืออะไร](#iprint-คืออะไร)
    - [ibotClick คืออะไร](#ibotclick-คืออะไร)
    - [ipandas คืออะไร](#ipandas-คืออะไร)
  - [วิธีการใช้งานแต่ละโมดูล](#วิธีการใช้งานแต่ละโมดูล)
    - [เกี่ยวกับแท็กพิเศษสำหรับการแสดงผลข้อความ (ANSI escape code :\033)](#เกี่ยวกับแท็กพิเศษสำหรับการแสดงผลข้อความ (ANSI escape code :\033))
    - [การใช้งาน icolor](#icolor)
    - [การใช้งาน iterText](#itertext)
    - [การใช้งาน iprint](#iprint)
    - [การใช้งาน ibotClick](#ibotclick)
    - [การใช้งาน ipandas](#ipandas)
  - [ประวัติการอัพเดต](#ประวัติการอัพเดต)
  - [รายละเอียดผู้พัฒนา](#รายละเอียดผู้พัฒนา)



  `icecomet project` คือไลบราลี่ที่รวมโมดูลของคำสั่งที่ใช้งานบ่อย โดยประกอบด้วย 5 โมดูล ดังนี้:


  `icolor` เป็นโมดูลที่ช่วยในการจัดการสีของข้อความในเทอร์มินัล (เช่น การทำข้อความเป็นสีแดง, เขียว, หรือสีอื่น ๆ) เพื่อช่วยในการสร้างข้อความที่ดูน่าสนใจหรือเพื่อเน้นความสำคัญ. โดยรวมแท็กพิเศษสำหรับหรับเปลี่ยนสีตัวอักษรไว้ในออบเจค color_text หรือ ct เช่น `ct.red` จะเก็บค่าของ `'\033[91m'` ซึ่งทำให้ข้อความเป็นสีแดง


  `iterText` ใช้ในการขยับเคอร์เซอร์ ทำให้แก้ไขข้อความที่ถูกปริ้นออกมาบนเทอร์มินัลแล้วได้ ใช้หลักการเดียวกับ icolor โดยรวมแท็กที่ใช้ ไว้ในออบเจค cursor_control หรือ cc สามารถดูวิธีใช้ฉบับเต็มใด้ที่หัวข้อ - [วิธีการใช้งานแต่ละโมดูล](#วิธีการใช้งานแต่ละโมดูล)>[iterText](#itertext) (เมื่อนำเข้าโมดูลนี้ ตัวออบเจค ct ที่อยู่ใน icolor จะถูกนำเข้ามาด้วย เนื่องจากมีการทำงานที่ใกล้เคียงกัน)


  `iprint` จะเพิ่มคำสั่งที่ใช้บ่อยในการดีบั๊ก และจัดรูปแบบให้ใช้งานง่ายขึ้น เช่น ij('variable','t') ซึ่งเท่ากับ print(type('variable')) หรือ ij('variable','l') ที่เท่ากับ print(len('variable')) และนอกจากนี้ยังมีฟังก์ชั่นพิเศษที่ใช้ตรวจจับการรันโค้ด ว่าตอนนี้กำลังทำงานอยู่ที่จุดไหน ด้วยวิธีนี้ทำให้สามารถเช็คข้อมูลเกี่ยวกับตัวแปรหรือจุดที่มีปัญหาใด้อย่างรวดเร็ว สามารถดูวิธีใช้ฉบับเต็มใด้ที่หัวข้อ - [วิธีการใช้งานแต่ละโมดูล](#วิธีการใช้งานแต่ละโมดูล)>[การใช้งาน iprint](#iprint)


  `ibotClick` จะรวมฟังก์ชั่นเกี่ยวกับการทำงานอัตโนมัติ เช่นคำสั่ง คลิกขวาที่พิกัด(x,y) , กดปุ่ม(xxx) บนคีย์บอร์ด โดยใช้ Library `pynput` - [วิธีการใช้งานแต่ละโมดูล](#วิธีการใช้งานแต่ละโมดูล)>[การใช้งาน ibotClick](#ibotclick)


  `ipandas` กำลังอยู่ระหว่างการพัฒนา ตอนนี้มีฟังก์ชั่นเดียวคือการแปลง dataframe ให้เป็น dictionary แบบที่ใช้ประกาศ dataframe




  โมดูล `icolor` ช่วยให้สามารถปรับแต่งสีของข้อความในเทอร์มินัลได้ตามต้องการ:

  ```python
  from icolor import icolor


  icolor.red("ข้อความสีแดง")
  icolor.green("ข้อความสีเขียว")


pkgId: c8ee1ededfcfa3cf5f2c01360890cca225febce2763230afc16218696bd84833
name: python-icemedia-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for icemedia
url: https://pypi.org/project/icemedia/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-icemedia-0.1.9-1.src.rpm
location_href: Packages/python-icemedia-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  More comfortable wrapper for gstreamer and JACK




  ```
  pip install icemedia
  ```





  ```python
  import icemedia.sound_player

  testmedia = "YourAudioFileHere.mp3"

  icemedia.sound_player.play_sound(testmedia)
  time.sleep(3)
  ```

  The icemedia.sound_player.sound uses MPV to play sounds, so it supports almost any file.



  Spins up a paused player for that filename and player. Garbage collecting old cache entries is handled for you.
  Will be used when sound.play is called for the same filename and output.




  Fades the current sound on a given channel to the file. **kwargs aare equivalent to those on playSound.

  Passing none for the file allows you to fade to silence, and if no sound is playing. it will fade FROM silence.

  Block will block till the fade ends. Detach lets you keep the faded copy attached to the handle(Which makes it end when a new sound plays,
  so it only makes sense if fading to silence).

  Fading is perceptually linear.




  The handle parameter lets you name the new sound instance to
  stop it later or set volume.

  If you try to play a sound under the same handle as a
  stil-playing sound, the old one will be stopped. Defaults to PRIMARY.


  Volume is a dimensionless multiplier. Start and end times are in seconds,
  negative means relative to sound end. Start and end times are also
  SOX/mplayer specific and are ignored(full sound will always play) with
  other players.


  Output is a jack client or port if JACK is running.  Currently only the default
  outout works on non-jack systems.




  Stop a sound by handle.



  Stop all currently playing sounds.



  Return true if a sound with handle handle is playing. Note that the
  sound might finish before you actually get around to doing anything with
  the value. If using the dummy backend because a backend is not
  installed, result is undefined, but will not be an error, and will be a
  boolean value. If a sound is paused, will return True anyway.



  Set the volume of a sound. Volume goes from 0 to 1.



  Pause a sound. Does nothing if already paused.



  Resume a paused a sound. Does nothing if not paused.




  This submodule requires pyjack, and of course Jack.



  This uses both JACK and GStreamer

  ```python
  import time
  import icemedia.jack_tools
  import icemedia.iceflow

  "Only works if your device names match, may need to change Built-in Audio Analog Stereo to something else"

  icemedia.jack_tools.start_managing()


  class Player(icemedia.iceflow.GstreamerPipeline):
      def __init__(self):
          icemedia.iceflow.GstreamerPipeline.__init__(self, realtime=False)
          self.src = self.add_element("audiotestsrc")
          self.sink = self.add_element("jackaudiosink", client_name="JackTest", connect=0)

  p = Player()
  p.start()

  print("You should hear noise")
  aw = icemedia.jack_tools.Airwire("JackTest", "Built-in Audio Analog Stereo")
  aw.connect()
  time.sleep(1)
  print("No more noise")
  aw.disconnect()

  del aw
  gc.collect()
  time.sleep(1)
  ```



  Call this to try to connect to the JACK server.  None of the other commands will work until you do this.



  Return an Airwire object. This is a declaration that you want to connect two clients or ports and keep them connected.
  If you try to connect a client to a single port, all outputs get mixed down. Likewise a port to a client duplicates to all inputs.

  They start in the disconnected state.



  Connect and stay connected. Even if a client dissapears and comes back. Deleting the Airwire will disconnect.
  Note that manually disconnecting may not be undone, to prevent annoyance.


  Disconnect.




  This submodule posts the following messages to the [Scullery](https://github.com/EternityForest/scullery) message bus.


   A PortInfo object with a .name, isInput, and isOutput property gets posted here whenever a new port is added to JACK.


   A PortInfo object gets posted here whenever a port is unregistered.


  When jack is started or restarted


  Start the worker thread and enable management functions




  This is a wrapper around GStreamer that handles a lot of the more obnoxious parts for you.
  You'll need to install Gstreamer and it's bindings yourself, they are not in Pip.

  To do this on debian-based systems, try these packages on apt, you only
  need the plugins you actually want to use. GStreamer also will use any LADSPA plugins it finds.

   - python3-gi
   - python3-gst-1.0
   - gstreamer1.0-plugins-good
   - gstreamer1.0-plugins-bad
   - gstreamer1.0-plugins-ugly




  This example shows a window full of noise

  ```python
  import time
  import icemedia.iceflow


  class NoiseWindow(icemedia.iceflow.GstreamerPipeline):
      def __init__(self):
          icemedia.iceflow.GstreamerPipeline.__init__(self)
          self.add_element("videotestsrc", pattern="snow")
          self.add_element("autovideosink")


  n = NoiseWindow()
  n.start()
  print("started")


  time.sleep(5)
  n.stop()
  ```


  This is the base class for making GStreamer apps



  Adds an element to the pipe and returns a weakref proxy. Normally, this will connect to the last added
  element, but you can explicitly pass a an object to connect to.

  If auto_insert_audio_convert is set, then if connecting the elements fails,
  will retry with an audioconvert element in between.

  if connect_when_available is True, then the elements will be connected later,
  at runtime, when the pad exists.  This is needed for some Gst elements that have dynamic pads.

  The `**kwargs` are used to set properties of the element.

  This function returns an ElementProxy.  It acts like a GStreamer element but it is actually
  a proxy object, because the actual pipeline is in a separate background process.



  Set a key on the element.


  Adds a PILCapture object which acts like a video sink. It will buffer the most recent N frames, discarding as needed.


  Return a video frame as a PIL/Pillow Image. May return None on empty buffers.


  Set a prop of an element, with some added nice features like converting strings to GstCaps where needed, and checking that filesrc locations are actually
  valid files that exist.


  Used for subclassing. Called when a message that has a structure is seen on the bus. Source is the GST elemeny, struct is dict-like, and name is a string.


  If paused, start. If never started, raise an error.


  Start running



  Permanently stop and clean up.



  What it sounds like



  Return True if playing or paused


  Seek to a time, set playback rate, or both.




  Subclass this if you want to add a level element and recieve info about the volume.


      A MultiFileSink made a new file


      A barcode reader element has detected a barcode


pkgId: 19cd94c03249ee25136d7c1be81275c126fccde5baf85c324ff66be88bad99b5
name: python-ideastatica-connection-api-help
arch: noarch
version: 24.1.2.1474
epoch: 0
release: 1
summary: Development documents and examples for ideastatica-connection-api
description: API for designing steel connections
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ideastatica-connection-api-24.1.2.1474-1.src.rpm
location_href: Packages/python-ideastatica-connection-api-help-24.1.2.1474-1.noarch.rpm
checksum_type: sha256
url:
  https://github.com/idea-statica/ideastatica-public/tree/main/src/api-sdks/connection-api/clients/python


pkgId: 0ac0684e6671fa6b1e42da3f05822451bbdb13895e5078924aa12d0f74084fd7
name: python-ideastatica-rcs-api-help
arch: noarch
version: 24.1.2.1474
epoch: 0
release: 1
summary: Development documents and examples for ideastatica-rcs-api
url: https://pypi.org/project/ideastatica-rcs-api/
rpm_license: IDEA StatiCa License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ideastatica-rcs-api-24.1.2.1474-1.src.rpm
location_href: Packages/python-ideastatica-rcs-api-help-24.1.2.1474-1.noarch.rpm
checksum_type: sha256
description:
      IDEA StatiCa RCS API, used for the automated design and calculation of reinforced concrete sections.


pkgId: e7f4cb1da5bc63c44c4ca9931e10a8edb3d8b6d56290a5784e6ed7f217979e83
name: python-idefix-cli-help
arch: noarch
version: 6.0.1
epoch: 0
release: 1
summary: Development documents and examples for idefix-cli
url: https://github.com/neutrinoceros/idefix_cli
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-idefix-cli-6.0.1-1.src.rpm
location_href: Packages/python-idefix-cli-help-6.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/idefix_cli.svg?logo=pypi&logoColor=white&label=PyPI)](https://pypi.org/project/idefix-cli/)
  [![Documentation Status](https://readthedocs.org/projects/idefix-cli/badge/?version=latest)](https://idefix-cli.readthedocs.io/en/latest/?badge=latest)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/neutrinoceros/idefix_cli/main.svg)](https://results.pre-commit.ci/badge/github/neutrinoceros/idefix_cli/main.svg)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)



  `idefix_cli` is a command line utility belt for [Idefix](https://github.com/idefix-code/idefix).

  It defines a `idfx` command familly. The builtin command set (`idfx conf`, `idfx run`,
  ...) can be extended to include arbitrary helper scripts.




  `idefix_cli` is distributed via the Python Packaging Index (PyPI).

  It is recommended to install this tool at the system level, but still in isolation,
  using for instance [`uv`](https://docs.astral.sh/uv/) as
  ```shell
  $ uv tool install idefix-cli
  ```
  or [`pipx`](https://pipxproject.github.io/pipx/)
  ```shell
  $ pipx install idefix-cli
  ```

  Otherwise, the most portable way to install the latest stable version is
  ```shell
  $ python -m pip install --user idefix_cli
  ```

  Note that most `idfx` commands explicitly require that the env variable `$IDEFIX_DIR` be
  set at runtime.



  Get a complete description of available commands with
  ```shell
  $ idfx --help
  ```
  Likewise, get help for each command therein as, for instance
  ```shell
  $ idfx run --help
  ```

  For more, read [the documentation !](https://idefix-cli.readthedocs.io/en/latest/?badge=latest)


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

  The Identety Python library provides convenient access to the Identety 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 [docs.identety.com](https://docs.identety.com). The full API of this library can be found in [api.md](https://github.com/identety/identety-python-sdk/tree/main/api.md).



  ```sh

  pip install --pre identety
  ```



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

  ```python
  from identety import Identety

  client = Identety()

  client = client.clients.create(
      name="name",
      type="public",
  )
  print(client.id)
  ```

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



  Simply import `AsyncIdentety` instead of `Identety` and use `await` with each API call:

  ```python
  import asyncio
  from identety import AsyncIdentety

  client = AsyncIdentety()


  async def main() -> None:
      client = await client.clients.create(
          name="name",
          type="public",
      )
      print(client.id)


  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 `identety.APIConnectionError` is raised.

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

  All errors inherit from `identety.APIError`.

  ```python
  import identety
  from identety import Identety

  client = Identety()

  try:
      client.clients.create(
          name="name",
          type="public",
      )
  except identety.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except identety.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except identety.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 identety import Identety


  client = Identety(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).clients.create(
      name="name",
      type="public",
  )
  ```



  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 identety import Identety


  client = Identety(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).clients.create(
      name="name",
      type="public",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/identety/identety-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 `IDENTETY_LOG` to `info`.

  ```shell
  $ export IDENTETY_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 identety import Identety

  client = Identety()
  response = client.clients.with_raw_response.create(
      name="name",
      type="public",
  )
  print(response.headers.get('X-My-Header'))

  client = response.parse()  # get the object that `clients.create()` would have returned
  print(client.id)
  ```

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

  The async client returns an [`AsyncAPIResponse`](https://github.com/identety/identety-python-sdk/tree/main/src/identety/_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.clients.with_streaming_response.create(
      name="name",
      type="public",
  ) 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 identety import Identety, DefaultHttpxClient

  client = Identety(
      
      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/identety/identety-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 identety
  print(identety.__version__)
  ```



  Python 3.8 or higher.



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


pkgId: c0dd45abc1a9a8b251ccf8e41a235c133afb1f4f422eab30b0f5ef8336b2721f
name: python-identity-client-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for identity-client
url: https://pypi.org/project/identity-client/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-identity-client-1.1.2-1.src.rpm
location_href: Packages/python-identity-client-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Client lib for the identity service



  Since we don't have a CI/CD pipeline set up right now. You'll have to follow the following steps to release

  1. Do your changes
  2. Install `bumpversion` and `twine`
  ```
  pip install twine bumpversion
  ```
  3. Bump the version using `bumpversion`
  ```
  bumpversion patch
  ```
  4. A commit should be made automatically, just push
  ```
  git push
  ```
  5. Build using setup.py
  ```
  python setup.py sdist
  ```
  6. Push to pypi using twine
  ```
  twine upload dist/*
  ```
  Use `1password` to find the credentials for pypi.

  In order to upload, we have 2FA and the following needs to be done:
  - username should be "\_\_token__"
  - password should be the Access Token value


pkgId: 53088aa6813696cd2d3a1853416194b18978cb0db4c358f3cfa3bf1b8c15064f
name: python-ididi-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for ididi
url: https://pypi.org/project/ididi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ididi-1.1.3-1.src.rpm
location_href: Packages/python-ididi-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://raceychan.github.io/ididi" target="_blank"> https://raceychan.github.io/ididi </a>


pkgId: 0e47c0b8feb5248387cba72e35d143ac7b134b3d4a948ddb6cd551a690ca5472
name: python-idp-async-client-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for idp-async-client
url: https://github.com/SifatIbna/idp-async-client.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-idp-async-client-0.1.0-1.src.rpm
location_href: Packages/python-idp-async-client-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - [Overview](#overview)
  - [Installation](#installation)
  - [Getting Started](#getting-started)
  - [Authentication](#authentication)
  - [Token Management](#token-management)
  - [Role-Based Access](#role-based-access)
  - [Session Management](#session-management)
  - [Web Integration](#web-integration)
  - [Configuration](#configuration)
  - [Error Handling](#error-handling)
  - [API Reference](#api-reference)
  - [FAQ](#faq)



  IdP Async Client is a Python library that provides a unified interface for interacting with Identity Providers (IdPs). It currently supports Keycloak with plans to expand to other IdP solutions.


  - Async/await support
  - Token verification & management
  - Session handling
  - Role-based access control
  - Web framework integration
  - Extensible IdP support



  ```bash
  pip install idp-async-client
  ```





  ```python
  from idp_async_client import IdPClient, IdPConfig


  config = IdPConfig(
      provider="keycloak",
      server_url="http://localhost:8080",
      realm_name="my-realm",
      client_id="my-client",
      client_secret="my-secret"
  )


  client = IdPClient(config)
  ```



  ```python

  async def test_connection():
      is_available = await client.test_connection()
      print(f"IdP server is {'available' if is_available else 'unavailable'}")
  ```





  ```python

  async def login():
      try:
          tokens = await client.login_with_password(
              username="user@example.com",
              password="secure_password"
          )
          return tokens
      except AuthenticationError as e:
          print(f"Login failed: {e}")
  ```



  ```python

  async def social_login():
      tokens = await client.login_with_social(
          subject_token="social-provider-token",
          subject_issuer="google"
      )
      return tokens
  ```





  ```python

  async def verify_token(token: str):
      try:
          user_data = await client.verify_token(token)
          print(f"Token valid for user: {user_data['username']}")
          return user_data
      except TokenError as e:
          print(f"Token invalid: {e}")
  ```



  ```python

  async def refresh_token(refresh_token: str):
      try:
          new_tokens = await client.refresh_token(refresh_token)
          return new_tokens
      except TokenError as e:
          print(f"Token refresh failed: {e}")
  ```





  ```python

  async def verify_user_access(token: str, required_roles: list):
      try:
          user_data = await client.verify_token(
              token=token,
              verify_roles=required_roles
          )
          return True
      except AuthenticationError:
          return False
  ```



  ```python
  from idp_async_client.auth import require_auth

  @require_auth(roles=['admin'])
  async def protected_route(request):
      return {"status": "accessed by admin"}
  ```





  ```python

  async def get_sessions(user_id: str):
      sessions = await client.get_user_sessions(user_id)
      return sessions


  async def revoke_session(session_id: str):
      await client.revoke_session(session_id)
  ```



  ```python

  async def logout(refresh_token: str):
      try:
          await client.logout(refresh_token)
          return {"status": "logged out"}
      except Exception as e:
          print(f"Logout failed: {e}")
  ```





  ```python
  from idp_async_client.middleware import IdPMiddleware


  app = FastAPI()
  app.add_middleware(
      IdPMiddleware,
      idp_client=client,
      required_roles=['user']
  )


  MIDDLEWARE = [
      'idp_async_client.middleware.DjangoIdPMiddleware',
  ]
  ```



  ```python
  from idp_async_client.cache import BaseCache

  class RedisCache(BaseCache):
      def __init__(self, redis_client):
          self.redis = redis_client

      async def get(self, key: str):
          return await self.redis.get(key)

      async def set(self, key: str, value: str, timeout: int = None):
          await self.redis.set(key, value, ex=timeout)
  ```





  ```python
  config = IdPConfig(
      
      provider="keycloak",
      server_url="http://localhost:8080",
      realm_name="my-realm",
      client_id="my-client",
      client_secret="my-secret",

      
      verify_ssl=True,
      timeout=30,
      token_expires_in=300,
      refresh_expires_in=1800,
      cache_timeout=86400
  )
  ```



  ```bash
  export IDP_SERVER_URL="http://localhost:8080"
  export IDP_REALM_NAME="my-realm"
  export IDP_CLIENT_ID="my-client"
  export IDP_CLIENT_SECRET="my-secret"
  ```





  ```python
  from idp_async_client.exceptions import (
      IdPError,
      AuthenticationError,
      TokenError,
      ConfigError
  )

  async def handle_auth():
      try:
          tokens = await client.login_with_password(
              "username",
              "password"
          )
      except AuthenticationError as e:
          
          print(f"Authentication failed: {e}")
      except TokenError as e:
          
          print(f"Token error: {e}")
      except ConfigError as e:
          
          print(f"Configuration error: {e}")
      except IdPError as e:
          
          print(f"IdP error: {e}")
  ```





  - `IdPClient`: Main client interface
  - `IdPConfig`: Configuration class
  - `TokenVerifier`: Token verification utilities
  - `SessionManager`: Session management utilities



  - `token_utils`: Token handling utilities
  - `cache_utils`: Caching utilities
  - `crypto_utils`: Cryptographic utilities





  **Q: Why am I getting token verification errors?**
  A: Ensure your server's clock is synchronized and the token hasn't expired.

  **Q: How do I handle token expiration?**
  A: Use the refresh token to get a new access token before it expires.

  **Q: Can I use multiple IdP providers?**
  A: Yes, create separate client instances with different configurations.



  1. Always use HTTPS in production
  2. Implement proper error handling
  3. Use role-based access control
  4. Regularly rotate client secrets
  5. Implement token refresh logic
  6. Use secure session storage


pkgId: dbd96b35162983491bc0f561a71157266e25deff1df691057847a74435a20661
name: python-igpyhw-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for igpyhw
url: https://github.com/israelglixinski/igpyhw
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-igpyhw-0.1.1-1.src.rpm
location_href: Packages/python-igpyhw-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A simple example module.




  * pip install build
  * python -m build
  * pip install twine
  * twine upload dist/*




  ```bash
  pip install igpyhw


pkgId: 4ee33fff0e61d3b31fe85887ebfdefb117ecdd0f3daba3e64094a6e4664c30c8
name: python-igwn-alert-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for igwn-alert
url: https://igwn-alert.readthedocs.io/
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-igwn-alert-0.7.0-1.src.rpm
location_href: Packages/python-igwn-alert-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  The IGWN Alert System (igwn-alert) is a prototype notification service built on Apache Kafka, using the publish-subscribe (pubsub) protocol. It is a higher-level modification of SCIMMA's hop-client to streamline receiving and responding to alerts from GraceDB.


pkgId: db6629c85a057e66c55be4d00d50eca61c3d3808bb54988b4ef8846e941bd786
name: python-iiif-download-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for iiif-download
url: https://github.com/Segolene-Albouy/iiif-download
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iiif-download-0.1.4-1.src.rpm
location_href: Packages/python-iiif-download-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/iiif-download.svg)](https://pypi.org/project/iiif-download)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/iiif-download.svg)](https://pypi.org/project/iiif-download)
  ![Test Status](https://img.shields.io/github/actions/workflow/status/Segolene-Albouy/iiif-download/test.yml?branch=main)

  This repository contains code to download images from IIIF manifests.
  It takes into account limitations and data specificities from various institutions.

  ```bash
  pip install iiif-download
  ```



  The configuration is stored in `iiif_download/config.py` and can be overriden by setting environment variables.



  ```python
  from iiif_download import IIIFDownloader, config


  config.max_size = 2500
  config.img_dir = "custom/path/to/images"


  downloader = IIIFDownloader()


  downloader = IIIFDownloader(
      img_dir="path/to/dir"  # surcharge any global attribute
  )

  manifest = "https://example.org/manifest"


  downloader.download_manifest(manifest, save_dir="dir_name")
  ```



  ```bash

  export IIIF_BASE_DIR=custom/path/to/images
  export IIIF_MAX_SIZE=4000

  source .env

  iiif-download https://example.org/manifest
  iiif-download -f test-manifests.txt
  iiif-download -d custom/path/to/images
  ```



  ```python
  from iiif_download import IIIFManifest

  manifest = IIIFManifest("https://example.org/manifest")
  manifest.load()
  lic = manifest.license
  author = manifest.get_meta("author")
  images = manifest.get_images()
  ```


pkgId: 2000399566f69eea6db134c8b995177fd65510ede09762ec110e67d7e1d955b9
name: python-iinfer-help
arch: noarch
version: 0.10.2
epoch: 0
release: 1
summary: Development documents and examples for iinfer
url: https://github.com/hamacom2004jp/iinfer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iinfer-0.10.2-1.src.rpm
location_href: Packages/python-iinfer-help-0.10.2-1.noarch.rpm
checksum_type: sha256
description:
  - onnx又はmmlabフォーマットのAIモデルファイルを実行するアプリケーションです。
  - ドキュメントは[こちら](https://hamacom2004jp.github.io/iinfer/)。
  - iinferを使用することで、AIモデルを簡単に実行することが出来ます。
  - 動作確認したモデルは[動作確認済みモデル](https://hamacom2004jp.github.io/iinfer/docs/models.html)に記載しています。
  - 主なAIタスクは、画像分類、物体検知、領域検知、顔検知、顔認識です。
  - 複数の `iinfer` コマンドの入出力をつなげる、パイプライン処理を行うことが出来ます。
  - GUIモードを使用することで、 `iinfer` コマンド操作を簡単に行うことが出来ます。




  ![iinferの動作イメージ](https://github.com/hamacom2004jp/iinfer/raw/main/docs_src/static/orverview.drawio.png)

  1. **iinfer client** は **imageファイル** や **camera** から画像を取得し、 **推論結果 predict.json** を出力します。
  2. **iinfer server** は推論を行うサーバーです。 **iinfer client** からの要求に応えて、推論結果を **iinfer client** に返します。
  3. **iinfer server** は予め **ai model** をロードしておくことで、推論を高速化します。
  4. **iinfer client** と **iinfer server** は **Redis** 経由で通信します。
  5. **iinfer server** と **Redis** は **dockerコンテナ** を使用して起動させることが出来ます。



  インストール方法は [こちら](https://hamacom2004jp.github.io/iinfer/docs/install.html) を参照してください。



  iinferを使用するには、次のコマンドを実行します:

  1. guiモードで利用する場合:

  ![guiモードのイメージ](https://github.com/hamacom2004jp/iinfer/raw/main/docs_src/static/ss/00242_cmd_predict.jpg)

  ```bash
  iinfer -m gui -c start
  ```

  2. コマンドモードで利用する場合

      1. AIモデルのデプロイ:

      ```bash
      
      
      iinfer -m client -c deploy -n <任意のモデル名> -f \
                                 --model_file <モデルファイル> \
                                 --model_conf_file <モデル設定ファイル> \
                                 --predict_type <推論タイプ> \
                                 --label_file <ラベルファイル>

      
      iinfer -m client -c deploy_list -f
      ```

      2. AIモデルのセッションを開始:

      ```bash

      
      
      iinfer -m client -c start -n <モデル名> -f \
                                --use_track
      ```

     3. 推論を実行:

      ```bash
      
      
      iinfer -m client -c predict -n <モデル名> -f \
                                  -i <推論させる画像ファイル> \
                                  -o <推論結果の画像ファイル> \
                                  --output_preview

      
      
      iinfer -m client -c capture | \
      iinfer -m client -c predict -n <モデル名> \
                                  --stdin \
                                  --image_type capture \
                                  --nodraw | \
      iinfer -m postprocess -c det_filter -f -P \
                                  --stdin \
                                  --score_th 0.8
      ```

      4. AIモデルのセッションを開放:

      ```bash
      
      iinfer -m client -c stop -n <モデル名> -f
      ```



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


pkgId: d0be4b55813cb50fc23184513d97ceaf12ec503b0b32c41db1da6a45b0bf0bfc
name: python-ikml-doc-help
arch: noarch
version: 0.15.0
epoch: 0
release: 1
summary: Development documents and examples for ikml-doc
url: https://gitlab.com/siddhantakosha/public/software/ikml-pypi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ikml-doc-0.15.0-1.src.rpm
location_href: Packages/python-ikml-doc-help-0.15.0-1.noarch.rpm
checksum_type: sha256
description:
  A parser for IKML (Indic Knowledge Markup Language)


  To install the IKML parser, use the following command:

  ```bash
  pip install ikml_doc
  ```


  The IKML parser can be used to load IKML data from a URL or a local file, and then convert it into various formats such as JSON, XML, and plain text.


  You can load IKML data from a URL or a local file using the `IKML_Document` class.

  ```python
  from ikml_doc import IKML_Document
  ```

  ```python
  ikml_url = "https://siddhantakosha.org/libraries/smap-granthas/Naadi-Pariksha/vakyas-ikml.txt"
  ```

  ```python
  doc = IKML_Document()
  doc.load(url=ikml_url)



  _doc = IKML_Document(url=ikml_url)
  _doc.tags()
  ```




  ```python
  tags = doc.tags()
  tags[:10]
  ```




  ```python
  print(tags[0]["id"])
  doc.child_tags(tags[0]["id"])
  ```




  ```python



  doc.get(tags[10]["id"], fmt="dict")
  ```




  ```python
  tag_node = doc.get(tags[10]["id"])
  tag_node.keys()
  ```




  ```python
  for node in doc.iter():
      print(node)
  ```




  ```python
  for child in tag_node.node_children:
      print(child)
  ```




  ```python
  list(doc.find_children(tag_name="va"))[:5]
  ```




  ```python
  node = doc.get(tags[10]["id"])

  new_doc = IKML_Document(data=node.to_txt())
  new_doc.to_dict()
  ```




  ```python
  doc.to_dict()
  ```


  ```python
  doc.to_xml()
  ```


  ```python
  doc.to_txt()
  ```




  ```python
  filename = "out_ikml.txt"
  doc.save(filename)
  ```




  ```python
  xmlout = doc.to_xml()
  with open("out_xml.txt", "w", encoding="utf-8") as fd:
      fd.write(xmlout)
  ```




  ```python
  from ikml_doc import IKML_Document
  ```


  ```python
  all_ikml_url = "https://siddhantakosha.org/libraries/smap-granthas/Tarkasangraha-Moola/all-ikml.txt"
  ```


  ```python
  doc2 = IKML_Document(url=all_ikml_url)
  ```


  ```python
  new_dict = doc2.to_dict()
  new_dict
  ```




  ```python
  doc3 = IKML_Document()
  doc3.load(data=new_dict)
  doc3.to_dict()
  ```




  ```python
  from ikml_doc import IKML_Document
  ```


  ```python
  smb_url = "https://siddhantakosha.org/libraries/smap-granthas/Tarkasangraha-Moola/sambandhas-ikml.txt"
  ```


  ```python
  doc4 = IKML_Document()
  doc4.load(url=smb_url)
  ```


  ```python
  doc4.get('smaps.TarkaSM.r.1')
  ```


  ```python
  n = doc4.get('smaps.TarkaSM.r.1', fmt='node')
  print(n.keys())
  n['.srcid']
  ```



  Contributions are welcome. Please open an issue to discuss any changes before submitting a pull request.


  This project is licensed under the LGPL License.


  Special thanks to the contributors and maintainers of the IKML project.


pkgId: dfc3f7ec4c6a73c0dcd24bcbd67e75e47c0e91eeac1c34d9dcfac5600389d3de
name: python-ilo-help
arch: noarch
version: 0.0.45
epoch: 0
release: 1
summary: Development documents and examples for ilo
url: https://ilorobot.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ilo-0.0.45-1.src.rpm
location_href: Packages/python-ilo-help-0.0.45-1.noarch.rpm
checksum_type: sha256
description:
  <picture align="center">
      <img alt="Ilo robot" src="https://images.squarespace-cdn.com/content/v1/6312fe2115db3003bd2ec2f1/546df043-e044-4003-867b-802738eb1332/LOGO+ILO+PYTHON.png">
  </picture>



  A package that lets users control ilo the new educational robot using python command lines.



  - Moves the robot in **many directions** with python commands line
  - Creates **movement loops**
  - Play with the robot in **real time** with your keyboard
  - Use **colored plates** to make the robot move and many other **autonomous modes**



  ```

  pip install ilo
  ```



  ```

  pip install ilo --upgrade
  ```



  - [Keyboard - Take full control of your keyboard with this small Python library. Hook global events, register hotkeys, simulate key presses and much more.](https://pypi.org/project/keyboard/)

  - [PrettyTable - A simple Python library for easily displaying tabular data in a visually appealing ASCII table format.](https://pypi.org/project/prettytable/)

  - [WebSocket-Client - websocket-client is a WebSocket client for Python. It provides access to low level APIs for WebSockets.](https://pypi.org/project/websocket-client/)

  - [Python Serial Port Extension for Win32, OSX, Linux, BSD, Jython, IronPython.](https://pypi.org/project/pyserial/)

  - [Pyperclip is a cross-platform Python module for copy and paste clipboard functions.](https://pypi.org/project/pyperclip/)

  Don't worry, these dependencies are automatically installed with the ilo library.



  ```
  import ilo

  ilo.check_robot_on_network()

  my_ilo = ilo.robot(1)

  my_ilo.set_led_color(255,0,0)      # set the robot color to red

  while true:

      print("Ilo moves forward")
      my_ilo.move("front", 100)

      while my_ilo.get_distance() > 20:
          pass

      my_ilo.stop()
      print("ilo has encountered an obstacle")

      if my_ilo.get_distance() > 20:
          my_ilo.move("right", 80)
          print("ilo moves to the right at 80% speed")

      else:
          my_ilo.move("left", 70)
          print("ilo moves to the left at 70% speed")
  ```



  Bug reports, patches and suggestions are welcome!

  Contact us through our [***website***](https://ilorobot.com) ;)


pkgId: f7401dda64681c34c15fa194213d5dc399f9e7432de4c40ddd76bec0e039bedd
name: python-iloveapi-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for iloveapi
url: https://pypi.org/project/iloveapi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iloveapi-0.1.4-1.src.rpm
location_href: Packages/python-iloveapi-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Python api client made for iLoveIMG & iLovePDF based on iLoveAPI (https://www.iloveapi.com/docs/api-reference).



  - Fully typed code
  - Asyncio support
  - REST API & workflow API encapsulation



  ```shell
  pip install iloveapi
  ```



  Simply compress image:

  ```python
  from iloveapi import ILoveApi

  client = ILoveApi(
      public_key="<project_public_******>",
      secret_key="<secret_key_******>",
  )
  task = client.create_task("compressimage")
  task.process_files("p1.png")
  task.download("output.png")
  ```

  Multiple images:

  ```python
  task = client.create_task("compressimage")
  task.process_files(
      "p1.png",
      ("custom_name.png", "p2.png"),
      ("custom_name.png", b"..PNG..."),
      {
          "file": b"..PNG...",
          "filename": "custom_name.png",
          "rotate": 2,  # add image parameter
          "password": "xxx",  # for PDF
      }
  )
  task.download("output.zip")  # zip format
  ```

  Async support:

  ```python
  task = await client.create_task_async("compressimage")
  await task.process_files_async("p1.png")
  await task.download_async("output.png")
  ```

  Directly call REST API:

  ```python
  response = client.rest.start("compressimage")  # getting httpx response
  response = await client.rest.start_async("compressimage")  # async
  ```



  - [ ] Typed parameter for all processing tools
  - [ ] Command-line interface



  Image / PDF processing tools usually focus on results rather than JSON data, as data type validation is not important to the user.


pkgId: b6ff622df47ec7da083ef66d07aa30cbe7c7df37c2289fe2645d1d3a5a372909
name: python-ilund4u-help
arch: noarch
version: 0.0.9.1
epoch: 0
release: 1
summary: Development documents and examples for ilund4u
url: https://art-egorov.github.io/ilund4u/
rpm_license: WTFPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ilund4u-0.0.9.1-1.src.rpm
location_href: Packages/python-ilund4u-help-0.0.9.1-1.noarch.rpm
checksum_type: sha256
description:
  <img  src="https://raw.githubusercontent.com/art-egorov/iLund4u/main/docs/img/ilund4u_logo.png?token=GHSAT0AAAAAACNA6ZUMHKXAJEHFEYINLXQ2ZTK4Y3Q" width="310"/>



  **iLund4u** is a bioinformatics tool for search and annotation of hotspots in a large set of proteomes.

  **Supported input**: gff3 for annotation files (prokka/pharokka generated); fasta for protein sequences
  **Programming language:** Python3
  **OS:** MacOS, Linux
  **Python dependencies:** biopython, bcbio-gff, scipy, configs, pandas, matplotlib, seaborn, progess, leidanalg, igraph. pyhmmer, msa4u, lovis4u
  **Python version:** >= 3.8
  **OS-level dependencies:** MMseqs2 (included in the package)
  **License:** WTFPL
  **Version:** 0.0.9 (December 2024)


  **Detailed documentation with user guide is available at [iLund4u Homepage](https://art-egorov.github.io/ilund4u/)**




  If you find iLund4u useful, please cite:
  Artyom. A. Egorov, Vasili Hauryliuk, Gemma C. Atkinson, **Systematic annotation of hyper-variability hotspots in phage genomes and plasmids**, *bioRxiv 22024.10.15.618418; doi: [10.1101/2024.10.15.618418](https://doi.org/10.1101/2024.10.15.618418)*



  Please contact us by e-mail _artem**dot**egorov**AT**med**dot**lu**dot**se_ or use [Issues](https://github.com/art-egorov/ilund4u/issues?q=) to report any technical problems.
  You can also use [Discussions section](https://github.com/art-egorov/ilund4u/discussions) for sharing your ideas or feature requests!



  iLund4u is developed by Artyom Egorov at [the Atkinson Lab](https://atkinson-lab.com), Department of Experimental Medical Science, Lund University, Sweden. We are open for suggestions to extend and improve iLund4u functionality. Please don't hesitate to share your ideas or feature requests.


pkgId: c004735a7c509c5aa8dfb1c651130d9805100427a31bd9d745df309d0dc6752b
name: python-image-classification-jax-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for image-classification-jax
url: https://pypi.org/project/image-classification-jax/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-image-classification-jax-0.1.4-1.src.rpm
location_href: Packages/python-image-classification-jax-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Run image classification experiments in JAX with ViT, resnet, cifar10, cifar100, imagenette, and imagenet.

  Meant to be simple but good quality. Includes:
  - ViT with qk normalization, swiglu, empty registers
  - Palm style z-loss (https://arxiv.org/pdf/2204.02311)
  - ability to use schedule-free from `optax.contrib`
  - datasets currently implemented include cifar10, cifar100, imagenette, and imagenet

  Currently no model sharding, only data parallelism (automatically splits batch `batch_size/n_devices`).




  ```bash
  pip install image-classification-jax
  ```




  Set your wandb key either in your python script or through command line:
  ```bash
  export WANDB_API_KEY=<your_key>
  ```

  Use `run_experiment` to run an experiment. Here's how you could run an experiment with
  PSGD affine optimizer wrapped with schedule-free:

  ```python
  import optax
  from image_classification_jax.run_experiment import run_experiment
  from psgd_jax.affine import affine

  base_lr = 0.001
  warmup = 256
  lr = optax.join_schedules(
      schedules=[
          optax.linear_schedule(0.0, base_lr, warmup),
          optax.constant_schedule(base_lr),
      ],
      boundaries=[warmup],
  )

  psgd_opt = optax.chain(
      optax.clip_by_global_norm(1.0),
      affine(
          lr,
          preconditioner_update_probability=1.0,
          b1=0.0,
          weight_decay=0.0,
          max_size_triangular=0,
          max_skew_triangular=0,
          precond_init_scale=1.0,
      ),
  )

  optimizer = optax.contrib.schedule_free(psgd_opt, learning_rate=lr, b1=0.95)

  run_experiment(
      log_to_wandb=True,
      wandb_entity="",
      wandb_project="image_classification_jax",
      wandb_config_update={  # extra logging info for wandb
          "optimizer": "psgd_affine",
          "lr": base_lr,
          "warmup": warmup,
          "b1": 0.95,
          "schedule_free": True,
      },
      global_seed=100,
      dataset="cifar10",
      batch_size=64,
      n_epochs=10,
      optimizer=optimizer,
      compute_in_bfloat16=False,
      apply_z_loss=True,
      model_type="vit",
      n_layers=4,
      enc_dim=64,
      n_heads=4,
      n_empty_registers=0,
      dropout_rate=0.0,
      using_schedule_free=True,  # set to True if optimizer wrapped with schedule_free
  )
  ```


pkgId: 1b210f0e46a55abd645c09d90220e07c0cde62b99a21ca52422881ca5e93cc3a
name: python-image-location-scan-help
arch: noarch
version: 0.2.20
epoch: 0
release: 1
summary: Development documents and examples for image-location-scan
url: https://pypi.org/project/image-location-scan/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-image-location-scan-0.2.20-1.src.rpm
location_href: Packages/python-image-location-scan-help-0.2.20-1.noarch.rpm
checksum_type: sha256
description:
  **Image Location Scan** is a powerful tool designed to extract Exif metadata from images, monitor a specified directory for changes, and maintain a synchronized [geopackage file](https://www.geopackage.org/). This script is ideal for users who need to keep track of photo metadata and visualize it on a map, especially in dynamic environments where files are frequently added, removed, or modified. Requires [exiftool](https://exiftool.org/) to be installed and callable by subprocess. Optionally scans and matches Metashape psx and psz files.



  - **Directory Monitoring**: Utilizes `watchdog` to monitor a specified directory for changes and keeps a GeoPackage map updated in real-time.
  - **Exif Metadata Extraction**: Extracts Exif metadata from images using `ExifTool`, including GPS coordinates, camera make and model, and more.
  - **GeoPackage Synchronization**: Maintains a GeoPackage file that is updated with the latest metadata from the monitored directory.
  - **HTML Map Generation**: Generates an HTML map and table to visualize the metadata, with options to include additional map layers.
  - **Configurable Logging**: Supports dual logging to both console and file, with customizable log levels.
  - **Persistent Observer**: Optionally persists the observer state to resume monitoring after interruptions.
  - **Integration with Kart**: Supports integration with Kart for version control and remote repository synchronization.
  - **Additonal Metadata**: Manually add key/value metadata by saving `metadata.xlsx` files in the directory structure.



  To install the package, use the following command:

  ```bash
  pip install image-location-scan
  ```



  The script can be run from the command line with various options to customize its behavior. Below is an example of how to use it:

  ```bash
  py -m exifScan '\\file\Shared\SEESPhotoDatabase' --config .\config.json --watchDirectory
  ```



  - `path`: The path to scan for Exif data (required).
  - `--WorkDirectory`: The working directory (defaults to current working directory).
  - `--MetashapeDirectory`: Directory to search for Metashape project files.
  - `--KartRemote`: Kart remote repository URL for pushing updates.
  - `--KartDirectory`: Directory for the Kart repository.
  - `--GeopackageDirectory`: Directory to save the GeoPackage file (defaults to WorkDirectory).
  - `--LogDirectory`: Directory to save log files (defaults to current directory).
  - `--OutputGeopackage`: Name of the output GeoPackage file (defaults to `Photos.gpkg`).
  - `--htmlFolder`: Directory to save the HTML map and table.
  - `--mapFileName`: Name of the HTML map file (defaults to `map.html`).
  - `--otherMapLayers`: List of paths to additional map layers.
  - `--otherMapLayerNames`: List of names for additional map layers.
  - `--ExifOutputFile`: Name of the Exif output file (defaults to `outdb`).
  - `--readExifFromOutputFile`: Read Exif data from the output file instead of scanning.
  - `--recursive`: Scan directories recursively.
  - `--ignoreDirs`: List of directories to ignore during scanning.
  - `--ignoreMetashape`: Ignore directories containing `.files` and `auto-project`.
  - `--persistObserver`: Persist the observer state to resume monitoring after interruptions.
  - `--dualLogging`: Enable logging to both console and file.
  - `--groupByTags`: List of tags to group by. Always groups by folder, but can also split into the groups specified by this flag (defaults to `["Make", "Model"]`).
  - `--xyTagNames`: List of tag names for x and y coordinates (defaults to `['GPSLongitude', 'GPSLatitude']`).
  - `--zTagName`: Tag name for z coordinate (defaults to `GPSAltitude`).
  - `--imageFileExtensions`: List of image file extensions to scan (defaults to `['JPG']`).
  - `--metashapeCacheTime`: Time to keep Metashape data cached (in minutes, defaults to 120).
  - `--pollingInterval`: Time (in seconds) between polling intervals.
  - `--config`: Path to a JSON config file.
  - `--watchDirectory`: Watch directory for changes after initial scan.
  - `--logLevel`: Set the logging level (choices: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`). Only if dualLogging is disabled.



  - `argparse`
  - `sys`
  - `json`
  - `logging`
  - `os`
  - `time`
  - `datetime`
  - `copy`
  - `threading`
  - `subprocess`
  - `folium`
  - `pandas`
  - `geopandas`
  - `ExifTool`
  - `watchdog`



  Thanks to Phil Harvey and his excellent exiftool software.


pkgId: ebd2036abcbc35a923307814731f33da3bde568ce17e7b4a76b73b46a96304fa
name: python-image-padder-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for image-padder
url: https://github.com/crapthings/py-image-padder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-image-padder-0.1.0-1.src.rpm
location_href: Packages/python-image-padder-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Publish Python Package](https://github.com/crapthings/py-image-padder/actions/workflows/workflow.yml/badge.svg)](https://github.com/crapthings/py-image-padder/actions/workflows/workflow.yml)



  Image Padder is a command-line tool for batch processing image files. It can pad images to a specified aspect ratio, resize them, and supports custom background colors.



  - Supports jpg, jpeg, png, webp, and avif image formats
  - Pads images to a specified aspect ratio (default 1:1)
  - Customizable padding background color (default black)
  - Optional image resizing
  - Batch processing of entire folders
  - Processed images saved in a new folder with original filenames



  Install Image Padder using pip:

  ```
  pip install image-padder
  ```



  Basic usage:

  ```
  image-padder <input_folder> [options]
  ```

  Options:
  - `--ratio`: Target aspect ratio (width/height). Default is 1.0 (square).
  - `--bg-color`: Background color in hex format (e.g., #FFFFFF). Default is #000000 (black).
  - `--output-size`: Output size after processing, specified as WIDTH HEIGHT.

  Example:

  ```
  image-padder /path/to/image/folder --ratio 1.5 --bg-color "#FFFFFF" --output-size 800 600
  ```

  This command processes all supported images in `/path/to/image/folder`, padding them to a 3:2 aspect ratio with a white background, and resizing to 800x600 pixels.



  Processed images are saved in a new folder at the same level as the input folder. The new folder is named:

  ```
  {original_folder_name}_padded_{random_three_letters}
  ```

  For example, if the input folder is "my_images", the output folder might be "my_images_padded_xyz".



  To set up the development environment:

  1. Clone the repository:
     ```
     git clone https://github.com/yourusername/image-padder.git
     cd image-padder
     ```

  2. Create and activate a virtual environment:
     ```
     python -m venv venv
     source venv/bin/activate  # On Windows use venv\Scripts\activate
     ```

  3. Install development dependencies:
     ```
     pip install -r requirements.txt
     ```

  4. Install the package in editable mode:
     ```
     pip install -e .
     ```



  We welcome issue reports and pull requests. For major changes, please open an issue first to discuss what you'd like to change.



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


pkgId: 4a11bd9cc103bf3e7ecc43eb84fa875128501d5eb8a823228f58d0e4825633f7
name: python-images-upload-cli-help
arch: noarch
version: 3.0.4
epoch: 0
release: 1
summary: Development documents and examples for images-upload-cli
url: https://github.com/DeadNews/images-upload-cli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-images-upload-cli-3.0.4-1.src.rpm
location_href: Packages/python-images-upload-cli-help-3.0.4-1.noarch.rpm
checksum_type: sha256
description:
  > Upload images via APIs

  [![PyPI: Version](https://img.shields.io/pypi/v/images-upload-cli?logo=pypi&logoColor=white)](https://pypi.org/project/images-upload-cli)
  [![AUR: version](https://img.shields.io/aur/version/python-images-upload-cli?logo=archlinux&logoColor=white)](https://aur.archlinux.org/packages/python-images-upload-cli)
  [![GitHub: Release](https://img.shields.io/github/v/release/deadnews/images-upload-cli?logo=github&logoColor=white)](https://github.com/deadnews/images-upload-cli/releases/latest)
  [![Documentation](https://img.shields.io/badge/documentation-gray.svg?logo=materialformkdocs&logoColor=white)](https://deadnews.github.io/images-upload-cli)
  [![CI: pre-commit](https://results.pre-commit.ci/badge/github/DeadNews/images-upload-cli/main.svg)](https://results.pre-commit.ci/latest/github/deadnews/images-upload-cli/main)
  [![CI: Main](https://img.shields.io/github/actions/workflow/status/deadnews/images-upload-cli/main.yml?branch=main&logo=github&logoColor=white&label=main)](https://github.com/deadnews/images-upload-cli/actions/workflows/main.yml)
  [![CI: Coverage](https://img.shields.io/codecov/c/github/deadnews/images-upload-cli?token=OCZDZIYPMC&logo=codecov&logoColor=white)](https://app.codecov.io/gh/deadnews/images-upload-cli)

  **[Installation](#installation)** • **[Hostings](#hostings)** • **[Usage](#usage)** • **[Env Variables](#env-variables)**



  PyPI

  ```sh
  pipx install images-upload-cli

  pip install images-upload-cli
  ```

  AUR

  ```sh
  yay -S python-images-upload-cli
  ```

  Windows executable is attached to the GitHub release.



  | host                                  | key required | return example                                       |
  | :------------------------------------ | :----------: | :--------------------------------------------------- |
  | [anhmoe](https://anh.moe/)            |      -       | `https://cdn.anh.moe/c/{id}.png`                     |
  | [beeimg](https://beeimg.com/)         |      -       | `https://beeimg.com/images/{id}.png`                 |
  | [catbox](https://catbox.moe/)         |      -       | `https://files.catbox.moe/{id}`                      |
  | [fastpic](https://fastpic.org/)       |      -       | `https://i120.fastpic.org/big/2022/0730/d9/{id}.png` |
  | [filecoffee](https://file.coffee/)    |      -       | `https://file.coffee/u/{id}.png`                     |
  | [freeimage](https://freeimage.host/)  |      -       | `https://iili.io/{id}.png`                           |
  | [gyazo](https://gyazo.com/)           |      +       | `https://i.gyazo.com/{id}.png`                       |
  | [imageban](https://imageban.ru/)      |      +       | `https://i2.imageban.ru/out/2022/07/30/{id}.png`     |
  | [imagebin](https://imagebin.ca/)      |      -       | `https://ibin.co/{id}.png`                           |
  | [imgbb](https://imgbb.com/)           |      +       | `https://i.ibb.co/{id}/image.png`                    |
  | [imgchest](https://imgchest.com/)     |      +       | `https://cdn.imgchest.com/files/{id}.png`            |
  | [imgur](https://imgur.com/)           |      -       | `https://i.imgur.com/{id}.png`                       |
  | [lensdump](https://lensdump.com/)     |      +       | `https://i.lensdump.com/i/{id}.png`                  |
  | [pixeldrain](https://pixeldrain.com/) |      +       | `https://pixeldrain.com/api/file/{id}`               |
  | [pixhost](https://pixhost.to/)        |      -       | `https://img75.pixhost.to/images/69/{id}_img.png`    |
  | [ptpimg](https://ptpimg.me/)          |      +       | `https://ptpimg.me/{id}.png`                         |
  | [smms](https://sm.ms/)                |      +       | `https://s2.loli.net/2022/07/30/{id}.png`            |
  | [sxcu](https://sxcu.net/)             |      -       | `https://sxcu.net/{id}.png`                          |
  | [telegraph](https://telegra.ph/)      |      -       | `https://telegra.ph/file/{id}.png`                   |
  | [thumbsnap](https://thumbsnap.com/)   |      +       | `https://thumbsnap.com/i/{id}.png`                   |
  | [tixte](https://tixte.com/)           |      +       | `https://{domain}.tixte.co/r/{id}.png`               |
  | [up2sha](https://up2sha.re/)          |      +       | `https://up2sha.re/media/raw/{id}.png`               |
  | [uplio](https://upl.io/)              |      +       | `https://upl.io/i/{id}.png`                          |
  | [uploadcare](https://uploadcare.com/) |      +       | `https://ucarecdn.com/{id}/img.png`                  |
  | [vgy](https://vgy.me/)                |      +       | `https://i.vgy.me/{id}.png`                          |



  [CLI Reference](https://deadnews.github.io/images-upload-cli/reference-cli/)

  ```sh
  Usage: images-upload-cli [OPTIONS] IMAGES...

    Upload images via APIs.

  Options:
    -h, --hosting [anhmoe|beeimg|catbox|fastpic|filecoffee|freeimage|gyazo|imageban|imagebin|imgbb|imgchest|imgur|lensdump|pixeldrain|pixhost|ptpimg|smms|sxcu|telegraph|thumbsnap|tixte|up2sha|uplio|uploadcare|vgy]
                                    [default: imgur]
    -f, --format [plain|bbcode|html|markdown]
                                    The format of the links to be generated.  [default: plain]
    -t, --thumbnail                 Create captioned thumbnails. By default, in bbcode format.
    -n, --notify                    Send desktop notification on completion. Required libnotify.
    --clipboard / --no-clipboard    Copy the result to the clipboard.  [default: clipboard]
    --env-file FILE                 The path to the environment file. Takes precedence over the default config file.
    --log-level [DEBUG|INFO|WARNING|ERROR|CRITICAL]
                                    Use DEBUG to show debug logs. Use CRITICAL to suppress all logs.  [default: INFO]
    --version                       Show the version and exit.
    --help                          Show this message and exit.
  ```



  ```ini
  CAPTION_FONT= # The default font is system dependent.

  FREEIMAGE_KEY=
  GYAZO_TOKEN=
  IMAGEBAN_TOKEN=
  IMGBB_KEY=
  IMGCHEST_KEY=
  IMGUR_CLIENT_ID=
  LENSDUMP_KEY=
  PIXELDRAIN_KEY=
  PTPIMG_KEY=
  SMMS_KEY=
  THUMBSNAP_KEY=
  TIXTE_KEY=
  UP2SHA_KEY=
  UPLIO_KEY=
  UPLOADCARE_KEY=
  VGY_KEY=
  ```

  You can set these in environment variables, or in `.env` file:

  - Unix: `~/.config/images-upload-cli/.env`
  - MacOS: `~/Library/Application Support/images-upload-cli/.env`
  - Windows: `C:\Users\<user>\AppData\Roaming\images-upload-cli\.env`


pkgId: dc46c3b9f1e4a8d67856259d70f7a2ee1b7ffd062c798355da2335b7a871e803
name: python-iman-help
arch: noarch
version: 1.0.24
epoch: 0
release: 1
summary: Development documents and examples for iman
url: https://pypi.org/project/iman/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iman-1.0.24-1.src.rpm
location_href: Packages/python-iman-help-1.0.24-1.noarch.rpm
checksum_type: sha256
description:
  1-plt
  2-now() ``get time``
  3-F ``format floating point``
  4-D ``format int number``
  5-Write_List(MyList,Filename)
  6-Write_Dic(MyDic,Filename)
  7-Read(Filename) ``read txt file``
  8-Read_Lines(Filename) ``read txt file line by line and return list``
  9-Write(_str,Filename)
  10-gf(pattern) ``Get files in a directory``
  11-gfa(directory_pattern , ext="*.*") ``Get Files in a Directory and SubDirectories``
  12-ReadE(Filename) ``Read Excel files``
  13-PM(dir) ``creat directory``
  14-PB(fname) ``get basename``
  15-PN(fname) ``get file name``
  16-PE(fname) ``get ext``
  17-PD(fname) ``get directory``
  18-PS(fname) ``get size``
  19-PJ(segments) ``Join Path``
  20-clear() ``clear cmd``
  21-os
  22-np
  23-RI(start_int , end_int , count=1) ``random int``
  24-RF(start_float , end_float , count=1) ``random float``
  25-RS(Arr) ``shuffle``
  26-LJ(job_file_name)
  27-SJ(value , job_file_name)
  28-LN(np_file_name)
  29-SN(arr , np_file_name)
  30-cmd(command , redirect=True) ``Run command in CMD``
  31-PX(fname) ``check existance of file``
  32-RC(Arr , size=1) ``Random Choice``
  33-onehot(data, nb_classes)
  34-exe(pyfile) ``need pyinstaller``
  35-FWL(wavfolder , sr) ``Get Folder Audio Length``
  36-norm(vector) ``vector/magnitude(vector)``
  37-delete(pattern)
  38-rename(fname , fout)
  39-separate(pattern,folout) ``separate vocal from music``
  40-dll(fname) ``create a pyd file from py file``
  41-get_hard_serial()
  42-mute_mic() ``on and off microphone``
  43-PA(fname) ``get abs path``


pkgId: a3d4e3ed44695eb40c245b01c5f8fb78d06a45b1f8d27076dd1b3d0ef45d4f86
name: python-imdclient-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for imdclient
url: https://pypi.org/project/imdclient/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-imdclient-0.1.4-1.src.rpm
location_href: Packages/python-imdclient-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  [//]: # (Badges)
  | **Latest release** | [![Last release tag][badge_release]][url_latest_release] ![GitHub commits since latest release (by date) for a branch][badge_commits_since]  [![Documentation Status][badge_docs]][url_docs]|
  | :----------------- | :------- |
  | **Status**         | [![GH Actions Status][badge_actions]][url_actions] [![codecov][badge_codecov]][url_codecov] |
  | **Community**      | [![License: MIT][badge_license]][url_license]  [![Powered by MDAnalysis][badge_mda]][url_mda]|
  [badge_actions]: https://github.com/becksteinlab/imdclient/actions/workflows/gh-ci.yaml/badge.svg
  [badge_codecov]: https://codecov.io/gh/becksteinlab/imdclient/branch/main/graph/badge.svg
  [badge_commits_since]: https://img.shields.io/github/commits-since/becksteinlab/imdclient/latest
  [badge_docs]: https://readthedocs.org/projects/imdclient/badge/?version=latest
  [badge_license]: https://img.shields.io/badge/License-MIT-blue.svg
  [badge_mda]: https://img.shields.io/badge/powered%20by-MDAnalysis-orange.svg?logoWidth=16&logo=data:image/x-icon;base64,AAABAAEAEBAAAAEAIAAoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJD+XwCY/fEAkf3uAJf97wGT/a+HfHaoiIWE7n9/f+6Hh4fvgICAjwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACT/yYAlP//AJ///wCg//8JjvOchXly1oaGhv+Ghob/j4+P/39/f3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJH8aQCY/8wAkv2kfY+elJ6al/yVlZX7iIiI8H9/f7h/f38UAAAAAAAAAAAAAAAAAAAAAAAAAAB/f38egYF/noqAebF8gYaagnx3oFpUUtZpaWr/WFhY8zo6OmT///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgICAn46Ojv+Hh4b/jouJ/4iGhfcAAADnAAAA/wAAAP8AAADIAAAAAwCj/zIAnf2VAJD/PAAAAAAAAAAAAAAAAICAgNGHh4f/gICA/4SEhP+Xl5f/AwMD/wAAAP8AAAD/AAAA/wAAAB8Aov9/ALr//wCS/Z0AAAAAAAAAAAAAAACBgYGOjo6O/4mJif+Pj4//iYmJ/wAAAOAAAAD+AAAA/wAAAP8AAABhAP7+FgCi/38Axf4fAAAAAAAAAAAAAAAAiIiID4GBgYKCgoKogoB+fYSEgZhgYGDZXl5e/m9vb/9ISEjpEBAQxw8AAFQAAAAAAAAANQAAADcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjo6Mb5iYmP+cnJz/jY2N95CQkO4pKSn/AAAA7gAAAP0AAAD7AAAAhgAAAAEAAAAAAAAAAACL/gsAkv2uAJX/QQAAAAB9fX3egoKC/4CAgP+NjY3/c3Nz+wAAAP8AAAD/AAAA/wAAAPUAAAAcAAAAAAAAAAAAnP4NAJL9rgCR/0YAAAAAfX19w4ODg/98fHz/i4uL/4qKivwAAAD/AAAA/wAAAP8AAAD1AAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALGxsVyqqqr/mpqa/6mpqf9KSUn/AAAA5QAAAPkAAAD5AAAAhQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkUFBSuZ2dn/3V1df8uLi7bAAAATgBGfyQAAAA2AAAAMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0AAADoAAAA/wAAAP8AAAD/AAAAWgC3/2AAnv3eAJ/+dgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9AAAA/wAAAP8AAAD/AAAA/wAKDzEAnP3WAKn//wCS/OgAf/8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAAANwAAADtAAAA7QAAAMAAABUMAJn9gwCe/e0Aj/2LAP//AQAAAAAAAAAA
  [badge_release]: https://img.shields.io/github/release-pre/becksteinlab/imdclient.svg
  [url_actions]: https://github.com/becksteinlab/imdclient/actions?query=branch%3Amain+workflow%3Agh-ci
  [url_codecov]: https://codecov.io/gh/becksteinlab/imdclient/branch/main
  [url_docs]: https://imdclient.readthedocs.io/en/latest/?badge=latest
  [url_latest_release]: https://github.com/becksteinlab/imdclient/releases
  [url_license]: https://opensource.org/license/mit
  [url_mda]: https://www.mdanalysis.org
  Receiver for [IMDv3 protocol](https://imdclient.readthedocs.io/en/latest/protocol_v3.html) from simulation engines like Gromacs, LAMMPS, and NAMD.
  IMDClient is bound by a [Code of Conduct](https://github.com/becksteinlab/imdreader/blob/main/CODE_OF_CONDUCT.md).

  IMDClient is available via PyPi and can be installed with pip:
  ```bash
  pip install imdclient
  ```
  To build IMDClient from source,
  we highly recommend using virtual environments.
  If possible, we strongly recommend that you use
  [Anaconda](https://docs.conda.io/en/latest/) as your package manager.
  Below we provide instructions both for `conda` and
  for `pip`.

  Ensure that you have [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html) installed.
  Create a virtual environment and activate it:
  ```
  conda create --name imdclient
  conda activate imdclient
  ```
  <!-- Install the development and documentation dependencies:
  ```
  conda env update --name imdreader --file devtools/conda-envs/test_env.yaml
  conda env update --name imdreader --file docs/requirements.yaml
  ``` -->
  Build this package from source:
  ```
  pip install -e .
  ```
  If you want to update your dependencies (which can be risky!), run:
  ```
  conda update --all
  ```
  And when you are finished, you can exit the virtual environment with:
  ```
  conda deactivate
  ```

  To build the package from source, run:
  ```
  pip install .
  ```
  If you want to create a development environment, install
  the dependencies required for tests and docs with:
  ```
  pip install ".[test,doc]"
  ```

  The IMDClient source code is hosted at https://github.com/becksteinlab/imdclient
  and is available under the MIT license (see the file [LICENSE](https://github.com/becksteinlab/imdclient/blob/main/LICENSE)).
  Copyright (c) 2024, Lawson

  Project based on the
  [MDAnalysis Cookiecutter](https://github.com/MDAnalysis/cookiecutter-mda) version 0.1.
  <!-- Please cite [MDAnalysis](https://github.com/MDAnalysis/mdanalysis#citation) when using IMDReader in published work. -->

rpm_license:
  Copyright 2024 Lawson Woods  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.


pkgId: 09b6d21e11e8a6253a78328afecdadb72526181311f95f442cacca85f13ecb3d
name: python-imgocr-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for imgocr
url: https://github.com/shibing624/imgocr
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-imgocr-0.0.2-1.src.rpm
location_href: Packages/python-imgocr-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/imgocr.svg)](https://badge.fury.io/py/imgocr)
  [![Downloads](https://static.pepy.tech/badge/imgocr)](https://pepy.tech/project/imgocr)
  [![Contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg)](CONTRIBUTING.md)
  [![License Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
  [![python_version](https://img.shields.io/badge/Python-3.5%2B-green.svg)](requirements.txt)
  [![GitHub issues](https://img.shields.io/github/issues/shibing624/imgocr.svg)](https://github.com/shibing624/imgocr/issues)
  [![Wechat Group](https://img.shields.io/badge/wechat-group-green.svg?logo=wechat)](#Contact)
  **imgocr**：Python3 package for Chinese/English OCR, with paddleocr-v4 onnx model(~14MB).
  **imgocr**：基于PaddleOCR-v4-onnx模型（~14MB）推理，性能更高，可实现 CPU 上毫秒级的 OCR 精准预测，在通用场景上达到开源SOTA。

  | 银行存根                                                                                                     | 表格                                                                                                        |
  |----------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
  | <img src="https://github.com/shibing624/imgocr/blob/main/examples/ocr_results/00111002.jpg" width="500"> | <img src="https://github.com/shibing624/imgocr/blob/main/examples/ocr_results/00015504.jpg" width="600">  |
  | 火车票                                                                                                      | 英文论文                                                                                                      |
  | <img src="https://github.com/shibing624/imgocr/blob/main/examples/ocr_results/00056221.jpg" width="500"> | <img src="https://github.com/shibing624/imgocr/blob/main/examples/ocr_results/eng_paper.png" width="600"> |

  PP-OCRv4串联系统由文本检测模型和文本识别模型串联完成，首先输入预测图片，经过文本检测模型获取全部的检测框。根据检测框坐标在原图中抠出文本行，并进行矫正，最后将全部文本行送入文本识别模型，得到文本结果。
  整个流程如下图所示：
  <img src="https://github.com/shibing624/imgocr/blob/main/docs/ppocrv4_framework.png" width="800" alt="ppocr-v4">
  OCR 检测/识别 benchmark：
  | 模型               | 检测 mAP(%) | 识别 Acc(%) | GPU 推理耗时(ms) | CPU 推理耗时(ms) | 模型存储大小(M)  |
  |------------------|-----------|-----------|-----------------|------------------|------------|
  | PP-OCRv4-mobile  | 77.79     | 78.20     | 2.719474        | 79.1097           | 14         |
  > GPU 推理耗时基于 NVIDIA Tesla T4 机器，精度类型为 FP32，CPU 推理速度基于 Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz，精度类型为 FP32。
  > OCR 评估集是 PaddleOCR 自建的中文数据集，覆盖街景、网图、文档、手写多个场景，其中文本识别包含1.1w张图片，检测包含500张图片。

  HuggingFace Demo: https://huggingface.co/spaces/shibing624/imgocr
  ![](https://github.com/shibing624/imgocr/blob/main/docs/imgocr_hf.png)
  run example: [examples/gradio_demo.py](https://github.com/shibing624/imgocr/blob/main/examples/gradio_demo.py) to see the demo:
  ```shell
  python examples/gradio_demo.py
  ```

  ```shell
  pip install -U imgocr
  ```
  or
  ```shell
  pip install -r requirements.txt
  git clone https://github.com/shibing624/imgocr.git
  cd imgocr
  pip install --no-deps .
  ```


  example: [examples/ocr_demo.py](https://github.com/shibing624/imgocr/blob/main/examples/ocr_demo.py)
  ```python
  from imgocr import ImgOcr
  m = ImgOcr()
  result = m.ocr("data/11.jpg")
  print("result:", result)
  ```
  output:
  ![](https://github.com/shibing624/imgocr/blob/main/examples/ocr_results/11.jpg)

  支持批量做OCR识别
  code: [cli.py](https://github.com/shibing624/imgocr/blob/main/imgocr/cli.py)
  ```
  > imgocr -h
  usage: cli.py [-h] --image_dir IMAGE_DIR [--output_dir OUTPUT_DIR]
                [--chunk_size CHUNK_SIZE] [--use_gpu USE_GPU]
  imgocr cli
  options:
    -h, --help            show this help message and exit
    --image_dir IMAGE_DIR
                          input image dir path, required
    --output_dir OUTPUT_DIR
                          output ocr result dir path, default outputs
    --chunk_size CHUNK_SIZE
                          chunk size, default 10
    --use_gpu USE_GPU     use gpu, default False
  ```
  run：
  ```shell
  pip install imgocr -U
  imgocr --image_dir data
  ```
  > 输入图片目录（--image_dir， required）

  - Issue(建议)：[![GitHub issues](https://img.shields.io/github/issues/shibing624/imgocr.svg)](https://github.com/shibing624/imgocr/issues)
  - 邮件我：xuming: xuming624@qq.com
  - 微信我：加我*微信号：xuming624, 备注：姓名-公司-NLP* 进NLP交流群。
  <img src="https://github.com/shibing624/imgocr/blob/main/docs/wechat.jpeg" width="200" />

  如果你在研究中使用了imgocr，请按如下格式引用：
  APA:
  ```latex
  Xu, M. imgocr: Image OCR toolkit (Version 0.0.1) [Computer software]. https://github.com/shibing624/imgocr
  ```
  BibTeX:
  ```latex
  @misc{imgocr,
    author = {Ming Xu},
    title = {imgocr: Image OCR toolkit},
    year = {2024},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/shibing624/imgocr}},
  }
  ```

  授权协议为 [The Apache License 2.0](LICENSE)，可免费用做商业用途。请在产品说明中附加imgocr的链接和授权协议。

  项目代码还很粗糙，如果大家对代码有所改进，欢迎提交回本项目，在提交之前，注意以下两点：
   - 在`tests`添加相应的单元测试
   - 使用`python -m pytest -v`来运行所有单元测试，确保所有单测都是通过的
  之后即可提交PR。

  - [RapidOCR](https://github.com/RapidAI/RapidOCR)
  - [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)
  - [Paddle2ONNX](https://github.com/PaddlePaddle/Paddle2ONNX)
  - [ppocr-onnx](https://github.com/triwinds/ppocr-onnx)


pkgId: 749c021a1ac8c02dc5207f2bbae0a1bffb76c59824909eb221e168ebee6fb611
name: python-immuneML-help
arch: noarch
version: 3.0.5
epoch: 0
release: 1
summary: Development documents and examples for immuneML
url: https://github.com/uio-bmi/immuneML
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-immuneML-3.0.5-1.src.rpm
location_href: Packages/python-immuneML-help-3.0.5-1.noarch.rpm
checksum_type: sha256
description:
  ![Python application](https://github.com/uio-bmi/immuneML/workflows/Python%20application/badge.svg?branch=master)
  ![Docker](https://github.com/uio-bmi/immuneML/workflows/Docker/badge.svg?branch=master)
  [![](https://img.shields.io/static/v1?label=AIRR-C%20sw-tools%20v1&message=compliant&color=008AFF&labelColor=000000&style=plastic)](https://docs.airr-community.org/en/stable/swtools/airr_swtools_standard.html)

  immuneML is a platform for machine learning-based analysis and
  classification of adaptive immune receptors and repertoires (AIRR).

  It supports the analyses of experimental B- and T-cell receptor data,
  as well as synthetic data for benchmarking purposes.

  In immuneML, users can define flexible workflows supporting different
  machine learning libraries (such as scikit-learn or PyTorch), benchmarking of different approaches, numerous reports
  of data characteristics, ML algorithms and their predictions, and
  visualizations of results.

  Additionally, users can extend the platform by defining their own data
  representations, ML models, reports and visualizations.


  Useful links:
  - Main website: https://immuneml.uio.no
  - Documentation: https://docs.immuneml.uio.no
  - Galaxy web interface: https://galaxy.immuneml.uiocloud.no






  We recommend installing immuneML inside a virtual environment.
  immuneML uses **Python 3.9 or later**. If using immuneML simulation, Python 3.11 or later is recommended.
  immuneML can be [installed directly using a package manager](<https://docs.immuneml.uio.no/latest/installation/install_with_package_manager.html#>) such as pip or conda,
  or [set up via docker](<https://docs.immuneml.uio.no/latest/installation/installation_docker.html>).



  ```bash
  python3 -m venv ./immuneml_venv/
  source ./immuneml_venv/bin/activate
  pip install wheel
  pip install immune-ml
  ```

  or

  ```bash
  conda create --prefix immuneml_env/ python=3.11
  conda activate immuneml_env/
  conda install -c bioconda immuneml
  ```



  Please check the documentation for more detailed instructions or [how to install optional dependencies](<https://docs.immuneml.uio.no/latest/installation/install_with_package_manager.html#installing-optional-dependencies>).



  To validate the installation, run:

  ```bash
  immune-ml -h
  ```

  This should display a help message explaining immuneML usage.

  To quickly test out whether immuneML is able to run, try running the quickstart command:

  ```bash
  immune-ml-quickstart ./quickstart_results/
  ```

  This will generate a synthetic dataset and run a simple machine machine learning analysis
  on the generated data. The results folder will contain two sub-folders: one for the generated dataset (`synthetic_dataset`)
  and one for the results of the machine learning analysis (`machine_learning_analysis`).
  The files named `specs.yaml` are the input files for immuneML that describe how to generate
  the dataset and how to do the machine learning analysis. The `index.html` files can be used
  to navigate through all the results that were produced.





  The quickest way to familiarize yourself with immuneML usage is to follow
  one of the [Quickstart tutorials](https://docs.immuneml.uio.no/quickstart.html).
  These tutorials provide a step-by-step guide on how to use immuneML for a
  simple machine learning analysis on an adaptive immune receptor repertoire (AIRR) dataset,
  using either the command line tool or the [Galaxy web interface](https://galaxy.immuneml.uiocloud.no).




  The figure below shows an overview of immuneML usage.
  All parameters for an immuneML analysis are defined in the YAML specification file.
  In this file, the settings of the analysis components are defined (also known as `definitions`,
  shown in different colors in the figure).
  Additionally, the YAML file describes one or more `instructions`, which are workflows that are
  applied to the defined analysis components.
  See also: [documentation of the YAML specification](https://docs.immuneml.uio.no/latest/yaml_specs/how_to_specify_an_analysis_with_yaml.html).

  Each instruction produces different types of results, including trained ML models,
  ML model predictions on a given dataset, plots or other reports describing the
  dataset or trained models, or synthetic/simulated datasets.
  These results can be navigated through the summary HTML file.
  See also: [tutorials for specific immuneML use cases](https://docs.immuneml.uio.no/latest/tutorials.html#).


  ![image info](https://docs.immuneml.uio.no/latest/_images/definitions_instructions_overview.png)




  The `immune-ml` command takes only two parameters: the YAML specification file and a result path.
  An example is given here:

  ```bash
  immune-ml path/to/specification.yaml result/folder/path/
  ```



  For each instruction specified in the YAML specification file, a subfolder is created in the
  `result/folder/path`. Each subfolder will contain:
  - An `index.html` file which shows an overview of the results produced by that instruction. Inspecting the results of an immuneML analysis typically starts here.
  - A copy of the used YAML specification (`full_specification.yaml`) with all default parameters explicitly set.
  - A log file (`log.txt`).
  - A folder containing the imported dataset(s) in immuneML format.
  - A folder containing all raw results produced by the instruction.



  We will prioritize fixing important bugs, and try to answer any questions as soon as possible.
  Please note we are only 2 people maintaining the platform with occasional absences.

  When experiencing an issue, please take the following steps:

  1. **Make sure the latest version of immuneML is installed.** immuneML is under constant development, and the issue you experience may already be resolved in the latest version of the platform.

  2. Check the ['troubleshooting' page](<https://docs.immuneml.uio.no/latest/troubleshooting.html>) in the immuneML documentation. Any known issues and their solutions are already described there.

  3. If you are still experience a problem and suspect a bug in immuneMl, you can [report an issue on GitHub](https://github.com/uio-bmi/immuneML/issues). Please make sure to include the following information:
      - The YAML specification you tried to run.
      - The full output log file (log.txt).
      - A list of dependency versions (can be retrieved with pip list or conda list).
      - We primarily test immuneML using Unix-based operating systems, please make sure to mention it if you're using Windows.
      - We will be able to help you fastest if you can also provide a small reproducible example, such as a very small dataset for which your run fails.


  If this does not answer your question, you can contact us via:
  - Twitter [`@immuneml`](https://twitter.com/immuneml)
  - Email [`contact@immuneml.uio.no`](mailto:contact@immuneml.uio.no)





  If you are using immuneML in any published work, please cite:

  Pavlović, M., Scheffer, L., Motwani, K. et al. The immuneML ecosystem for machine learning analysis of adaptive immune
  receptor repertoires. Nat Mach Intell 3, 936–944 (2021). https://doi.org/10.1038/s42256-021-00413-z



  <hr>


  © Copyright 2021-2022, Milena Pavlovic, Lonneke Scheffer, Keshav Motwani, Victor Greiff, Geir Kjetil Sandve


