# packages

pkgId: 01dbee299e24392ac2816d02ad006167ee2e738bad847b90eff7797a69253e00
name: python-immunity-iast-help
arch: noarch
version: 0.1.10
epoch: 0
release: 1
summary: Development documents and examples for immunity-iast
url: https://pypi.org/project/immunity-iast/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-immunity-iast-0.1.10-1.src.rpm
location_href: Packages/python-immunity-iast-help-0.1.10-1.noarch.rpm
checksum_type: sha256
description:
  IAST-агент, встраиваемый в сканируемые приложения на Python. Инструментирование реализуется путём внедрения middleware для перехвата обработки запросов.

  Поддерживаемые фреймворки:
  - `Django`
  - TODO: `Flask`

  Установка агента:

  ```bash
  pip install --index-url https://gitverse.ru/api/packages/immunity_iast/pypi/simple/ immunity-python-agent
  ```

  Обновление установленного ранее пакета:

  ```bash
  pip install --index-url https://gitverse.ru/api/packages/immunity_iast/pypi/simple/ immunity-python-agent --upgrade
  ```

  Интеграция установленного агента в Django-проект:

  ```python
  INSTALLED_APPS = [
      
      'immunity_agent'
  ]

  MIDDLEWARE = [
      
      'immunity_agent.middlewares.django_middleware.ImmunityDjangoMiddleware'
  ]
  ```

  Конфигурирование агента:

  ```bash
  python -m immunity_agent 127.0.0.1 80 test
  ```

  Вызов через шелл, в качестве аргументов передаём хост и порт серверной части и имя приложения (должно быть создано на сервере).

  Далее просто запустите Django-проект. Агент активируется автоматически.


pkgId: 624e65f2a2f4b68e816c5d6e5105d3974c79ef584c681aff76887a573dc5ff29
name: python-imt-diodem-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for imt-diodem
url: https://github.com/SimiPixel/diodem
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-imt-diodem-1.1.3-1.src.rpm
location_href: Packages/python-imt-diodem-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  ![](imgs/pose1_noBG.png)



  This repository contains the source code of a Python Package (published on PyPI under `imt-diodem`) that allows for easy-access to the DIODEM dataset.

  > **ℹ️ Installation:**
  >
  > You can install with `pip install imt-diodem`.

  > **ℹ️ Documentation:**
  >
  > You can access the [Diodem Data Description](./docs/diodem.pdf) here.

  The dataset files are hosted on Harvard Dataverse (https://doi.org/10.7910/DVN/SGJLZA). This Python Package then downloads the required dataset files from Dataverse on-demand.


  ```python
  import diodem


  data = diodem.load_data(
      exp_id         = 1,
      motion_start   = 1,
      motion_stop    = 3,
      resample_to_hz = 100
  )

  print(data.keys())


  print(data['seg1'].keys())


  print(data['seg1']['imu_rigid'].keys())

  ```


pkgId: aadcca9f4054439de0f84adb374725283a99101181c7ebc61de0322e40d40375
name: python-imt-ring-help
arch: noarch
version: 1.6.29
epoch: 0
release: 1
summary: Development documents and examples for imt-ring
url: https://github.com/SimiPixel/ring
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-imt-ring-1.6.29-1.src.rpm
location_href: Packages/python-imt-ring-help-1.6.29-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="https://raw.githubusercontent.com/simon-bachhuber/ring/main/docs/img/icon.svg" height="200" />
  </p>


  <img src="https://raw.githubusercontent.com/simon-bachhuber/ring/main/docs/img/coverage_badge.svg" height="20" />

  > **ℹ️ Tip:**
  >
  > Check out my new plug-and-play interface for inertial motion tracking (RING included) [here](https://github.com/simon-bachhuber/imt.git).



  Supports `Python=3.10/3.11/3.12` (tested).

  Install with `pip` using

  `pip install imt-ring`

  Typically, this will install `jax` as cpu-only version. Afterwards, gpu-enabled version can be installed with
  ```bash
  pip install --upgrade "jax[cuda12_pip]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
  ```



  Available [here](https://simipixel.github.io/ring/).


  ```python
  import ring
  import numpy as np

  T  : int       = 30        # sequence length     [s]
  Ts : float     = 0.01      # sampling interval   [s]
  B  : int       = 1         # batch size
  lam: list[int] = [0, 1, 2] # parent array
  N  : int       = len(lam)  # number of bodies
  T_i: int       = int(T/Ts) # number of timesteps

  X              = np.zeros((B, T_i, N, 9))







  X[..., 0, :3]  = acc_segment1
  X[..., 2, :3]  = acc_segment3
  X[..., 0, 3:6] = gyr_segment1
  X[..., 2, 3:6] = gyr_segment3

  ringnet = ring.RING(lam, Ts)
  yhat, _ = ringnet.apply(X)

  ```





  > mujoco.FatalError: an OpenGL platform library has not been loaded into this process, this most likely means that a valid OpenGL context has not been created before mjr_makeContext was called

  Solution:

  ```python
  import os
  os.environ["MUJOCO_GL"] = "egl"
  ```



  > ImportError: DLL load failed while importing _multiarray_umath: Das angegebene Modul wurde nicht gefunden.

  Solution:
  1. `pip uninstall -y jax jaxlib`
  2. `conda install -c conda-forge jax`



  The following publications utilize this software library, and refer to it as the *Random Chain Motion Generator (RCMG)* (more specifically the function `ring.RCMG`):

  - [*RNN-based Observability Analysis for Magnetometer-Free Sparse Inertial Motion Tracking*](https://ieeexplore.ieee.org/document/9841375)
  - [*Plug-and-Play Sparse Inertial Motion Tracking With Sim-to-Real Transfer*](https://ieeexplore.ieee.org/document/10225275)
  - [*RNN-based State and Parameter Estimation for Sparse Magnetometer-free Inertial Motion Tracking*](https://www.journals.infinite-science.de/index.php/automed/article/view/745)



  Particularly useful is the following publication from *Roy Featherstone*
  - [*A Beginner’s Guide to 6-D Vectors (Part 2)*](https://ieeexplore.ieee.org/document/5663690)



  Simon Bachhuber (simon.bachhuber@fau.de)


pkgId: 014c96826ba2b8c7b792b639edd0c1943f82717060ae48c2278832fdf35184aa
name: python-imy-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for imy
url: https://pypi.org/project/imy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-imy-0.6.0-1.src.rpm
location_href: Packages/python-imy-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  Utilities I can't go without.

  This package contains a bunch of common functionality I tend to share across
  projects. It's a bit of a grab bag - maybe you'll find something useful to you.


pkgId: 884ae1533f108c5651e1b76d340a975656ad7872e864b1a3ea8e768e83cc6b3d
name: python-inc-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for inc
url: https://pypi.org/project/inc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inc-0.1.0-1.src.rpm
location_href: Packages/python-inc-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Install basic software for different operating systems:

  [See documentation](https://install-new-computer.readthedocs.io/en/latest/)



  ```
  pip install inc
  ```



  Copy-paste these 3 lines into a terminal. For example `bash install mac.mk` will run the macOs installer

  ```
  git clone https://github.com/joamatab/install_new_computer.git ~/install_new_computer
  cd install_new_computer/bash
  bash install mac
  ```

  where you can replace mac.mk by any of the supported OS:

  - arch
  - centos
  - fedora
  - mac
  - ubuntu

  This install the specific `install` section of the Makefile for the selected distro.

  To install specific sections of each Makefile you can also run

  ```
  bash install centos desktop
  ```

  For MacOs type this into a terminal

  ```
  xcode-select --install
  ```




  ```
  inc --help
  ```

  Links:

  - [my dotfiles wiki](https://github.com/joamatab/dotfiles/wiki)
  - [my dotfiles](https://github.com/joamatab/dotfiles)
  - [mac CLI](https://github.com/guarinogabriel/mac-cli)
  - https://github.com/jaywcjlove/awesome-mac.git
  - https://www.stuartellis.name/articles/mac-setup/
  - https://dotfiles.github.io/
  - https://github.com/atomantic/dotfiles
  - https://sourabhbajaj.com/mac-setup/
  - https://github.com/gotbletu
  - https://lukesmith.xyz/
  - http://www.openvim.com/tutorial.html


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

  The Increase Python library provides convenient access to the Increase 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).



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



  ```sh

  pip install increase
  ```



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

  ```python
  import os
  from increase import Increase

  client = Increase(
      api_key=os.environ.get("INCREASE_API_KEY"),  # This is the default and can be omitted
      
      environment="sandbox",
  )

  account = client.accounts.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  print(account.id)
  ```

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



  Simply import `AsyncIncrease` instead of `Increase` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from increase import AsyncIncrease

  client = AsyncIncrease(
      api_key=os.environ.get("INCREASE_API_KEY"),  # This is the default and can be omitted
      
      environment="sandbox",
  )


  async def main() -> None:
      account = await client.accounts.create(
          name="New Account!",
          entity_id="entity_n8y8tnk2p9339ti393yi",
          program_id="program_i2v2os4mwza1oetokh9i",
      )
      print(account.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 Increase 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 increase import Increase

  client = Increase()

  all_accounts = []

  for account in client.accounts.list():
      
      all_accounts.append(account)
  print(all_accounts)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from increase import AsyncIncrease

  client = AsyncIncrease()


  async def main() -> None:
      all_accounts = []
      
      async for account in client.accounts.list():
          all_accounts.append(account)
      print(all_accounts)


  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.accounts.list()
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.data)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.accounts.list()

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


  ```



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

  ```python
  from increase import Increase

  client = Increase()

  account = client.accounts.create(
      name="New Account!",
  )
  print(account.id)
  ```



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

  ```python
  from pathlib import Path
  from increase import Increase

  client = Increase()

  client.files.create(
      file=Path("my/file.txt"),
      purpose="check_image_front",
  )
  ```

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



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

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

  All errors inherit from `increase.APIError`.

  ```python
  import increase
  from increase import Increase

  client = Increase()

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


  client = Increase(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).accounts.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  ```



  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 increase import Increase


  client = Increase(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).accounts.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

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

  ```shell
  $ export INCREASE_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 increase import Increase

  client = Increase()
  response = client.accounts.with_raw_response.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  print(response.headers.get('X-My-Header'))

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

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

  The async client returns an [`AsyncAPIResponse`](https://github.com/Increase/increase-python/tree/main/src/increase/_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.accounts.with_streaming_response.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  ) 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 increase import Increase, DefaultHttpxClient

  client = Increase(
      
      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/Increase/increase-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 increase
  print(increase.__version__)
  ```



  Python 3.8 or higher.



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


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

  The Increase Python library provides convenient access to the Increase 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).



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



  ```sh

  pip install increase
  ```



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

  ```python
  import os
  from increase import Increase

  client = Increase(
      api_key=os.environ.get("INCREASE_API_KEY"),  # This is the default and can be omitted
      
      environment="sandbox",
  )

  account = client.accounts.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  print(account.id)
  ```

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



  Simply import `AsyncIncrease` instead of `Increase` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from increase import AsyncIncrease

  client = AsyncIncrease(
      api_key=os.environ.get("INCREASE_API_KEY"),  # This is the default and can be omitted
      
      environment="sandbox",
  )


  async def main() -> None:
      account = await client.accounts.create(
          name="New Account!",
          entity_id="entity_n8y8tnk2p9339ti393yi",
          program_id="program_i2v2os4mwza1oetokh9i",
      )
      print(account.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 Increase 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 increase import Increase

  client = Increase()

  all_accounts = []

  for account in client.accounts.list():
      
      all_accounts.append(account)
  print(all_accounts)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from increase import AsyncIncrease

  client = AsyncIncrease()


  async def main() -> None:
      all_accounts = []
      
      async for account in client.accounts.list():
          all_accounts.append(account)
      print(all_accounts)


  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.accounts.list()
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.data)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.accounts.list()

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


  ```



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

  ```python
  from increase import Increase

  client = Increase()

  account = client.accounts.create(
      name="New Account!",
  )
  print(account.id)
  ```



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

  ```python
  from pathlib import Path
  from increase import Increase

  client = Increase()

  client.files.create(
      file=Path("my/file.txt"),
      purpose="check_image_front",
  )
  ```

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



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

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

  All errors inherit from `increase.APIError`.

  ```python
  import increase
  from increase import Increase

  client = Increase()

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


  client = Increase(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).accounts.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  ```



  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 increase import Increase


  client = Increase(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).accounts.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

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

  ```shell
  $ export INCREASE_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 increase import Increase

  client = Increase()
  response = client.accounts.with_raw_response.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  )
  print(response.headers.get('X-My-Header'))

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

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

  The async client returns an [`AsyncAPIResponse`](https://github.com/Increase/increase-python/tree/main/src/increase/_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.accounts.with_streaming_response.create(
      name="New Account!",
      entity_id="entity_n8y8tnk2p9339ti393yi",
      program_id="program_i2v2os4mwza1oetokh9i",
  ) 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 increase import Increase, DefaultHttpxClient

  client = Increase(
      
      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.

  ```py
  from increase import Increase

  with Increase() as client:
    
    ...


  ```



  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/Increase/increase-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 increase
  print(increase.__version__)
  ```



  Python 3.8 or higher.



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


pkgId: 2e2a8ee98e945265ebf181d6bfd37592eff5e52732840443bcbe7a8090a4845b
name: python-indexify-help
arch: noarch
version: 0.2.41
epoch: 0
release: 1
summary: Development documents and examples for indexify
url: https://github.com/tensorlakeai/indexify
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-indexify-0.2.41-1.src.rpm
location_href: Packages/python-indexify-help-0.2.41-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/indexify.svg)](https://badge.fury.io/py/indexify)
  [![Discord](https://dcbadge.vercel.app/api/server/VXkY7zVmTD?style=flat&compact=true)](https://discord.gg/VXkY7zVmTD)

  This is the Python SDK to build real-time continuously running unstructured data processing pipelines with Indexify.

  Start by writing and testing your pipelines locally using your data, then deploy them into the Indexify service to process data in real-time at scale.



  ```shell
  pip install indexify
  ```


  **[PDF Document Extraction](../examples/pdf_document_extraction/workflow.py)**
  1. Extracts text, tables and images from an ingested PDF file
  2. Indexes the text using MiniLM-L6-v2, the images with CLIP
  3. Writes the results into a vector database.

  **[Youtube Transcription Summarizer](../examples/video_summarization/workflow.py)**
  1. Downloads Youtube Video
  2. Extracts audio from the video and transcribes using `Faster Whisper`
  3. Uses Llama 3.1 backed by `Llama.cpp` to understand and classify the nature of the video.
  4. Routes the transcription dynamically to one of the transcription summarizer to retain specific summarization attributes.
  5. Finally the entire transcription is embedded and stored in a vector database for retrieval.


  1. Write data processing functions in Python and use Pydantic objects for returning complex data types from functions
  2. Connect functions using a graph interface. Indexify automatically stores function outputs and passes them along to downstream functions.
  3. If a function returns a list, the downstream functions will be called with each item in the list in **parallel**.
  4. The input of the first function becomes the input to the HTTP endpoint of the Graph.


  1. There is **NO** limit to volume of data being ingested since we use blob stores for storing metadata and objects
  2. The server can handle 10s of 1000s of files being ingested into the graphs in parallel.
  3. The scheduler reacts under 8 microseconds to ingestion events, so it's suitable for workflows which needs to run in realtime.
  4. Batch ingestion is handled gracefully by batching ingested data and scheduling for high throughput in production settings.

  ```python
  from pydantic import BaseModel
  from indexify import indexify_function
  from typing import Dict, Any, Optional, List


  class Document(BaseModel):
      text: str
      metadata: Dict[str, Any]

  class TextChunk(BaseModel):
      text: str
      metadata: Dict[str, Any]
      embedding: Optional[List[float]] = None



  @indexify_function()
  def split_text(doc: Document) -> List[TextChunk]:
      midpoint = len(doc.text) // 2
      first_half = TextChunk(text=doc.text[:midpoint], metadata=doc.metadata)
      second_half = TextChunk(text=doc.text[midpoint:], metadata=doc.metadata)
      return [first_half, second_half]


  @indexify_function(requirements=["langchain_text_splitter"])
  def compute_embedding(chunk: TextChunk) -> TextChunk:
      chunk.embedding = [0.1, 0.2, 0.3]
      return chunk


  @indexify_function(executor_runtime_name="postgres-driver-image")
  def write_to_db(chunk: TextChunk):
      
      ...


  from indexify import Graph

  g = Graph(name="my_graph", start_node=split_text)
  g.add_edge(split_text, compute_embedding)
  g.add_edge(embed_text, write_to_db)
  ```


  Every time the Graph is invoked, Indexify will provide an `Invocation Id` which can be used to know about the status of the processing and any outputs from the Graph.


  ```python
  from indexify import IndexifyClient

  client = IndexifyClient(local=True)
  client.register_graph(g)
  invocation_id = client.invoke_graph_with_object(g.name, Document(text="Hello, world!", metadata={"source": "test"}))
  graph_outputs = client.graph_outputs(g.name, invocation_id)
  ```


  > Work In Progress - The version of server that works with python based graphs haven't been released yet. It will be shortly released. Join discord for development updates.
  ```python
  from indexify import IndexifyClient

  client = IndexifyClient(service_url="http://localhost:8900")
  client.register_graph(g)
  ```


  Extraction Graphs continuously run on the Indexify Service like any other web service. Indexify Server runs the extraction graphs in parallel and in real-time when new data is ingested into the service.

  ```python
  output_id = client.invoke_graph_with_object(g.name, Document(text="Hello, world!", metadata={"source": "test"}))
  ```


  ```python
  graph_outputs = client.graph_outputs(g.name, output_id)
  ```


  ```python
  graph_inputs = client.graph_inputs(g.name)
  ```


pkgId: 922dd9efc2aeb9fa4e32f5384a536f87ad9b7579bd2fe223b30115114c248a26
name: python-inductiva-help
arch: noarch
version: 0.12.1
epoch: 0
release: 1
summary: Development documents and examples for inductiva
url: https://github.com/inductiva/inductiva
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inductiva-0.12.1-1.src.rpm
location_href: Packages/python-inductiva-help-0.12.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/inductiva/inductiva/actions/workflows/python-package.yml/badge.svg)](https://github.com/inductiva/inductiva/actions/workflows/python-package.yml) [![Python version](https://img.shields.io/pypi/pyversions/inductiva.svg)](https://www.python.org/downloads/) [![Documentation](https://img.shields.io/badge/Documentation-blue.svg)](https://docs.inductiva.ai/en/latest/) [![Benchmarks](https://img.shields.io/badge/Benchmarks-blue.svg)](https://benchmarks.inductiva.ai) <a href="https://pypi.org/project/inductiva/"><img src="https://img.shields.io/pypi/v/inductiva" alt="pypi version"></a> ![coverage badge](https://raw.githubusercontent.com/inductiva/inductiva/Inductiva-badges/badges/cov.svg)

  ![inductiva_banner](https://github.com/inductiva/inductiva/assets/7538022/85569dd8-3beb-4ac3-8cbe-78e300a28fde)




  Welcome to the official Python library for the Inductiva API version **0.10**.
  The Inductiva API allows running a set of open-source physical
  simulators on the cloud, easily parallelizing simulations, each running
  on hundreds of CPU cores.

  Inductiva simplifies the complexities of cloud resource management, and software
  configuration, offering a straightforward Python interface for running simulations
  on state-of-the-art hardware. This allows scientists and engineers to focus their
  time and energy on what matters: running simulations that solve real problems.

  To find out more, check our [documentation](https://docs.inductiva.ai/).


  If you have any questions or suggestions about the API please
  [open an issue on the inductiva’s API Client GitHub repo](https://github.com/inductiva/inductiva/issues),
  or contact us via [support@inductiva.ai](mailto:support@inductiva.ai).


pkgId: 2102cb0bc93b0fbe55d17834749ee52ec6ba6b988702caf64ab344bff61585fc
name: python-inferless-cli-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for inferless-cli
url: https://pypi.org/project/inferless-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inferless-cli-2.0.1-1.src.rpm
location_href: Packages/python-inferless-cli-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Inferless - Deploy Machine Learning Models in Minutes.

  See the website at https://inferless.com/ for documentation and more information
  about running code on Inferless.

  **Usage**:

  ```console
  $ inferless [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `-v, --version`
  * `--install-completion`: Install completion for the current shell.
  * `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
  * `--help`: Show this message and exit.

  **Commands**:

  * `deploy`: Deploy a model to Inferless
  * `export`: Export the runtime configuration of...
  * `init`: Initialize a new Inferless model
  * `integration`: Manage Inferless integrations
  * `log`: Inferless models logs (view build logs or...
  * `login`: Login to Inferless
  * `mode`: Change mode
  * `model`: Manage Inferless models (list , delete ,...
  * `region`: Manage Inferless regions
  * `remote-run`: Remotely run code on inferless
  * `run`: Run a model locally
  * `runtime`: Manage Inferless runtimes (can be used to...
  * `scaffold`: Scaffold a demo Inferless project
  * `secret`: Manage Inferless secrets (list secrets)
  * `token`: Manage Inferless tokens
  * `volume`: Manage Inferless volumes (can be used to...
  * `workspace`: Manage Inferless workspaces (can be used...



  Deploy a model to Inferless

  **Usage**:

  ```console
  $ inferless deploy [OPTIONS]
  ```

  **Options**:

  * `--gpu TEXT`: Denotes the machine type (A10/A100/T4).  [required]
  * `--region TEXT`: Inferless region. Defaults to Inferless default region.
  * `--beta`: Deploys the model with v2 endpoints.
  * `--fractional`: Use fractional machine type (default: dedicated).
  * `--runtime TEXT`: Runtime name or file location. if not provided default Inferless runtime will be used.
  * `--volume TEXT`: Volume name.
  * `--volume-mount-path TEXT`: Custom volume mount path.
  * `--env TEXT`: Key-value pairs for model environment variables.
  * `--inference-timeout INTEGER`: Inference timeout in seconds.  [default: 180]
  * `--scale-down-timeout INTEGER`: Scale down timeout in seconds.  [default: 600]
  * `--container-concurrency INTEGER`: Container concurrency level.  [default: 1]
  * `--secret TEXT`: Secret names to attach to the deployment.
  * `--runtimeversion TEXT`: Runtime version (default: latest version of runtime).
  * `--max-replica INTEGER`: Maximum number of replicas.  [default: 1]
  * `--min-replica INTEGER`: Minimum number of replicas.  [default: 0]
  * `-c, --config TEXT`: Inferless config file path to override from inferless.yaml  [default: inferless.yaml]
  * `--help`: Show this message and exit.



  Export the runtime configuration of another provider to Inferless runtime config

  **Usage**:

  ```console
  $ inferless export [OPTIONS]
  ```

  **Options**:

  * `-r, --runtime TEXT`: The runtime configuration file of another provider  [default: cog.yaml]
  * `-d, --destination TEXT`: The destination file for the Inferless runtime configuration  [default: inferless-runtime-config.yaml]
  * `-f, --from TEXT`: The provider from which to export the runtime configuration  [default: replicate]
  * `--help`: Show this message and exit.



  Initialize a new Inferless model

  **Usage**:

  ```console
  $ inferless init [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `-n, --name TEXT`: Denotes the name of the model.
  * `-s, --source TEXT`: Not needed if local, else provide Github/Gitlab.  [default: local]
  * `-u, --url TEXT`: Denotes the URL of the repo. required if source is not local.
  * `-b, --branch TEXT`: Denotes the branch where the model is located. required if source is not local.
  * `-a, --autobuild`: Enable autobuild for the model. will be False for local source.
  * `--help`: Show this message and exit.

  **Commands**:

  * `docker`: Initialize with Docker.
  * `file`: Import a PyTorch, ONNX, or TensorFlow file...
  * `hf`: Load a model from Hugging Face.
  * `pythonic`: (Default) Deploy a Python workflow.



  Initialize with Docker.

  **Usage**:

  ```console
  $ inferless init docker [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Denotes the name of the model.  [required]
  * `-t, --type TEXT`: Type for import: dockerimage/dockerfile.  [required]
  * `-p, --provider TEXT`: Provider for the model dockerimage = (dockerhub/ecr) dockerfile = (github/gitlab).  [required]
  * `-u, --url TEXT`: Docker image URL or GitHub/GitLab URL.  [required]
  * `-b, --branch TEXT`: Branch for Dockerfile import (GitHub/GitLab). required if type is dockerfile.
  * `-d, --dockerfilepath TEXT`: Path to the Dockerfile. required if type is dockerfile.
  * `-h, --healthapi TEXT`: Health check API endpoint.  [required]
  * `-i, --inferapi TEXT`: Inference API endpoint.  [required]
  * `-s, --serverport INTEGER`: Server port.  [required]
  * `-a, --autobuild`: Enable autobuild for the model.
  * `--help`: Show this message and exit.




  Import a PyTorch, ONNX, or TensorFlow file for inference with Triton server.




  The folder structure for the zip file should be as follows:




  ┌───────────────────────────────────────────────┐



  │ .                                             │



  │ ├── config.pbtxt (optional)                   │



  │ ├── input.json                                │



  │ ├── output.json                               │



  │ ├── 1/                                        │



  │ │   ├── model.xxx (pt/onnx/savedmodel)        │



  └───────────────────────────────────────────────┘





  **Usage**:

  ```console
  $ inferless init file [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Denotes the name of the model.  [required]
  * `-f, --framework TEXT`: Framework of the model. [pytorch, onnx, tensorflow]  [default: pytorch]
  * `-p, --provider TEXT`: Provider for the model (local/gcs/s3).  [default: local]
  * `--url TEXT`: Provider URL. required if provider is not local.
  * `--help`: Show this message and exit.



      Load a model from Hugging Face.



      We will create new files called app.py, inferless_runtime_config.yaml and input_schema.py at your current directory.



  Transformers options: audio-classification, automatic-speech-recognition, conversational, depth-estimation, document-question-answering, feature-extraction, fill-mask, image-classification, image-segmentation, image-to-text, object-detection, question-answering, summarization, table-question-answering, text-classification, text-generation, text2text-generation, token-classification, translation, video-classification, visual-question-answering, zero-shot-classification, zero-shot-image-classification, zero-shot-object-detection




  Diffusers options: Depth-to-Image, Image-Variation, Image-to-Image, Inpaint, InstructPix2Pix,Stable-Diffusion-Latent-Upscaler



  **Usage**:

  ```console
  $ inferless init hf [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Denotes the name of the model.  [required]
  * `-m, --hfmodelname TEXT`: Name of the Hugging Face repo.  [required]
  * `-t, --modeltype TEXT`: Type of the model (transformer/diffuser).  [required]
  * `-k, --tasktype TEXT`: Task type of the model (text-generation).  [required]
  * `--help`: Show this message and exit.



  (Default) Deploy a Python workflow.

  **Usage**:

  ```console
  $ inferless init pythonic [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Denotes the name of the model.  [required]
  * `-s, --source TEXT`: Not needed if local, else provide Github/Gitlab.  [default: local]
  * `-u, --url TEXT`: Denotes the URL of the repo. required if source is not local.
  * `-b, --branch TEXT`: Denotes the branch where the model is located. required if source is not local.
  * `-a, --autobuild`: Enable autobuild for the model. will be False for local source.
  * `--help`: Show this message and exit.



  Manage Inferless integrations

  **Usage**:

  ```console
  $ inferless integration [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `add`: Add an integration to your workspace
  * `list`: List all integrations



  Add an integration to your workspace

  **Usage**:

  ```console
  $ inferless integration add [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `DOCKERHUB`: Add Dockerhub integration to your workspace
  * `ECR`: Add ECR integration to your workspace
  * `GCS`: Add Google cloud storage integration to...
  * `HF`: Add Huggingface integration to your workspace
  * `S3`: Add S3/ECR Integration to your workspace



  Add Dockerhub integration to your workspace

  **Usage**:

  ```console
  $ inferless integration add DOCKERHUB [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Integration name  [required]
  * `--username TEXT`: Username for dockerhub integration  [required]
  * `--access-token TEXT`: Access token for dockerhub integration  [required]
  * `--help`: Show this message and exit.



  Add ECR integration to your workspace

  **Usage**:

  ```console
  $ inferless integration add ECR [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Integration name  [required]
  * `--access-key TEXT`: Access key for aws integration.  [required]
  * `--secret-key TEXT`: Access key for aws integration.  [required]
  * `--help`: Show this message and exit.



  Add Google cloud storage integration to your workspace

  **Usage**:

  ```console
  $ inferless integration add GCS [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Integration name  [required]
  * `--gcp-json-path TEXT`: Path to the GCP JSON key file  [required]
  * `--help`: Show this message and exit.



  Add Huggingface integration to your workspace

  **Usage**:

  ```console
  $ inferless integration add HF [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Integration name  [required]
  * `--api-key TEXT`: API key for huggingface integration  [required]
  * `--help`: Show this message and exit.



  Add S3/ECR Integration to your workspace

  **Usage**:

  ```console
  $ inferless integration add S3 [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Integration name  [required]
  * `--access-key TEXT`: Access key for aws integration.  [required]
  * `--secret-key TEXT`: Access key for aws integration.  [required]
  * `--help`: Show this message and exit.



  List all integrations

  **Usage**:

  ```console
  $ inferless integration list [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  Inferless models logs (view build logs or call logs)

  **Usage**:

  ```console
  $ inferless log [OPTIONS] [MODEL_ID]
  ```

  **Arguments**:

  * `[MODEL_ID]`: Model id or model import id

  **Options**:

  * `-i, --import-logs`: Import logs
  * `-t, --type TEXT`: Logs type [BUILD, CALL]]  [default: BUILD]
  * `--help`: Show this message and exit.



  Login to Inferless

  **Usage**:

  ```console
  $ inferless login [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  Change mode

  **Usage**:

  ```console
  $ inferless mode [OPTIONS] MODE
  ```

  **Arguments**:

  * `MODE`: The mode to run the application in, either 'DEV' or 'PROD'.  [required]

  **Options**:

  * `--help`: Show this message and exit.



  Manage Inferless models (list , delete , activate , deactivate , rebuild the models)

  **Usage**:

  ```console
  $ inferless model [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `activate`: activate a model.
  * `deactivate`: deactivate a model.
  * `delete`: delete a model.
  * `info`: Get model details.
  * `list`: List all models.
  * `patch`: patch model configuration.
  * `rebuild`: rebuild a model.



  activate a model.

  **Usage**:

  ```console
  $ inferless model activate [OPTIONS]
  ```

  **Options**:

  * `--model-id TEXT`: Model ID
  * `--help`: Show this message and exit.



  deactivate a model.

  **Usage**:

  ```console
  $ inferless model deactivate [OPTIONS]
  ```

  **Options**:

  * `--model-id TEXT`: Model ID
  * `--help`: Show this message and exit.



  delete a model.

  **Usage**:

  ```console
  $ inferless model delete [OPTIONS]
  ```

  **Options**:

  * `--model-id TEXT`: Model ID
  * `--help`: Show this message and exit.



  Get model details.

  **Usage**:

  ```console
  $ inferless model info [OPTIONS]
  ```

  **Options**:

  * `--model-id TEXT`: Model ID
  * `--help`: Show this message and exit.



  List all models.

  **Usage**:

  ```console
  $ inferless model list [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  patch model configuration.

  **Usage**:

  ```console
  $ inferless model patch [OPTIONS]
  ```

  **Options**:

  * `--model-id TEXT`: Model ID
  * `--gpu TEXT`: Denotes the machine type (A10/A100/T4).
  * `--fractional`: Use fractional machine type (default: dedicated).
  * `--volume TEXT`: Volume name.
  * `--mount-path TEXT`: Volume Mount path for the volume.
  * `--env TEXT`: Key-value pairs for model environment variables.
  * `--inference-timeout INTEGER`: Inference timeout in seconds.
  * `--scale-down-timeout INTEGER`: Scale down timeout in seconds.
  * `--container-concurrency INTEGER`: Container concurrency level.
  * `--secret TEXT`: Secret names to attach to the deployment.
  * `--runtimeversion TEXT`: Runtime version (default: latest).
  * `--max-replica INTEGER`: Maximum number of replicas.
  * `--min-replica INTEGER`: Minimum number of replicas.
  * `--help`: Show this message and exit.



  rebuild a model. (If you have a inferless.yaml file in your current directory, you can use the --local or -l flag to redeploy the model locally.)

  **Usage**:

  ```console
  $ inferless model rebuild [OPTIONS]
  ```

  **Options**:

  * `--model-id TEXT`: Model ID  [required]
  * `-l, --local`: Local rebuild
  * `-r, --runtime-path TEXT`: runtime file path.
  * `-rv, --runtime-version TEXT`: runtime version.
  * `--help`: Show this message and exit.



  Manage Inferless regions

  **Usage**:

  ```console
  $ inferless region [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `list`: List available regions



  List available regions

  **Usage**:

  ```console
  $ inferless region list [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  Remotely run code on inferless

  **Usage**:

  ```console
  $ inferless remote-run [OPTIONS] [FILE_PATH]
  ```

  **Arguments**:

  * `[FILE_PATH]`: The path to the file to run on Inferless

  **Options**:

  * `-c, --config TEXT`: The path to the Inferless config file
  * `-e, --exclude TEXT`: The path to the file to exclude from the run, use .gitignore format. If not provided, .gitignore will be used if present in the directory.
  * `--help`: Show this message and exit.



  Run a model locally

  **Usage**:

  ```console
  $ inferless run [OPTIONS]
  ```

  **Options**:

  * `-r, --runtime TEXT`: custom runtime name or file location. if not provided default Inferless runtime will be used.
  * `-t, --type TEXT`: Type of runtime to run [inferless, replicate]
  * `-n, --name TEXT`: Name of the model to deploy on inferless  [default: inferless-model]
  * `-f, --env-file TEXT`: Path to an env file containing environment variables (one per line in KEY=VALUE format)
  * `-e, --env TEXT`: Environment variables to set for the runtime (e.g. 'KEY=VALUE'). If the env variable contains special chars please escape them.
  * `-u, --docker-base-url TEXT`: Docker base url. Defaults to system default, feteched from env
  * `--volume TEXT`: Volume name.
  * `-f, --framework TEXT`: Framework type. (PYTORCH, ONNX, TENSORFLOW)  [default: PYTORCH]
  * `-i, --input-schema TEXT`: Input schema path. (Default: input_schema.json)  [default: input_schema.py]
  * `-i, --input TEXT`: Input json path
  * `-o, --output TEXT`: Output json path
  * `--runtimeversion TEXT`: Runtime version (default: latest).
  * `--help`: Show this message and exit.



  Manage Inferless runtimes (can be used to list runtimes and upload new runtimes)

  **Usage**:

  ```console
  $ inferless runtime [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `create`: Create a runtime.
  * `generate`: use to generate a new runtime from your...
  * `list`: List all runtimes.
  * `patch`: Update the runtime with the config file.
  * `version-list`: use to list the runtime versions



  Create a runtime.

  **Usage**:

  ```console
  $ inferless runtime create [OPTIONS]
  ```

  **Options**:

  * `-p, --path TEXT`: Path to the runtime
  * `-n, --name TEXT`: Name of the runtime
  * `--help`: Show this message and exit.



  use to generate a new runtime from your local environment

  **Usage**:

  ```console
  $ inferless runtime generate [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  List all runtimes.

  **Usage**:

  ```console
  $ inferless runtime list [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  Update the runtime with the config file.

  **Usage**:

  ```console
  $ inferless runtime patch [OPTIONS]
  ```

  **Options**:

  * `-p, --path TEXT`: Path to the runtime
  * `-i, --name TEXT`: ID of the runtime
  * `--help`: Show this message and exit.



  use to list the runtime versions

  **Usage**:

  ```console
  $ inferless runtime version-list [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: runtime name
  * `--help`: Show this message and exit.



  Scaffold a demo Inferless project

  **Usage**:

  ```console
  $ inferless scaffold [OPTIONS]
  ```

  **Options**:

  * `-d, --demo`: Demo name  [required]
  * `--help`: Show this message and exit.



  Manage Inferless secrets (list secrets)

  **Usage**:

  ```console
  $ inferless secret [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `list`: List all secrets.



  List all secrets.

  **Usage**:

  ```console
  $ inferless secret list [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  Manage Inferless tokens

  **Usage**:

  ```console
  $ inferless token [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `set`: Set account credentials for connecting to...



  Set account credentials for connecting to Inferless. If not provided with the command, you will be prompted to enter your credentials.

  **Usage**:

  ```console
  $ inferless token set [OPTIONS]
  ```

  **Options**:

  * `--token-key TEXT`: Account CLI key  [required]
  * `--token-secret TEXT`: Account CLI secret  [required]
  * `--help`: Show this message and exit.



  Manage Inferless volumes (can be used to list volumes and create new volumes)

  **Usage**:

  ```console
  $ inferless volume [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `cp`: Add a file or directory to a volume.
  * `create`: Create a new volume
  * `list`: List all existing volumes
  * `ls`: List files and directories within a volume
  * `rm`: Specify the Inferless path to the file or...



  Add a file or directory to a volume.

  **Usage**:

  ```console
  $ inferless volume cp [OPTIONS]
  ```

  **Options**:

  * `-s, --source TEXT`: Specify the source path (either a local directory/file path or an Inferless path)
  * `-d, --destination TEXT`: Specify the destination path (either a local directory/file path or an Inferless path)
  * `-r, --recursive`: Recursively copy the contents of a directory to the destination.
  * `--help`: Show this message and exit.



  Create a new volume

  **Usage**:

  ```console
  $ inferless volume create [OPTIONS]
  ```

  **Options**:

  * `-n, --name TEXT`: Assign a name to the new volume.
  * `--help`: Show this message and exit.



  List all existing volumes

  **Usage**:

  ```console
  $ inferless volume list [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  List files and directories within a volume

  **Usage**:

  ```console
  $ inferless volume ls [OPTIONS] PATH
  ```

  **Arguments**:

  * `PATH`: Specify the infer path to the directory  [required]

  **Options**:

  * `-d, --directory`: List only directories.
  * `-f, --files`: List only files.
  * `-r, --recursive`: Recursively list contents of directories.
  * `--help`: Show this message and exit.



  Specify the Inferless path to the file or directory you want to delete.

  **Usage**:

  ```console
  $ inferless volume rm [OPTIONS]
  ```

  **Options**:

  * `-p, --path TEXT`: Infer Path to the file/dir your want to delete
  * `--help`: Show this message and exit.



  Manage Inferless workspaces (can be used to switch between workspaces)

  **Usage**:

  ```console
  $ inferless workspace [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--help`: Show this message and exit.

  **Commands**:

  * `use`



  **Usage**:

  ```console
  $ inferless workspace use [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.


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


  This client can be used to call Inferless API from your python code. It supports both synchronous and asynchronous calls.

  Fetch the URL and API_KEY from the Inferless console https://console-dev.inferless.com/
  ```python
  URL = "<url>"
  API_KEY = "<api_key>"
  ```


  Input data can be provided in two formats, as shown below as inputs and data.
  ```python
  INPUTS = { "inputs" :
            [
                {
                  "name": "prompt",
                  "shape": [
                    1
                  ],
                  "datatype": "BYTES",
                  "data": [
                    "Once upon a time"
                  ]
                }
            ]
          }
  ```

  This other format is simpler and can be used if other parameters are not required. `datatype` and `shape` are automatically inferred.
  ```python
  DATA = {
      "prompt": "Once upon a time"
  }
  ```


  An example to call Inferless API synchronously
  ```python
  import inferless
  import datetime
  def main():
      t1 = datetime.datetime.now()
      data = inferless.call(url=URL, workspace_api_key=API_KEY, inputs=INPUTS)
      t2 = datetime.datetime.now()
      print(f"time taken: {t2-t1}")

  main()
  ```
  Output
  ```console
  time taken: 0:00:05.218835
  ```
  For a particular url, the synchronous call took approximately 5 seconds to complete.


  This library also supports async calls to Inferless API. The following example shows how to call Inferless API in background with a callback function.
  ```python
  import inferless
  import datetime

  def callback_func(e, response):
      
      
      with open("response.json", "w") as f:
          f.write(json.dumps(response))


  t1 = datetime.now()
  inferless.call_async(url=URL, workspace_api_key=KEY, data=data, callback=callback_func)
  t2 = datetime.now()
  print(t2 - t1)
  ```
  Output
  ```console
  time taken: 0:00:00.000141
  ```
  It can be seen that the program continues without waiting for the response. The response is written to a file by the callback function after it is received.


  If the model is configured for batch processing, `is_batch` should be set to `True`


pkgId: feab21028b37adc288807122a3bc34465202271dd5562a8d97888f95fe5fbd84
name: python-inflation-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for inflation
url: https://github.com/ecboghiu/inflation
rpm_license: GNU GPL v. 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inflation-2.0.2-1.src.rpm
location_href: Packages/python-inflation-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/500850617.svg)](https://zenodo.org/badge/latestdoi/500850617)


  Inflation is a package, written in Python, that implements inflation algorithms for causal inference. In causal inference, the main task is to determine which causal relationships can exist between different observed random variables. Inflation algorithms are a class of techniques designed to solve the causal compatibility problem, that is, test compatibility between some observed data and a given causal relationship.

  This package implements the inflation technique for classical, quantum, and post-quantum causal compatibility. By relaxing independence constraints to symmetries on larger graphs, it develops hierarchies of relaxations of the causal compatibility problem that can be solved using linear and semidefinite programming. For details, see [Wolfe et al. “The inflation technique for causal inference with latent variables.” Journal of Causal Inference 7 (2), 2017-0020 (2019)](https://www.degruyter.com/document/doi/10.1515/jci-2017-0020/html), [Wolfe et al. “Quantum inflation: A general approach to quantum causal compatibility.” Physical Review X 11 (2), 021043 (2021)](https://journals.aps.org/prx/abstract/10.1103/PhysRevX.11.021043), and references therein.

  Examples of use of this package include:

  - Causal compatibility with classical, quantum, non-signaling, and hybrid models.
  - Feasibility problems and extraction of certificates.
  - Optimization of Bell operators.
  - Optimization over classical distributions.
  - Handling of bilayer (i.e., networks) and multilayer causal structures.
  - Standard [Navascués-Pironio-Acín hierarchy](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.98.010401).
  - Scenarios with partial information.
  - Possibilistic compatibility with a causal network.
  - Estimation of do-conditionals and causal strengths.

  See the documentation for more details.



  * [Latest version](https://ecboghiu.github.io/inflation/).



  To install the package, run the following command:

  ```
  pip install inflation
  ```

  You can also install directly from GitHub with:

  ```
  pip install git+https://github.com/ecboghiu/inflation.git@main
  ```

  or download the repository on your computer and run `pip install .` in the repository folder. Install the `devel` branch for the latest features and bugfixes.

  Tests are written outside the Python module, therefore they are not installed together with the package. To test the installation, clone the repository and run, in a Unix terminal,
  ```python -m unittest -v```
  inside the repository folder.



  The following example shows that the W distribution is incompatible with the triangle scenario with quantum sources by showing that a specific semidefinite programming relaxation is infeasible:

  ```python
  from inflation import InflationProblem, InflationSDP
  import numpy as np

  P_W = np.zeros((2, 2, 2, 1, 1, 1))
  for a, b, c, x, y, z in np.ndindex(*P_W.shape):
      if a + b + c == 1:
          P_W[a, b, c, x, y, z] = 1 / 3

  triangle = InflationProblem(dag={"rho_AB": ["A", "B"],
                                   "rho_BC": ["B", "C"],
                                   "rho_AC": ["A", "C"]},
                               outcomes_per_party=(2, 2, 2),
                               settings_per_party=(1, 1, 1),
                               inflation_level_per_source=(2, 2, 2))

  sdp = InflationSDP(triangle, verbose=1)
  sdp.generate_relaxation('npa2')
  sdp.set_distribution(P_W)
  sdp.solve()

  print("Problem status:", sdp.status)
  print("Infeasibility certificate:", sdp.certificate_as_probs())
  ```

  For more information about the theory and other features, please visit the [documentation](https://ecboghiu.github.io/inflation/), and more specifically the [Tutorial](https://ecboghiu.github.io/inflation/_build/html/tutorial.html) and [Examples](https://ecboghiu.github.io/inflation/_build/html/examples.html) pages.



  Contributions are welcome and appreciated. If you want to contribute, you can read the [contribution guidelines](https://github.com/ecboghiu/inflation/blob/main/CONTRIBUTE.md). You can also read the [documentation](https://ecboghiu.github.io/inflation/) to learn more about how the package works.



  Inflation is free open-source software released under [GNU GPL v. 3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).



  If you use Inflation in your work, please cite [Inflation's paper](https://www.arxiv.org/abs/2211.04483):

  - Emanuel-Cristian Boghiu, Elie Wolfe and Alejandro Pozas-Kerstjens, "Inflation: a Python package for classical and quantum causal compatibility", Quantum **7**, 996 (2023), arXiv:2211.04483

  ```
  @article{pythoninflation,
    doi = {10.22331/q-2023-05-04-996},
    url = {https://doi.org/10.22331/q-2023-05-04-996},
    title = {Inflation: a {P}ython library for classical and quantum causal compatibility},
    author = {Boghiu, Emanuel-Cristian and Wolfe, Elie and Pozas-Kerstjens, Alejandro},
    journal = {{Quantum}},
    issn = {2521-327X},
    publisher = {{Verein zur F{\"{o}}rderung des Open Access Publizierens in den Quantenwissenschaften}},
    volume = {7},
    pages = {996},
    month = may,
    year = {2023},
    archivePrefix = {arXiv},
    eprint = {2211.04483}
  }
  ```


pkgId: 6ef2706e85bdb8bb7f51a12e16f56b0e0c6029b9ed4dda74694fe6c209ec1421
name: python-influencemapper-help
arch: noarch
version: 0.9.1
epoch: 0
release: 1
summary: Development documents and examples for influencemapper
url: https://pypi.org/project/influencemapper/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-influencemapper-0.9.1-1.src.rpm
location_href: Packages/python-influencemapper-help-0.9.1-1.noarch.rpm
checksum_type: sha256
description:
  InfluenceMapper is a python library for extracting disclosure information from scholarly articles. It uses fine-tuned OpenAI's GPT models for the extraction of entities and relationships from the text. The functions included in the library are:
  - Extract entities from the text.
  - Extract relationships between authors and entities.
  - Extract relationships between entities and the study.



  To install the library, run the following command:

  ```bash
  pip install influencemapper
  ```



  The model is trained on a dataset of scholarly articles. The dataset is available at the `data` folder. To train the model, clone the directory and run the following command:

  ```bash
  python core/src/influencemapper/cli.py fine_tune -train_data data/train.jsonl -valid_data data/valid.jsonl -model_name gpt-4o-mini -threshold 1500 study_org
  python core/src/influencemapper/cli.py fine_tune -train_data data/train.jsonl -valid_data data/valid.jsonl -model_name gpt-4o-mini -threshold 1500 author_org
  ```

  As of the writing of this README, the resulting file has to be uploaded manually to the OpenAI platform to fine-tune the model. The model will be available for use after the fine-tuning process is completed.The `threshold` parameter is used to restrict samples, allowing only those with a maximum token count that meets the training requirements to pass.



  To infer entities and relationships from a disclosure text, run the following command:

  ```bash
  python core/src/influencemapper/cli.py infer -data data/test.jsonl -model_name gpt-4o-mini -API_KEY [API_KEY] study_org
  python core/src/influencemapper/cli.py infer -data data/test.jsonl -model_name gpt-4o-mini -API_KEY [API_KEY] author_org
  ```

  To get the results, you have to visit the OpenAI platform and download the results. After dowlnoading the results, you need to combine the results back to the original dataset using the following command:

  ```bash
  python core/src/influencemapper/cli.py combine -data data/test.jsonl -result batch*.jsonl study_org
  python core/src/influencemapper/cli.py combine -data data/test.jsonl -result batch*.jsonl author_org
  ```


pkgId: 0dcb99b8a38d495e11008314744db6e3364e0929f34ac6d06f573bd3a1f758e8
name: python-influx-si-help
arch: noarch
version: 7.2.2
epoch: 0
release: 1
summary: Development documents and examples for influx-si
url: https://github.com/sgsokol/influx/
rpm_license: GNU General Public License v2 or later (GPLv2+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-influx-si-7.2.2-1.src.rpm
location_href: Packages/python-influx-si-help-7.2.2-1.noarch.rpm
checksum_type: sha256
description:
  ``influx_s`` and ``influx_i`` are programs designed for flux and metabolite concentration estimation based on labeling data using stable isotopes (essentially ¹³C but combination of multiple isotopes like ²H, ¹³C, ¹⁵N, ... is also possible). ``influx_s`` works with stationary data while the ``influx_i`` is able to simulate instationary labeling (hence the ``_i`` in the name). The both work in metabolically stationary context. The whole project is referred as ``influx_si``. Note also that the term ``influx_si`` is used in contexts where ``influx_s`` and ``influx_i`` are interchangeable.

  For installation instructions and more details, you can check the `doc online <https://influx-si.readthedocs.io/>`_.


pkgId: 13aede19bcab3414bdafe62cb1075474504001179ff78c57e40c8b81f83d6c9b
name: python-infrahub-sdk-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for infrahub-sdk
url: https://opsmill.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-infrahub-sdk-1.2.0-1.src.rpm
location_href: Packages/python-infrahub-sdk-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable -->
  ![Infrahub Logo](https://assets-global.website-files.com/657aff4a26dd8afbab24944b/657b0e0678f7fd35ce130776_Logo%20INFRAHUB.svg)
  <!-- markdownlint-restore -->



  [Infrahub](https://github.com/opsmill/infrahub) by [OpsMill](https://opsmill.com) is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.

  At its heart, Infrahub is built on 3 fundamental pillars:

  - **Powerful Schema**: that's easily extensible
  - **Unified Version Control**: for data and files
  - **Data Synchronization**: with traceability and ownership



  The Infrahub Python SDK greatly simplifies how you can interact with Infrahub programmatically.

  More information can be found in the [Infrahub Python SDK Documentation](https://docs.infrahub.app/python-sdk/).



  The Infrahub SDK can be installed using the pip package installer. It is recommended to install the SDK into a virtual environment.

  ```bash
  python3 -m venv .venv
  source .venv/bin/activate
  pip install infrahub-sdk
  ```



  Extras can be installed as part of the Python SDK and are not installed by default.



  The ctl extra provides the `infrahubctl` command, which allows you to interact with an Infrahub instance.

  ```bash
  pip install 'infrahub-sdk[ctl]'
  ```



  The tests extra provides all the components for the testing framework of Transforms, Queries and Checks.

  ```bash
  pip install 'infrahub-sdk[tests]'
  ```



  Installs infrahub-sdk together with all the extras.

  ```bash
  pip install 'infrahub-sdk[all]'
  ```


pkgId: 556616abe6a5c113beac35dc67ef66a46edbf05dcbf7f978c6b560fec5639655
name: python-infrahub-server-help
arch: noarch
version: 1.0.10
epoch: 0
release: 1
summary: Development documents and examples for infrahub-server
url: https://opsmill.com
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-infrahub-server-1.0.10-1.src.rpm
location_href: Packages/python-infrahub-server-help-1.0.10-1.noarch.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable -->
  ![Infrahub Logo](docs/static/img/infrahub-hori.svg)
  <!-- markdownlint-restore -->



  Infrahub from [OpsMill](https://opsmill.com) is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run. Infrahub offers a central hub to manage the data, templates and playbooks that powers your infrastructure by combining the version control and branch management capabilities of Git with the flexible data model and UI of a graph database.

  ![infrahub screenshot](docs/docs/media/infrahub-readme.gif)



  [Always-On Sandbox](https://demo.infrahub.app/) - Instantly login to the UI of a demo environment of Infrahub with sample data pre-loaded.

  [Getting Started Environment & Tutorial](https://opsmill.instruqt.com/pages/labs) - It spins up an instance of Infrahub on our cloud, provides a browser, terminal, code editor and walks you through the basic concepts:

  - Branching and version control
  - Flexible schema
  - Unified storage

  For longer term tests, you can deploy a local instance of Infrahub by referring to our guide: [Installing Infrahub](https://docs.infrahub.app/guides/installation)



  If you'd like to learn more about Infrahub, please refer to the following resources:

  - [Infrahub Overview](https://docs.infrahub.app/overview/)
  - [Infrahub Documentation](https://docs.infrahub.app/)
  - [FAQ](https://docs.infrahub.app/faq/)



  If you need help, support for the community version of Infrahub is provided on [![Join our Discord server](https://img.shields.io/badge/Discord-7289DA?logo=discord&logoColor=white)](https://discord.gg/opsmill) or via [filing an issue on GitHub](https://github.com/opsmill/infrahub/issues).



  [View our CONTRIBUTING](./CONTRIBUTING.md) policy to get started on contributing to Infrahub.



  [View our SECURITY](https://github.com/opsmill/infrahub?tab=security-ov-file) policy to find the latest information.


pkgId: ee7db53c394ae37bf4f5b9fd897c8041806067b91dd3d991695681128aa4e8f4
name: python-ingen-lib-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for ingen-lib
url: https://github.com/blackrock/interface-generator
rpm_license: License :: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ingen-lib-1.0.5-1.src.rpm
location_href: Packages/python-ingen-lib-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  InGen is a command line tool written on top of pandas and great_expectations to perform small scale data transformations and validations without writing code. It is designed for developers and analysts to quickly transform data by specifying their requirements in a simple YAML file.


pkgId: 82e68f235a06d6e194dcf636b11a3b4733ddbda44f08da7c222ed9874be304a8
name: python-ingenannot-help
arch: noarch
version: 0.0.14
epoch: 0
release: 1
summary: Development documents and examples for ingenannot
url: https://forgemia.inra.fr/bioger/ingenannot
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ingenannot-0.0.14-1.src.rpm
location_href: Packages/python-ingenannot-help-0.0.14-1.noarch.rpm
checksum_type: sha256
description:
  [![pipeline status](https://forgemia.inra.fr/bioger/ingenannot/badges/master/pipeline.svg)](https://forgemia.inra.fr/bioger/ingenannot/-/commits/master)
  [![coverage report](https://forgemia.inra.fr/bioger/ingenannot/badges/master/coverage.svg)](https://forgemia.inra.fr/bioger/ingenannot/-/commits/master)
  [![pylint](https://bioger.pages.mia.inra.fr/ingenannot/badges/pylint.svg)](https://bioger.pages.mia.inra.fr/ingenannot/lint/)
  [![pip](https://img.shields.io/pypi/v/ingenannot.svg)](https://pypi.org/project/ingenannot/)




  `InGenAnnot` is a set of utilities to inspect and generate
  statistics for one or several sets of gene annotations. It allows
  structure comparison and can help you to prioritize your
  efforts in manual curation. `InGenAnnot` uses among other
  things, the Sequence Ontology gene-splicing classification [SO [1]](#ref1) that aims to classify alternative transcripts in seven
  categories or the Annotation Edit Distance [AED [2]](#ref2) proposed as a metric for
  evidence support.

  As several approaches and tools exist to annotate genes in newly assembled genomes, it could be usefull to compare predictions and extract best evidence supported.

  `InGenAnnot` can handle multiple gffs from different sources. In case of several annotations, gene boundaries are often divergent
  (especially if you tried to predict UTR regions), that implies to
  clusterize genes, to propose new loci sharing a list of transcripts.
  We define these new loci as 'meta-gene' and propose several options
  to clusterize them. We tried to summarize the pro and cons of classification feature type in the following table.

  ||pros|cons|
  |:--:|--|--|
  |`--clu-type gene`|detect problem of missens predictions|overlaps of UTR merge different genes, not suitable for compact genomes|
  |`--clu-type cds`|detect problem of missens predictions|could not correct split CDS|
  |`--clu-type gene` `--clu-stranded`|resolve conflict between genes and possible non-coding RNA on the opposite strand|will not detect severe problem due to divergent prediction on opposite strand, overlaps of UTR merge different genes|
  |`--clu-type cds` `--clu-stranded`|resolve conflict between genes and possible non-coding RNA on the opposite strand|will not detect severe problem due to divergent prediction on opposite strand|

  In most cases, we recommended to use `--clu-type cds` with `--clu-stranded` to avoid gene merge. A post-process is implemented to remove overlapping CDS, keeping gene models with the best AED scores.




  Annotation Edit Distance [AED [2]](#ref2) was proposed as metric for gene annotation prediction and was implemented in [MAKER [3]](#ref3) to filter out predicted models based on their AED. Here we propose some options which modify the computation of this distance and take into account the different sources of evidence. All gene prediction tools are not able to predict UTRs, despite the RNA-Seq data and Long-read based transcripts. So to avoid penalizing gene modelis limited to CDS, we implemented an overflow penalty parameter to maximize the score of model fitting best with transcript evidence despite missing UTRs. In addition, we compute separately the AED with transcript and proteomic evidence. Some genes are only supported with a transcript evidence (new/specifcic genes), a protein evidence (gene not expressed in our data), or in both type of evidences. Then to select the best model, we classified genes according to their AED for tr and pr separately. In case where the first gene is the same in the both ranking, we select this last one. If not, we compute the two distances between models according to their ranking, and select the most divergent.

  How to use the different parameters and their impact on the computed AED ratio ? Below we simulated different cases with different parameters and shown the impact on the computed AED:

  ***AED with proteins:***

  Only the CDS part of the gene model is used. So UTRs were discarded.

  ![AED with proteins](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/AED_protein.png)

  ***AED with transcripts assembled from RNA-Seq data:***

  Only the CDS part of the gene model is used, to avoid bias in comparison between gene models with or without UTRs depending of the gene predictor. Moreover, UTRs inferred from RNA-Seq transcripts are possibly wrong due to the data (weak/high coverage) and the assembly software. So here the AED is the distance between the CDS of the gene model and the transcript evidence. If you absolutely want to exclude/penalize gene models non-fitting the splicing sites of the transcript on their CDS parts, you can use an option to add a penalty weigth `--penalty_overflow`, set to 0.0 (no penalty) by default.

  ![AED with RNA-Seq](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/AED_rnaseq.png)

  ***AED with transcripts recovered with Long-reads (Iso-Seq, Nanopore):***

  All the gene model is used (exons with CDS/UTRs). Long-reads transcript evidences are considered as very reliable evidences on their CDS and UTRs parts. So we expect a very good fit with the gene model and the evidence. For this reason, in case of divergence in splicing sites, a penalty weight parameter is applied, `--longreads_penalty_overflow`, set to 0.25 by default. This penalty is only applied if a difference of splicing sites was observed in the CDS parts of the gene model. We allow divergences in UTRs, that could be corrected later with the `utr_refine` command.

  ![AED with Longreads](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/AED_longreads.png)

  For more options and fully described use case, see the documentation [select tool](https://bioger.pages.mia.inra.fr/ingenannot/tools/Select.html) or [select use case](https://bioger.pages.mia.inra.fr/ingenannot/usecases/select_best_gene_models.html)




  [SO [1]](#ref1) classification is interesting in case of annotation comparison, higligthing discrepencies between gene models at the same locus. But it could be used to compare gene structure or isoform structure of the same annotation dataset to control the quality of the predicted isoforms.

  |Class|definition|example|
  |--|--|--|
  |N:0:0|No transcript-pairs share any exon sequence|![N:0:0](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/N_0_0.png)|
  |N:N:0|Some transcript-pairs share sequence, but none have common exon boundaries|![N:N:0](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/N_N_0.png)|
  |N:0:N|Some transcript-pairs share no sequence, others have common exon boundaries|![N:0:N](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/N_0_N.png)|
  |N:N:N|Some transcript-pairs share no sequence, others have common sequence and exon boundaries|![N:N:N](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/N_N_N.png)|
  |0:N:0|All transcript-pairs share sequence in common, but none share exon boundaries|![0:N:0](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/0_N_0.png)|
  |0:N:N|All transcript-pairs share sequence in common and some share exon boundaries|![0:N:N](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/0_N_N.png)|
  |0:0:N|All transcript-pairs share some exons in common|![0:0:N](https://forgemia.inra.fr/bioger/ingenannot/raw/master/docs/img/0_0_N.png)|

  As described above, the SO classification was originally based on exon boundaries,
  that could be highly problematic for de-novo annotations with poorly
  defined UTR parts. To avoid such problem, you can choose to perform
  the same classification based on CDS coordinates. In this case you
  will obtained less biased results (See table above for pros/cons of clustering).




  `InGenAnnot` comes with multiple tools allowing analysis of your gene prediction datasets. You will be able to compare, select and annotate your genes with different tools [(link to documentation)](https://bioger.pages.mia.inra.fr/ingenannot/index.html). Full use cases are described step by step, such as:

  * [best gene selection](https://bioger.pages.mia.inra.fr/ingenannot/usecases/select_best_gene_models.html)
  * [UTRs reannotation](https://bioger.pages.mia.inra.fr/ingenannot/usecases/add_utrs.html)
  * [annotation comparison](https://bioger.pages.mia.inra.fr/ingenannot/usecases/annotation_comparison.html)
  * [isoform annotation](https://bioger.pages.mia.inra.fr/ingenannot/usecases/add_new_isoforms.html)



  * <b id="ref1">[1]</b> Eilbeck, K., Lewis, S. E., Mungall, C. J., Yandell, M., Stein, L., Durbin, R., and Ashburner, M. 2005. Open Access The Sequence Ontology: a tool for the unification of genome annotations. Genome Biol. 6:R44
  * <b id="ref2">[2]</b> Eilbeck K, Moore B, Holt C, Yandell M. Quantitative measures for the management and comparison of annotated genomes. BMC Bioinformatics. 2009 Feb 23;10:67. doi: 10.1186/1471-2105-10-67. PMID: 19236712; PMCID: PMC2653490.
  * <b id="ref3">[3]</b> Cantarel BL, Korf I, Robb SM, et al. MAKER: an easy-to-use annotation pipeline designed for emerging model organism genomes. Genome Res. 2008;18(1):188-196. doi:10.1101/gr.6743907


pkgId: 0349804512a0e563fdd7cb9f732fc98d4ed465a40a0aec312235dd8956426b49
name: python-inincompatibility-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for inincompatibility
url: https://github.com/userElaina/inincompatibility
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inincompatibility-0.0.4-1.src.rpm
location_href: Packages/python-inincompatibility-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  A dependency-free, code-less ``socket``-based solution for resolving
  (**Python** / **conda**) environment incompatibilities.

rpm_license:
  MIT License  Copyright (c) 2024 Elaina  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: fdeef634ceffec279e2171bd37e2d11be5b0afbf6060e36f83247643ccad8bb1
name: python-init-llm-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for init-llm
url: https://github.com/bluemeat0724/init_llm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-init-llm-0.1.1-1.src.rpm
location_href: Packages/python-init-llm-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A toolkit for initializing LLMs(Langchain) and embeddings with multiple providers.
  All models are openai compatible.



  ```bash
  pip install init-llm
  ```



  ```python
  from init_llm import ChatLLM, EmbeddingLLM


  llm = ChatLLM('openai')  # or 'azure', 'anthropic', etc.
  response = llm.invoke('Hello!')


  embeddings = EmbeddingLLM('text-embedding-3-small')
  vector = embeddings.embed_query('Hello world')
  ```



  The package uses two configuration files:
  - `model_providers.toml`: Model configurations and provider settings
  - `.env`: API keys and other sensitive information


  On first use, the package will:
  1. Check for configuration files in the working directory
  2. If not found, create them automatically with default settings
  3. Load environment variables from `.env`


  You can specify custom configuration location and env file name:

  ```python
  llm = ChatLLM(
      'openai',
      config_dir='/path/to/config',
      env_file='custom.env'
  )
  ```






  [MIT](LICENSE)


pkgId: b4d7c5bebd707d4937bd05e254b9dfd0a770092d6d5d08fbd765d1c2cacba6ca
name: python-injective-py-help
arch: noarch
version: 1.8.2
epoch: 0
release: 1
summary: Development documents and examples for injective-py
url: https://injectivelabs.org/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-injective-py-1.8.2-1.src.rpm
location_href: Packages/python-injective-py-help-1.8.2-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/InjectiveLabs/sdk-python/graph/badge.svg?token=RBGK98G6F1)](https://codecov.io/gh/InjectiveLabs/sdk-python)



  **Ubuntu**
  ```bash
  sudo apt install python3.X-dev autoconf automake build-essential libffi-dev libtool pkg-config
  ```
  **Fedora**
  ```bash
  sudo dnf install python3-devel autoconf automake gcc gcc-c++ libffi-devel libtool make pkgconfig
  ```

  **macOS**

  ```bash
  brew install autoconf automake libtool bufbuild/buf/buf
  ```


  Installation
  ```bash
  pip install injective-py
  ```


  Requires Python 3.9+
  Please install `poetry` following the steps described in the [documentation](https://python-poetry.org/docs/#installation)

  [Examples](https://github.com/InjectiveLabs/sdk-python/tree/master/examples)
  ```bash
  $ poetry install



  $ poetry run python examples/exchange_client/spot_exchange_rpc/8_StreamOrders.py



  $ poetry run python examples/chain_client/1_MsgSend.py
  ```
  Upgrade `pip` to the latest version, if you see these warnings:
    ```
    WARNING: Value for scheme.platlib does not match. Please report this to <https://github.com/pypa/pip/issues/10151>
    WARNING: Additional context:   user = True   home = None   root = None   prefix = None
    ```


  1. Generate proto binding & build
    ```
    make gen
    poetry build
    ```

  2. Install pkg
    ```
    
    pip uninstall injective-py
    pip install injective-py --no-index --find-links /path/to/injective/sdk-python/dist

    
    pip uninstall injective-py
    pip install injective-py
    ```

  3. Fetch latest denom config
  ```
  poetry run python pyinjective/utils/fetch_metadata.py
  ```

  Note that the [sync client](https://github.com/InjectiveLabs/sdk-python/blob/master/pyinjective/client.py) has been deprecated as of April 18, 2022. If you are using the sync client please make sure to transition to the [async client](https://github.com/InjectiveLabs/sdk-python/blob/master/pyinjective/async_client.py), for more information read [here](https://github.com/InjectiveLabs/sdk-python/issues/101)

  4. Run all unit tests in a development environment
  ```
  poetry run pytest -v
  ```



  Copyright © 2021 - 2022 Injective Labs Inc. (https://injectivelabs.org/)

  <a href="https://drive.google.com/uc?export=view&id=1-fPQRh_D_dnun2yTtSsPW5MypVBOVYJP"><img src="https://drive.google.com/uc?export=view&id=1-fPQRh_D_dnun2yTtSsPW5MypVBOVYJP" style="width: 300px; max-width: 100%; height: auto" />

  Originally released by Injective Labs Inc. under: <br />
  Apache License <br />
  Version 2.0, January 2004 <br />
  http://www.apache.org/licenses/


pkgId: d2c5f37c908607897bdf0aff24f2bd845cba43a42b843a92d9bd5de3ac2cbf93
name: python-inkBoard-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for inkBoard
url: https://github.com/Slalamander/inkBoard
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inkBoard-0.2.6-1.src.rpm
location_href: Packages/python-inkBoard-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  ![inkBoard Logo](https://raw.githubusercontent.com/Slalamander/inkBoard/78ff69ea4cb7540b49c96f563f95c5c5224af16e/assets/blue_logo_vector.svg)

  inkBoard is a dashboarding software that uses the [PythonScreenStackManager](https://github.com/Slalamander/PythonScreenStackManager) library to make it possible to use the dashboards on any platforms that support it. There is also a designer package, which is a tool to allow designing dashboards on desktop without the limitations of whatever platform it is meant to be deployed to, as well as giving a gui to certain actions easier.

  The system is designed with extendability in mind, such that new platforms can easily be implemented, and to allow integrations to implement new features, elements, and the like. The idea is that by making it easy to write integrations and implement them, inkBoard can be used for various simple dashboards.


  `pip install inkBoard`



  WIP



  See the example folder for a small configuration file to make a dashboard. It can be run by using the command `inkBoard run configuration.yaml` from the folder. Keep in mind it won't run without having the desktop platform installed.

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


pkgId: 8206cbd78e53c27c6c45698794d182e406a43c5de3a8be5ba769136d93fe41ef
name: python-inkBoarddesigner-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for inkBoarddesigner
url: https://github.com/Slalamander/inkBoarddesigner
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inkBoarddesigner-0.1.4-1.src.rpm
location_href: Packages/python-inkBoarddesigner-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  ![inkBoard Designer Logo](https://raw.githubusercontent.com/Slalamander/inkBoarddesigner/cf56abe61008b3364d179e9ebc3719c165555c65/assets/designer_logo.svg)

  inkBoard Designer is meant to help designing inkBoard dashboards. While working on the software, it could be rather cumbersome trying to test code or dashboards on the platform itself. The designer provides an emulator, so it allows using the same yaml config as you'd use on device within it (as opposed to when you'd run it on the desktop platform). The interface is also meant to aid some steps in the design/install process.

  For example, to keep the inkBoard package itself at a minimum, the platforms and integrations will be distributed along with the designer. However, it allows for creating packages of the running configuration, which can easily be installed in an inkBoard installation using `inkBoard install`.



  `pip install inkBoarddesigner`



  The command to run the designer is included in inkBoard itself, as well as some other hooks into it. It can be started by running `inkBoard designer`. Optionally, provide a configuration file to run, but that is not required. They can also be opened from the UI.

  While I work on the documentation, the UI will likely be one of the last things to be written. For the moment, each widget has tooltips attached which should hopefully explain what they do adequately.


  Currently, two examples are included in the example folder. They are a good way to get started, and comments are included in the files to help explain what certain lines do. If you want to download just the example, you can do so via i.e. here: https://downgit.github.io/#/home

  In the `examples/custom/integrations` folder, the `dummy_integration` is also included. This is a template/explanatory integration, with comments to somewhat explain what functions are required, what stuff does, etc. It can be included by using the `dummy_integration` entry in your config. Aside from that, the custom folder also includes examples for custom functions and custom elements, which are used by the example configurations as well.

  For the Home Assistant example, you should fill out the `ha_substitutions.yaml` file. It currently all references to `secrets.yaml` (via the `!secret` anchor), but they can also be put in the file directly. To run the integration, you should run `inkBoard install integration homeassistant_client` first, which takes care of downloading the appropriate requirements (the `websockets` and `requests` packages.)

  Running the examples can be done by selecting the yaml file from the designer ui, or running `inkBoard designer configuration.yaml` from the examples folder.

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


pkgId: 56eb0c4fbfdbe72331f56b138cb6314fb38b09f781481101a6f84b2c4ae29c42
name: python-inline-snapshot-help
arch: noarch
version: 0.17.0
epoch: 0
release: 1
summary: Development documents and examples for inline-snapshot
url: https://15r10nk.github.io/inline-snapshot/latest
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inline-snapshot-0.17.0-1.src.rpm
location_href: Packages/python-inline-snapshot-help-0.17.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- -8<- [start:Header] -->

  <p align="center">
    <a href="https://15r10nk.github.io/inline-snapshot/latest/">
      <img src="docs/assets/logo.svg" width="500" alt="inline-snapshot">
    </a>
  </p>

  ![ci](https://github.com/15r10nk/inline-snapshot/actions/workflows/ci.yml/badge.svg?branch=main)
  [![Docs](https://img.shields.io/badge/docs-mkdocs-green)](https://15r10nk.github.io/inline-snapshot/latest/)
  [![pypi version](https://img.shields.io/pypi/v/inline-snapshot.svg)](https://pypi.org/project/inline-snapshot/)
  ![Python Versions](https://img.shields.io/pypi/pyversions/inline-snapshot)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/inline-snapshot)
  [![coverage](https://img.shields.io/badge/coverage-100%25-blue)](https://15r10nk.github.io/inline-snapshot/latest/contributing/#coverage)
  [![GitHub Sponsors](https://img.shields.io/github/sponsors/15r10nk)](https://github.com/sponsors/15r10nk)

  <!-- -8<- [end:Header] -->



  You can install "inline-snapshot" via [pip](https://pypi.org/project/pip/):

  ``` bash
  pip install inline-snapshot
  ```



  - **Intuitive Semantics:** `snapshot(x)` mirrors `x` for easy understanding.
  - **Versatile Comparison Support:** Equipped with
      [`x == snapshot(...)`](https://15r10nk.github.io/inline-snapshot/latest/eq_snapshot/),
      [`x <= snapshot(...)`](https://15r10nk.github.io/inline-snapshot/latest/cmp_snapshot/),
      [`x in snapshot(...)`](https://15r10nk.github.io/inline-snapshot/latest/in_snapshot/), and
      [`snapshot(...)[key]`](https://15r10nk.github.io/inline-snapshot/latest/getitem_snapshot/).
  - **Enhanced Control Flags:** Utilize various [flags](https://15r10nk.github.io/inline-snapshot/latest/pytest/) for precise control of which snapshots you want to change.
  - **Preserved Black Formatting:** Retains formatting consistency with Black formatting.
  - **External File Storage:** Store snapshots externally using `outsource(data)`.
  - **Seamless Pytest Integration:** Integrated seamlessly with pytest for effortless testing.
  - **Customizable:** code generation can be customized with [@customize_repr](https://15r10nk.github.io/inline-snapshot/latest/customize_repr)
  - **Nested Snapshot Support:** snapshots can contain [other snapshots](https://15r10nk.github.io/inline-snapshot/eq_snapshot/#inner-snapshots)
  - **Fuzzy Matching:** Incorporate [dirty-equals](https://15r10nk.github.io/inline-snapshot/eq_snapshot/#dirty-equals) for flexible comparisons within snapshots.
  - **Dynamic Snapshot Content:** snashots can contain [non-constant values](https://15r10nk.github.io/inline-snapshot/eq_snapshot/#is)
  - **Comprehensive Documentation:** Access detailed [documentation](https://15r10nk.github.io/inline-snapshot/latest) for complete guidance.




  You can use `snapshot()` instead of the value which you want to compare with.

  <!-- inline-snapshot: first_block outcome-passed=1 outcome-errors=1 -->
  ``` python
  from inline_snapshot import snapshot


  def test_something():
      assert 1548 * 18489 == snapshot()
  ```

  You can now run the tests and record the correct values.

  ```
  $ pytest --inline-snapshot=review
  ```

  <!-- inline-snapshot: create outcome-passed=1 -->
  ``` python hl_lines="5"
  from inline_snapshot import snapshot


  def test_something():
      assert 1548 * 18489 == snapshot(28620972)
  ```

  The following examples show how you can use inline-snapshot in your tests. Take a look at the
  [documentation](https://15r10nk.github.io/inline-snapshot/latest) if you want to know more.

  <!-- inline-snapshot: create fix trim first_block outcome-passed=1 -->
  ``` python
  from inline_snapshot import snapshot, outsource, external


  def test_something():
      for number in range(5):
          
          assert number <= snapshot(4)
          assert number >= snapshot(0)

      for c in "hello world":
          
          assert c in snapshot(["h", "e", "l", "o", " ", "w", "r", "d"])

      s = snapshot(
          {
              0: {"square": 0, "pow_of_two": False},
              1: {"square": 1, "pow_of_two": True},
              2: {"square": 4, "pow_of_two": True},
              3: {"square": 9, "pow_of_two": False},
              4: {"square": 16, "pow_of_two": True},
          }
      )

      for number in range(5):
          
          assert s[number]["square"] == number**2
          assert s[number]["pow_of_two"] == (
              (number & (number - 1) == 0) and number != 0
          )

      assert outsource("large string\n" * 1000) == snapshot(
          external("8bf10bdf2c30*.txt")
      )

      assert "generates\nmultiline\nstrings" == snapshot(
          """\
  generates
  multiline
  strings\
  """
      )
  ```


  `snapshot()` can also be used as parameter for functions:

  <!-- inline-snapshot: create fix trim first_block outcome-passed=1 -->
  ``` python
  from inline_snapshot import snapshot
  import subprocess as sp
  import sys


  def run_python(cmd, stdout=None, stderr=None):
      result = sp.run([sys.executable, "-c", cmd], capture_output=True)
      if stdout is not None:
          assert result.stdout.decode() == stdout
      if stderr is not None:
          assert result.stderr.decode() == stderr


  def test_cmd():
      run_python(
          "print('hello world')",
          stdout=snapshot(
              """\
  hello world
  """
          ),
          stderr=snapshot(""),
      )

      run_python(
          "1/0",
          stdout=snapshot(""),
          stderr=snapshot(
              """\
  Traceback (most recent call last):
    File "<string>", line 1, in <module>
  ZeroDivisionError: division by zero
  """
          ),
      )
  ```

  <!-- -8<- [start:Feedback] -->


  inline-snapshot provides some advanced ways to work with snapshots.

  I would like to know how these features are used to further improve this small library.
  Let me know if you've found interesting use cases for this library via [twitter](https://twitter.com/15r10nk), [fosstodon](https://fosstodon.org/deck/@15r10nk) or in the github [discussions](https://github.com/15r10nk/inline-snapshot/discussions/new?category=show-and-tell).



  I would like to thank my sponsors. Without them, I would not be able to invest so much time in my projects.



  <p align="center">
    <a href="https://pydantic.dev/logfire">
      <img src="docs/assets/sponsors/pydantic.png" alt="pydantic" width="300"/>
    </a>
  </p>



  If you encounter any problems, please [report an issue](https://github.com/15r10nk/inline-snapshot/issues) along with a detailed description.
  <!-- -8<- [end:Feedback] -->



  Distributed under the terms of the [MIT](http://opensource.org/licenses/MIT) license, "inline-snapshot" is free and open source software.


pkgId: c7912805b409245c8a24040bbde1a441b697a5b0cb37bdd5981ad0cca9622831
name: python-inmanta-sphinx-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for inmanta-sphinx
url: https://github.com/inmanta/inmanta-sphinx
rpm_license: ASL 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inmanta-sphinx-2.2.0-1.src.rpm
location_href: Packages/python-inmanta-sphinx-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This contrib extension, sphinxcontrib.inmanta provides a Sphinx
  domain for describing inmanta config and inmanta modules.


pkgId: a5e0f0a0c087c16b0b4320c3141dd1ced9ee5016c60462ae8bc85835f89c958a
name: python-innate-sdk-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for innate-sdk
url: https://pypi.org/project/innate-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-innate-sdk-0.1.0-1.src.rpm
location_href: Packages/python-innate-sdk-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The Innate SDK introduces a revolutionary paradigm where every physical robot becomes an AI agent. Build sophisticated AI applications combining state-of-the-art manipulation, navigation, and reasoning capabilities.



  For full documentation, visit [docs.innate.bot](https://docs.innate.bot)



  - 🤖 Full robotic control (navigation, manipulation, sensing)
  - 🧠 Built-in AI agent capabilities
  - 📱 Simple Python SDK and CLI tools
  - 🛠 Extensible hardware support
  - 🎓 Learning from demonstration
  - 👀 Advanced visual understanding



  Visit our [Get Started Guide](https://docs.innate.bot/get-started) to:
  - Set up your Innate-powered robot
  - Create your first AI agent
  - Learn core concepts like Primitives and Directives
  - Build sophisticated robotic applications



  Join our [developer community](https://docs.innate.bot/welcome) to share and learn from other builders.



  Here's a simple example of creating a robot that serves drinks - provided that you trained a policy to pickup glasses as described in the [training guide](https://docs.innate.bot/docs.innate.bot/basics/manipulation).

  ```python
  from innate import Agent, Primitive, Directive
  from innate import manipulation
  from typing import List


  robot = Agent()


  class GrabGlass(Primitive):
      def init(self):
          super().init()
          manipulation.init()

      def execute(self):
          manipulation.run_policy("pickup_glass")
          return "Retrieved glass.", True



  class ServingDirective(Directive):
      def init(self):
          self.primitives = [GrabGlass()]
      def get_prompt(self) -> str:
          return """You are a helpful robot called Maurice that serves drinks to people.
  Navigate between rooms to find people and serve them drinks."""



  robot.set_directive(ServingDirective())
  robot.run()
  ```



  Explore our detailed documentation at [docs.innate.bot](https://docs.innate.bot)


pkgId: c1862ffb0778d4e2b0bd606ebc8ed448f7476ba6cba3682a3704201d6ac725c0
name: python-inoopa_utils-help
arch: noarch
version: 5.0.2
epoch: 0
release: 1
summary: Development documents and examples for inoopa_utils
url: https://bitbucket.org/inoopa/inoopa_utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inoopa_utils-5.0.2-1.src.rpm
location_href: Packages/python-inoopa_utils-help-5.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This repo contains helper functions we use in all of our python projects.





  ```bash
  pip install inoopa_utils
  ```

  ```python
  from inoopa_utils.mongodb_helpers import DbManagerMongo

  db_manager = DbManagerMongo()
  ```



  After any code change, **update the package version** in [pyproject.toml](./pyproject.toml) at the key `version`.

  Then, at the root of the repo:

  ```bash

  poetry config pypi-token.pypi <Pypi API token here>


  poetry build


  poetry publish
  ```


pkgId: 72a899a6ce2e8e41948dc17d30d98bf0b5f907bec11ffbafc81ff42ac4ff94e3
name: python-inspect-ai-help
arch: noarch
version: 0.3.51
epoch: 0
release: 1
summary: Development documents and examples for inspect-ai
url: https://pypi.org/project/inspect-ai/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inspect-ai-0.3.51-1.src.rpm
location_href: Packages/python-inspect-ai-help-0.3.51-1.noarch.rpm
checksum_type: sha256
description:
  [<img width="295" src="https://inspect.ai-safety-institute.org.uk/images/aisi-logo.png" />](https://aisi.gov.uk/)

  Welcome to Inspect, a framework for large language model evaluations created by the [UK AI Safety Institute](https://aisi.gov.uk/).

  Inspect provides many built-in components, including facilities for prompt engineering, tool usage, multi-turn dialog, and model graded evaluations. Extensions to Inspect (e.g. to support new elicitation and scoring techniques) can be provided by other Python packages.

  To get started with Inspect, please see the documentation at <https://inspect.ai-safety-institute.org.uk/>.

  ***



  To work on development of Inspect, clone the repository and install with the `-e` flag and `[dev]` optional dependencies:

  ```bash
  $ git clone https://github.com/UKGovernmentBEIS/inspect_ai.git
  $ cd inspect_ai
  $ pip install -e ".[dev]"
  ```

  Optionally install pre-commit hooks via
  ```bash
  make hooks
  ```

  Run linting, formatting, and tests via
  ```bash
  make check
  make test
  ```

  If you use VS Code, you should be sure to have installed the recommended extensions (Python, Ruff, and MyPy). Note that you'll be prompted to install these when you open the project in VS Code.


pkgId: 69d16bfc86cf58a7d25f142302ec9eca2f080d1d3d7d6ecb70ff5c1553d36941
name: python-inspect-k8s-sandbox-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for inspect-k8s-sandbox
url: https://github.com/UKGovernmentBEIS/inspect_k8s_sandbox
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inspect-k8s-sandbox-0.0.2-1.src.rpm
location_href: Packages/python-inspect-k8s-sandbox-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Placeholder package only. Please install from source https://github.com/UKGovernmentBEIS/inspect_k8s_sandbox. A Kubernetes Sandbox Environment for Inspect.


pkgId: 4be62def91833e59f9ba461b0c2d07897da5cd9949d4afacec0d0359a8fb794a
name: python-inspectortodo-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for inspectortodo
url: https://github.com/wolfgangmuender/InspectorTodo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inspectortodo-1.1.0-1.src.rpm
location_href: Packages/python-inspectortodo-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  InspectorTodo is a Python tool to track the status of todos in a software project, assuming that the project uses an
  issue tracker, e.g. JIRA. In its simplest form it searches for all occurrences of the string TODO and checks whether it
  is followed by an issue reference that is conform to a given regular expression.

  Install and update using pip:

      pip install inspectortodo

  Then you can run InspectorTodo from the command line,

      inspectortodo --help

  or invoke its API from your Python code (see example below).

  If you installed it in a virtualenv (which is recommended), then you always have to activate the virtualenv first.



  The source code of InspectorTodo contains a small example project which can be parsed with the command (assuming you
  are at project root of InspectorTodo)

      inspectortodo ./tests/inspectortodo/project_for_testing "IT-\d+" --version-pattern "Release-\d+" --version 2 --versions 1,2,3

  Equivalent example in Python:

  ```python
  import inspectortodo


  inspectortodo.inspect(root_dir="./tests/inspectortodo/project_for_testing", issue_pattern="IT-\d+", version_pattern="Release-\d+", version="2", versions="1,2,3")
  ```




  InspectorTodo currently features two ways of traversing the folder tree of your project: iterating over all files on
  OS level or iterating over all files under git control. The latter is used when the folder passed to InspectorTodo as
  root dir is a git root.



  To use advanced features you can use a config file by passing a file path via the --configfile option. If the file does
  not exist a default config is created which you can adapt afterwards.

  If issues are tracked in an issue tracker like JIRA, InspectorTodo can validate whether issues that are referenced in a
  todo are in an allowed status.



  Connection settings for a JIRA server.



  A filter (currently tailored to Jira) that will only mark todos as invalid, if a field with name `filter_key` is present
  and has at least one of `filter_values` values as its entry. Can be used, _e.g._ to show only todos pointing to issues
  belonging to certain teams (_e.g._ on branches).



  A list of allowed statuses in the issue tracker, like "Backlog" or "Todo".



  If there are files in the project that should not be parsed (e.g. because they belong to another project), you can
  configure a list of ignored paths here, relative to the project root. Compare the entries from the example config for
  details.



  InspectorTodo was conceived, written and executed by [Martin Fink](https://github.com/martin1fink),
  [Kai Helbig](https://github.com/ostrya) and [Wolfgang M&uuml;nder](https://github.com/wolfgangmuender).

  Licensed under the Apache License, Version 2.0 - see [LICENSE.md](LICENSE.md) in project root directory.


pkgId: 6f4c702c8116e971cf684a49f6e33fe6b2b6fd307b0a95be930335fb6e86d8cb
name: python-instantgit-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for instantgit
url: https://pypi.org/project/instantgit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-instantgit-0.1.0-1.src.rpm
location_href: Packages/python-instantgit-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A comprehensive .gitignore template manager that makes git initialization a breeze! Stop wasting time copying and pasting .gitignore templates - InstantGit has you covered with the most comprehensive template out of the box.



  - One-command installation
  - Comprehensive .gitignore template covering:
    - Operating Systems (Windows, macOS, Linux)
    - IDEs and Editors (VSCode, PyCharm, Sublime, etc.)
    - Programming Languages (Python, JavaScript, Java, etc.)
    - Build outputs and dependencies
    - Environment and configuration files
    - And much more!
  - Simple CLI interface
  - Automatic template addition to your project



  ```bash
  pip install instantgit
  ```



  To add the comprehensive .gitignore template to your project:

  ```bash
  instantgit --add
  ```

  This will create a new .gitignore file in your current directory (or append to an existing one) with our comprehensive template.



  Contributions are welcome! Feel free to:
  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/amazing-feature`)
  3. Commit your changes (`git commit -m 'Add some amazing feature'`)
  4. Push to the branch (`git push origin feature/amazing-feature`)
  5. Open a Pull Request



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


pkgId: 399ccf2286d777e8ee5bc806055d1d4f454a5048ebd844dfb146048d4f6e6bd7
name: python-instill-sdk-help
arch: noarch
version: 0.16.0
epoch: 0
release: 1
summary: Development documents and examples for instill-sdk
url: https://pypi.org/project/instill-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-instill-sdk-0.16.0-1.src.rpm
location_href: Packages/python-instill-sdk-help-0.16.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Unix Build Status](https://img.shields.io/github/actions/workflow/status/instill-ai/python-sdk/build.yml?branch=main&label=linux)](https://github.com/instill-ai/python-sdk/actions) [![Coverage Status](https://img.shields.io/codecov/c/gh/instill-ai/python-sdk)](https://codecov.io/gh/instill-ai/python-sdk) [![PyPI License](https://img.shields.io/pypi/l/instill-sdk.svg)](https://pypi.org/project/instill-sdk) [![PyPI Version](https://img.shields.io/pypi/v/instill-sdk.svg)](https://pypi.org/project/instill-sdk) [![PyPI Downloads](https://img.shields.io/pypi/dm/instill-sdk.svg?color=orange)](https://pypistats.org/packages/instill-sdk)

  > [!IMPORTANT]<br>
  > **This SDK tool is under active development**<br>
  > For any bug found or featur request, feel free to open any issue regarding this SDK in our [instill-core](https://github.com/instill-ai/instill-core/issues) repo.



  Welcome to Instill Python SDK, where the world of AI-first application comes alive in the form of Python.

  Before you jump into creating your first application with this SDK tool, we recommend you to get familiar with the core concepts of Instill Product first. You can check out our documentation here:

  - [Instill Core](https://www.instill.tech/docs/latest/core/concepts)
  - [Instill SDK](https://www.instill.tech/docs/latest/sdk/python)



  > [!NOTE]<br>
  > For setting up development environment, please refer to [Contributing](#contributing)



  - Python 3.8 - 3.11



  > [!WARNING]<br>
  > If your host machine is on arm64 architecture(including Apple silicon machines, equipped with m1/m2 processors), there are some issues when installing `grpcio` within `conda` environment. You will have to manually build and install it like below. Read more about this issue [here](https://github.com/grpc/grpc/issues/33714).

  ```bash
  $ GRPC_PYTHON_LDFLAGS=" -framework CoreFoundation" pip install grpcio --no-binary :all:
  ```

  Install it directly into an activated virtual environment:

  ```text
  $ pip install instill-sdk
  ```

  or add it to your [Poetry](https://poetry.eustace.io/) project:

  ```text
  $ poetry add instill-sdk
  ```



  After installation, you can check if it has been installed correctly:

  ```text
  $ python
  >>> import instill
  >>> instill.__version__
  ```



  Before we can start using this SDK, you will need to properly config your target instance. We support two ways to setup the configs, which are



  create a config file under this path `${HOME}/.config/instill/sdk/python/config.yml`, and within that path you will need to fill in some basic parameters for your desired host.[^1]

  [^1]: You can obtain an `api_token` by simply going to Settings > API Tokens page from the console, no matter it is `Instill Core` or `Instill Cloud`.

  Within the config file, you can define multiple instances with the `alias` of your liking, later in the SDK you can refer to this `alias` to switch between instances.[^2]

  [^2]: SDK is default to look for instance named `default` first, and will fall back to the first instance entry in the config file if `default` not found

  ```yaml
  hosts:
    alias1:
      url:    str
      secure: bool
      token:  str
    alias2:
      url:    str
      secure: bool
      token:  str
    ...
    ...
  ```

  Example:

  ```yaml
  hosts:
    default:
      url: localhost:8080
      secure: false
      token: instill_sk***
    cloud:
      url: api.instill.tech
      secure: true
      token: instill_sk***
  ```



  If you do not like the idea of having to create a config file, you can also setup your target instance by doing the following at the very beginning of your script.

  ```python
  from instill.configuration import global_config

  global_config.set_default(
      url="api.instill.tech",
      token="instill_sk***",
      secure=True,
  )
  ```



  Before we get into this, please make sure a local instance of `Instill VDP` and `Instill Model` is running, and the config file had been populated with the correct `url` and `api_token`

  Let's get started!



  To Form a pipeine, it required a `start` operator and a `end` operator, we have helper functions to create both

  ```python
  from instill.clients import InstillClient
  ```



  Get the unified client that connect to all the available services offered by `Instill VDP` and `Instill Model`, including

  - mgmt_service
  - pipeline_service
  - model_service
  - artifact_service

  ```python
  client = InstillClient()

  user = client.mgmt_service.get_user()





  ```

  Please find more usages for this sdk at [here](https://www.instill.tech/docs/sdk/python#usage)

  **You can also find some notebook examples [here](https://github.com/instill-ai/python-sdk/tree/main/notebooks)**



  Now create a model `text-generation` in `Instill Model` for later use

  ```python
  import instill.protogen.common.task.v1alpha.task_pb2 as task_interface
  model_id = "model_text-generation"
  client.model_service.create_model(
      model_id,
      task_interface.Task.TASK_TEXT_GENERATION,
      "REGION_GCP_EUROPE_WEST4",
      "CPU",
      "model-definitions/container",
      {},
  )
  ```



  `Instill Model` is an advanced MLOps/LLMOps platform that was specifically crafted to facilitate the efficient management and orchestration of model deployments for unstructured data ETL. With `Instill Model`, you can easily create, manage, and deploy your own custom models with ease in `Instill Core` or on the cloud with `Instill Cloud`.

  Follow the instructions [here](https://www.instill.tech/docs/model/create) to build and deploy your model.



  In the section we will be creating a pipeline using this `python-sdk` to harness the power of `Instill VDP`!

  The pipeline receipt below is a sample for demo. It simply returns the input string value.

  ```python
  pipeline_id = "pipeline_demo"
  client.pipeline_service.create_pipeline(
      pipeline_id,
      "this is a pipeline for demo",
      {
          "output": {"result": {"title": "result", "value": "${variable.input}"}},
          "variable": {"input": {"instillFormat": "string", "title": "input"}},
      },
  )
  ```



  Before we trigger the pipeline, it is recommended to first validate the pipeline recipe first

  ```python

  client.pipeline_service.validate_pipeline(pipeline_id)
  ```



  Finally the pipeline is done, now let us test it by triggering it!

  ```python

  client.pipeline_service.trigger_pipeline(pipeline_id, [], [{"input": "hello world"}])
  ```

  And the output should be exactly the same as your input.



  Please refer to the [Contributing Guidelines](https://github.com/instill-ai/python-sdk/blob/main/.github/CONTRIBUTING.md) for more details.



  Please refer to the [community](https://github.com/instill-ai/community) repository.



  See the [LICENSE](./LICENSE) file for licensing information.


pkgId: 224935c0b0798fdbd6da9a5fb38cdfec3df9f3121394559ef863c492fa1f000c
name: python-instructlab-eval-help
arch: noarch
version: 0.4.2
epoch: 0
release: 1
summary: Development documents and examples for instructlab-eval
url: https://pypi.org/project/instructlab-eval/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-instructlab-eval-0.4.2-1.src.rpm
location_href: Packages/python-instructlab-eval-help-0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Lint](https://github.com/instructlab/eval/actions/workflows/lint.yml/badge.svg?branch=main)
  ![Tests](https://github.com/instructlab/eval/actions/workflows/test.yml/badge.svg?branch=main)
  ![Build](https://github.com/instructlab/eval/actions/workflows/pypi.yaml/badge.svg?branch=main)
  ![Release](https://img.shields.io/github/v/release/instructlab/eval)
  ![License](https://img.shields.io/github/license/instructlab/eval)

  ![`e2e-nvidia-l4-x1.yml` on `main`](https://github.com/instructlab/eval/actions/workflows/e2e-nvidia-l4-x1.yml/badge.svg?branch=main)
  ![`e2e-nvidia-l40s-x4.yml` on `main`](https://github.com/instructlab/eval/actions/workflows/e2e-nvidia-l40s-x4.yml/badge.svg?branch=main)

  Python Library for Evaluation



  Evaluation allows us to assess how a given model is performing against a set of specific tasks. This is done by running a set of standardized benchmark tests against
  the model. Running evaluation produces numerical scores across these various benchmarks, as well as logs excerpts/samples of the outputs the model produced during these
  benchmarks. Using a combination of these artifacts as reference, along with a manual smoke test, allows us to get the best idea about whether or not a model has learned
  and improved on something we are trying to teach it. There are 2 stages of model evaluation in the InstructLab process:



  This step occurs during multi-phase training. Each phase of training produces multiple different “checkpoints” of the model that are taken at various stages during
  the phase. At the end of each phase, we evaluate all the checkpoints in order to find the one that provides the best results. This is done as part of the
  [InstructLab Training](https://github.com/instructlab/training) library.



  Once training is complete, and we have picked the best checkpoint from the output of the final phase, we can run full-scale evaluation suite which runs MT-Bench, MMLU,
  MT-Bench Branch and MMLU Branch.



  Below are more in-depth explanations of the suite of benchmarks we are using as methods for evaluation of models.



  **tl;dr** Full model evaluation of performance on **skills**

  MT-Bench is a type of benchmarking that involves asking a model 80 multi-turn questions - i.e.

  ```text
  <Question 1> → <model’s answer 1> → <Follow-up question> → <model’s answer 2>
  ```

  A “judge” model reviews the given multi-turn question, the provided model answer, and rate the answer with a score out of 10. The scores are then averaged out
  and the final score produced is the “MT-bench score” for that model. This benchmark assumes no factual knowledge on the model’s part. The questions are static, but do not get obsolete with time.

  You can read more about MT-Bench [here](https://arxiv.org/abs/2306.05685)



  MT-Bench Branch is an adaptation of MT-Bench that is designed to test custom skills that are added to the model with the InstructLab project. These new skills
  come in the form of question/answer pairs in a Git branch of the [taxonomy](https://github.com/instructlab/taxonomy).

  MT-Bench Branch uses the user supplied seed questions to have the candidate model generate answers to, which are then judged by the judge model using the user supplied
  seed answers as a reference.



  **tl;dr** Full model evaluation of performance on **knowledge**

  MMLU is a type of benchmarking that involves a series of fact-based multiple choice questions, along with 4 options for answers. It tests if a model is able to interpret
  the questions correctly, along the answers, formulate its own answer, then selects the correct option out of the provided ones. The questions are designed as a set
  of 57 “tasks”, and each task has a given domain. The domains cover a number of topics ranging from Chemistry and Biology to US History and Math.

  The performance number is then compared against the set of known correct answers for each question to determine how many the model got right. The final MMLU score is the
  average of its scores. This benchmark does not involve any reference/critic model, and is a completely objective benchmark. This benchmark does assume factual knowledge
  on the model’s part. The questions are static, therefore MMLU cannot be used to gauge the model’s knowledge on more recent topics.

  InstructLab uses an implementation found [here](https://github.com/EleutherAI/lm-evaluation-harness) for running MMLU.

  You can read more about MMLU [here](https://arxiv.org/abs/2306.05685)



  MMLU Branch is an adaptation of MMLU that is designed to test custom knowledge that is being added to the model via a Git branch of the [taxonomy](https://github.com/instructlab/taxonomy).

  A teacher model is used to generate new multiple choice questions based on the knowledge document included in the taxonomy Git branch. A “task” is then constructed that references the newly generated answer choices. These tasks are then used to score the model’s grasp on new knowledge the same way MMLU works. Generation of these tasks are done as part of the [InstructLab SDG](https://github.com/instructlab/sdg) library.



  > **⚠️ Note:** Must use Python version 3.10 or later.



  The following tools are required:

  - [`git`](https://git-scm.com)
  - [`python`](https://www.python.org) (v3.10 or v3.11)
  - [`pip`](https://pypi.org/project/pip/) (v23.0+)
  - [`bash`](https://www.gnu.org/software/bash/) (v5+, for functional tests)



  ```shell
  scripts/infra/cloud-instance.sh ec2 launch -t g6.2xlarge
  scripts/infra/cloud-instance.sh ec2 setup-rh-devenv
  scripts/infra/cloud-instance.sh ec2 install-rh-nvidia-drivers
  scripts/infra/cloud-instance.sh ec2 ssh sudo reboot
  scripts/infra/cloud-instance.sh ec2 ssh
  ```



  ```shell
  git clone https://github.com/instructlab/taxonomy.git && pushd taxonomy && git branch rc && popd
  git clone --bare https://github.com/instructlab/eval.git && git clone eval.git/ && cd eval && git remote add syncrepo ../eval.git
  python3 -m venv venv
  source venv/bin/activate
  pip install -r requirements.txt
  pip install -r requirements-dev.txt
  pip install -e .
  pip install vllm
  ```



  Before pushing changes to GitHub, you need to run the tests as shown below. They can be run individually as shown in each sub-section
  or can be run with the one command:

  ```shell
  tox
  ```



  Unit tests are enforced by the CI system using [`pytest`](https://docs.pytest.org/). When making changes, run these tests before pushing the changes to avoid CI issues.

  Running unit tests can be done with:

  ```shell
  tox -e py3-unit
  ```

  By default, all tests found within the `tests` directory are run. However, specific unit tests can run by passing filenames, classes and/or methods to `pytest` using tox positional arguments.  The following example invokes a single test method `test_mt_bench` that is declared in the `tests/test_mt_bench.py` file:

  ```shell
  tox -e py3-unit -- tests/test_mt_bench.py::test_mt_bench
  ```



  Functional tests are enforced by the CI system. When making changes, run the tests before pushing the changes to avoid CI issues.

  Running functional tests can be done with:

  ```shell
  tox -e py3-functional
  ```



  Cli follows the python [`pep8`](https://peps.python.org/pep-0008/) coding style. The coding style is enforced by the CI system, and your PR will fail until the style has been applied correctly.

  We use [pre-commit](https://pre-commit.com/) to enforce coding style using [`black`](https://github.com/psf/black), and [`isort`](https://pycqa.github.io/isort/).

  You can invoke formatting with:

  ```shell
  tox -e ruff
  ```

  In addition, we use [`pylint`](https://www.pylint.org) to perform static code analysis of the code.

  You can invoke the linting with the following command

  ```shell
  tox -e lint
  ```



  Launch vllm serving granite-7b-lab

  ```shell
  python -m vllm.entrypoints.openai.api_server --model instructlab/granite-7b-lab --tensor-parallel-size 1
  ```

  In another shell window

  ```shell
  export INSTRUCTLAB_EVAL_FIRST_N_QUESTIONS=10 # Optional if you want to shorten run times

  python3 scripts/test_gen_answers.py
  python3 scripts/test_branch_gen_answers.py
  ```

  Example output tree

  ```shell
  eval_output/
  ├── mt_bench
  │   └── model_answer
  │       └── instructlab
  │           └── granite-7b-lab.jsonl
  └── mt_bench_branch
      ├── main
      │   ├── model_answer
      │   │   └── instructlab
      │   │       └── granite-7b-lab.jsonl
      │   ├── question.jsonl
      │   └── reference_answer
      │       └── instructlab
      │           └── granite-7b-lab.jsonl
      └── rc
          ├── model_answer
          │   └── instructlab
          │       └── granite-7b-lab.jsonl
          ├── question.jsonl
          └── reference_answer
              └── instructlab
                  └── granite-7b-lab.jsonl
  ```

  ```shell
  python3 scripts/test_judge_answers.py
  python3 scripts/test_branch_judge_answers.py
  ```

  Example output tree

  ```shell
  eval_output/
  ├── mt_bench
  │   ├── model_answer
  │   │   └── instructlab
  │   │       └── granite-7b-lab.jsonl
  │   └── model_judgment
  │       └── instructlab
  │           └── granite-7b-lab_single.jsonl
  └── mt_bench_branch
      ├── main
      │   ├── model_answer
      │   │   └── instructlab
      │   │       └── granite-7b-lab.jsonl
      │   ├── model_judgment
      │   │   └── instructlab
      │   │       └── granite-7b-lab_single.jsonl
      │   ├── question.jsonl
      │   └── reference_answer
      │       └── instructlab
      │           └── granite-7b-lab.jsonl
      └── rc
          ├── model_answer
          │   └── instructlab
          │       └── granite-7b-lab.jsonl
          ├── model_judgment
          │   └── instructlab
          │       └── granite-7b-lab_single.jsonl
          ├── question.jsonl
          └── reference_answer
              └── instructlab
                  └── granite-7b-lab.jsonl
  ```


pkgId: 172e0253752ff7eec0d8aa58ad77470ee749c4f4372cfa5c2007a2a83d223f23
name: python-instructlab-schema-help
arch: noarch
version: 0.4.2
epoch: 0
release: 1
summary: Development documents and examples for instructlab-schema
url: https://pypi.org/project/instructlab-schema/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-instructlab-schema-0.4.2-1.src.rpm
location_href: Packages/python-instructlab-schema-help-0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Lint](https://github.com/instructlab/schema/actions/workflows/lint.yml/badge.svg?branch=main)
  ![Tests](https://github.com/instructlab/schema/actions/workflows/test.yml/badge.svg?branch=main)
  ![Build](https://github.com/instructlab/schema/actions/workflows/pypi.yml/badge.svg?branch=main)

  This Python package defines the JSON schema and a parser for the InstructLab [Taxonomy](https://github.com/instructlab/taxonomy) YAML.

  Consumers of this schema can `pip install instructlab-schema`, and use the `instructlab.schema.taxonomy.TaxonomyParser` class to parse and validate `qna.yaml` taxonomy files.
  Schema files can be directly accessed using the `instructlab.schema.schema_base()` method to get access the base of the schema resources.


pkgId: 79c94afd735ca7fbbaf74743b4fb53922452c26e59fa19b77ac245b6c876b993
name: python-int-encoder-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for int-encoder
url: https://pypi.org/project/int-encoder/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-int-encoder-1.0.0-1.src.rpm
location_href: Packages/python-int-encoder-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  `int_encoder` is a Python library for encoding and decoding integers using modular arithmetic.



  To install the library from PyPI, simply run:

  ```bash
  pip3 install int-encoder
  ```



  The library uses two configuration constants, defined in `config.py`:

  - `INT_ENCODE_KEY`: The key used for encoding and decoding integers.
  - `INT_ENCODED_MAX`: The maximum value for the encoded integer.

  These values can be modified in `config.py` to suit your needs.




  ```python
  import int_encoder


  int_encoder.config.INT_ENCODE_KEY = 987654321  # New key for encoding
  int_encoder.config.INT_ENCODED_MAX = 2 ** 16   # New maximum value for encoded integers


  int_to_encode = 123456
  encoded_value = int_encoder.encode(int_to_encode)
  print(f"Encoded value: {encoded_value}")

  decoded_value = int_encoder.decode(encoded_value)
  print(f"Decoded value: {decoded_value}")
  ```


pkgId: 4a95693a91580479af061431d8c4ebc8b488431afcb8ae6cc247bb5975104a44
name: python-integra-bridge-help
arch: noarch
version: 0.0.13
epoch: 0
release: 1
summary: Development documents and examples for integra-bridge
url: https://pypi.org/project/integra-bridge/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-integra-bridge-0.0.13-1.src.rpm
location_href: Packages/python-integra-bridge-help-0.0.13-1.noarch.rpm
checksum_type: sha256
description:
  ````bash
  pip install integra-bridge
  ````
  Allows you to move the business logic of complex services outside of Integra.
  Under the hood, interaction with Integra is carried out using the HTTP protocol based on REST FastAPI.

  `Bridge` - base class responsible for assembling services.

  Params:
      - `title` string - input title of service;
      - `address` string | None - address of service location;
      - `description` string | None - address of service location;
      - `manual_path` string | Pathlike - Path to manual file;

  To map external URLs to local ones when writing handlers,
  use the variable **URL_PATH_MAPPER**, which must be set via a variable in the environment of your service in the form of a serializable JSON string.



  ````python
  from integra_bridge import Bridge
  from integra_bridge.adapters import ProcessorAdapter
  from integra_bridge.dto import SkeletonProcessor, ProcessorView


  class SimpleProcessor(ProcessorAdapter):
      async def execute(self, body: dict, params: dict) -> dict:
          body['hello'] = 'world'
          return body

      async def get_view(self) -> ProcessorView:
          skeleton = SkeletonProcessor()
          return ProcessorView(
              title="Simple processor",
              description="",
              skeleton=skeleton
          )

  bridge = Bridge(
      title='My service',
      address='Moscow',
      description='For demo',
      manual_path=Path(__file__).parent / 'manual.pdf'
  )

  bridge.register_handlers([SimpleProcessor])

  application = bridge.build()

  if __name__ == '__main__':
      uvicorn.run(app="__main__:application", host='localhost', port=8000)
  ````



  ````python3
  server_name = Parameter(
      name='server_name',
      label='Server name',
      description='',
      default_value='google.com',
      is_required=True,
      is_add_value=True,
      bottom_text='bottom_text'
  )

  skeleton = SkeletonProcessor(parameters=[server_name,])
  ````



  ````python3
  class SimpleProcessor(ProcessorAdapter):
      async def execute(self, body: dict, params: dict) -> dict:
          body['hello'] = 'world'
          return body

      async def validate(self, processor: Processor) -> ValidationResponse:
          result = True
          params_description = {}
          if len(processor.params.get('field_to_check')) > 10:
              result = False
              params_description['field_to_check'] = ['Превышена максимальная длинна в 10 символов']
          return ValidationResponse(
              result=result,
              params_description=params_description,
          )
  ````



  ````python

  class ConsumerManager:
      def __init__(self):
          self.consumers = {}

      async def create_consumer(self, queue_name: str, connection_params: dict):
          connection = await aio_pika.connect_robust("amqp://guest:guest@localhost/")
          channel = await connection.channel()
          exchange = await channel.declare_exchange(name='integra', type="fanout")
          queue = await channel.declare_queue(queue_name, auto_delete=False, durable=True)
          await queue.bind(exchange=exchange, routing_key=queue_name)
          callback = partial(self.on_message, queue_name=queue_name, connection_params=connection_params)
          consumer_tag = await queue.consume(callback, no_ack=False)
          self.consumers[queue_name] = {"connection": connection, "channel": channel, "consumer_tag": consumer_tag}
          return consumer_tag

      async def delete_consumer(self, queue_name: str, connection_params: dict):
          if queue_name in self.consumers:
              consumer = self.consumers[queue_name]
              await consumer["channel"].close()
              await consumer["connection"].close()
              del self.consumers[queue_name]

      async def on_message(self, message: AbstractIncomingMessage, queue_name, connection_params: dict) -> None:
          data = json.loads(message.body.decode('utf-8'))
          send_status = await ConnectorAdapter.push_to_integra(
              input_body=data,
              connect_to_block_id=queue_name
          )
          if send_status in (200, 201):
              await message.ack()


  server_name = Parameter(
      name='server_name',
      label='Server name',
      is_required=True,
      is_add_value=True,
  )
  url = Parameter(
      name='url',
      label='url',
      is_required=True,
      is_add_value=True,
  )

  class SimpleInputConnector(ConnectorAdapter):
      async def get_view(self) -> ConnectorView:
          skeleton_connector = SkeletonConnector(type_connect='input', parameters=[server_name, url, ])
          return ConnectorView(
              title="Simple input connector",
              input_description="description",
              skeleton_input_connect=skeleton_connector
          )

      async def on_after_deploy(self, connection_id: str, connector_params: dict):
          await consumer_manager.create_consumer(connection_id, connector_params)

      async def on_after_destroy(self, connection_id: str, connector_params: dict):
          await consumer_manager.delete_consumer(connection_id, connector_params)
  ````


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

  The Python API library allows access to [Integry REST API](https://docs.integry.ai/apis-and-sdks/api-reference) from Python programs.



  ```bash

  pip install integry
  ```



  ```python
  import os
  from integry import Integry

  user_id = "your user's ID"


  integry = Integry(
      app_secret=os.environ.get("INTEGRY_APP_KEY"),
      app_key=os.environ.get("INTEGRY_APP_SECRET"),
  )


  predictions = await integry.functions.predict(
      prompt="say hello to my team on Slack", user_id=user_id, predict_arguments=True
  )

  if predictions:
      function = predictions[0]
      
      await function(user_id, function.arguments)
  ```


  List methods are paginated and allow you to iterate over data without handling pagination manually.
  ```python
  from integry import Integry

  user_id = "your user's ID"

  integry = Integry(
      app_secret=os.environ.get("INTEGRY_APP_KEY"),
      app_key=os.environ.get("INTEGRY_APP_SECRET"),
  )

  async for function in integry.functions.list(user_id):
      
      print(function.name)
  ```

  If you want to control pagination, you can fetch individual pages by using the `cursor` returned by the previous page.
  ```python
  from integry import Integry

  user_id = "your user's ID"

  integry = Integry(
      app_secret=os.environ.get("INTEGRY_APP_KEY"),
      app_key=os.environ.get("INTEGRY_APP_SECRET"),
  )

  first_page = await integry.apps.list(user_id)

  second_page = await integry.apps.list(user_id, cursor=first_page.cursor)
  ```


pkgId: 6ba80cc8694da2adb779acdfc845e9bf50a0db0d0bcf15a2a0eeebdb5b37a536
name: python-intel-npu-top-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for intel-npu-top
url: https://github.com/DMontgomery40/intel-npu-top
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-intel-npu-top-0.1.0-1.src.rpm
location_href: Packages/python-intel-npu-top-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A monitoring tool for Intel Meteor Lake NPU usage in real-time via sysfs on Linux, featuring ASCII-based visualization.

  **Status:** Pre-alpha prototype — expect incomplete features, rough edges, and limited functionality.



  This is an experimental prototype and is **NOT PRODUCTION READY**. Use at your own risk and expect:
  - Incomplete features
  - Potential bugs
  - Limited error handling
  - Possible system-specific issues



  - Linux system with Intel Meteor Lake NPU
  - Python 3.6 or higher
  - Access to NPU sysfs entries (usually requires root privileges)



  * Real-time NPU usage monitoring with ASCII bar chart visualization
  * Historical view of the last 40 samples
  * Automatic screen refresh
  * Docker container support





  Just copy the STANDALONE.py script to your system and run it with Python 3.





  git clone https://github.com/DMontgomery40/intel-npu-top
  cd intel-npu-top
  python3 -m pip install .



  docker-compose up -d



  sudo intel-npu-top

  Note: Root privileges are required to access the NPU sysfs entries.



  This project was inspired by and based on code from [ZoLArk173/nputop](https://github.com/ZoLArk173/nputop). Thanks for the inspiration and groundwork!



  MIT License - See LICENSE file for details.


pkgId: 020936c6e0982da6922a655a4930993080e776b6e3a75ef9f3d1bbfb693e4231
name: python-intelligent-plant-help
arch: noarch
version: 1.8.0
epoch: 0
release: 1
summary: Development documents and examples for intelligent-plant
url: https://github.com/intelligentplant/py-app-store-api
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-intelligent-plant-1.8.0-1.src.rpm
location_href: Packages/python-intelligent-plant-help-1.8.0-1.noarch.rpm
checksum_type: sha256
description:
  A python implmentation of the Intelligent Plant industrial appstore API client

  See the example folder for example on how to use the library for authorization code and implicit OAuth grant flows.





  `pip install intelligent-plant`



  Using pip:

  `pip install git+https://github.com/intelligentplant/py-app-store-api`

  Alternatively clone the Git repo:

  `git clone https://github.com/intelligentplant/py-app-store-api.git`



  The 'example' folder contains a series of examples which demonstrate the available authentication methods and queries that you can make using this library.

  To install dependencies used by the example scripts run

  `pip install -r example-requirements.txt`



  In order to query the industrial app store you must register as a developer and create an app registration. Full instructions can be found here: [https://wiki.intelligentplant.com/doku.php?id=dev:app_store_developers](https://wiki.intelligentplant.com/doku.php?id=dev:app_store_developers)

  Once you have created and app registration you will need to copy and rename `config-example.json` to `config.json` and populate the `id` and `secret` fields with you app ID and app secret.

  To run the authorization code grant flow example run:

  `python example/authorization_code_grant_flow.py`

  To run the authorization code grant flow example with the PKCE extension run:

  This is the recommended flow for web and native applications.

  `python example/authorization_code_grant_flow_pkce.py`

  To run the device code flow example run:

  *The device code flow is disabled by default, you must enable it on the app registration*

  This is the recommended flow for CLI apps and tools.

  `python example/device_code_flow.py`

  To run the implicit grant flow example run:

  *The implicit grant flow is deprecated and is disabled by default*

  `python example/implicit_grant_flow.py`



  The `intelligent_plant.session_manager` module provides functionality to save your session to your operating systems keyvault using the library [keyring](https://pypi.org/project/keyring/). To use this module you must have keyring installed:

  `pip install keyring`

  With keyring installed you can now use it as shown in the stored session examples.

  Running the stored session example will use the device code flow to authenticate the first time (or if your session expires) but will otherwise use the stored credentials:

  `python example/stored_session/stored_session.py`

  You can see the stored session values using:

  `python example/stored_session/get_stored_session.py`

  And you can clear the stored session using:

  `python example/stored_session/clear_session.py`

  You can also see this being used in a Jupyter notebook in `example/stored_session/jupyter.ipynb`.



  To run the NTLM (windows authentication) example you will need to have a data core node available on the local network.
  If you have an App Store Connect (https://appstore.intelligentplant.com/Home/DataSources) installed locally you can run the example without modification. If you are trying to authenticate with a data core node you will need to change the `base_url` variable defined in the script to match the URL of the Data Core admin UI.

  Run the example using:

  `python example/ntlm_example.py`



  You can find examples of how to use the library to make queries in our Jupyer Hub demo notebooks (these notebooks expect a valid Industrial App Store access token to be present in the `ACCESS_TOKEN` environment variable).

  [https://github.com/intelligentplant/jupyter-hub-demo/tree/master/Python](https://github.com/intelligentplant/jupyter-hub-demo/tree/master/Python)

  To use this library as part of a Jupyter Notebook join the Jupyter Hub:

  https://appstore.intelligentplant.com/Home/AppProfile?appId=40d7a49722f84be4986318bb5cc98cf3


pkgId: 2ad0308e824ba1e2bc1997348ce1be1dec49cc41396813124ace79237f30c9d1
name: python-internal-rdbms-help
arch: noarch
version: 0.1.16
epoch: 0
release: 1
summary: Development documents and examples for internal-rdbms
url: https://pypi.org/project/internal-rdbms/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-internal-rdbms-0.1.16-1.src.rpm
location_href: Packages/python-internal-rdbms-help-0.1.16-1.noarch.rpm
checksum_type: sha256
description:
  To make it easy for you to get started with GitLab, here's a list of recommended next steps.

  Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!



  - [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
  - [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:

  ```
  cd existing_repo
  git remote add origin https://gitlab.com/cruisys2/core/internal-rdbms.git
  git branch -M main
  git push -uf origin main
  ```



  - [ ] [Set up project integrations](https://gitlab.com/cruisys2/core/internal-rdbms/-/settings/integrations)



  - [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
  - [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
  - [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
  - [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
  - [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)



  Use the built-in continuous integration in GitLab.

  - [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
  - [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
  - [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
  - [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
  - [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)

  ***



  When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.



  Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.


  Choose a self-explaining name for your project.


  Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.


  On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.


  Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.


  Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.


  Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.


  Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.


  If you have ideas for releases in the future, it is a good idea to list them in the README.


  State if you are open to contributions and what your requirements are for accepting them.

  For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.

  You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.


  Show your appreciation to those who have contributed to the project.


  For open source projects, say how it is licensed.


  If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.


pkgId: 820786befef4d03c83d9a5cf721efc6a8481c62b7eb8a04a7f9bb5e907cd7fe5
name: python-interrail-vision-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for interrail-vision
url: https://github.com/Shakh7/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-interrail-vision-0.1.3-1.src.rpm
location_href: Packages/python-interrail-vision-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for reading images and PDFs with AI-powered vision.



  ```bash
  pip install interrail_vision


pkgId: d480948d92f027306cd9d4bcb1673c15b622d22fb535d93328c3a09a60f6f55d
name: python-interrogatio-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for interrogatio
url: https://github.com/ffaraone/interrogatio
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-interrogatio-2.4.0-1.src.rpm
location_href: Packages/python-interrogatio-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Python versions](https://img.shields.io/pypi/pyversions/interrogatio.svg) [![PyPi Status](https://img.shields.io/pypi/v/interrogatio.svg)](https://pypi.org/project/interrogatio/) ![Read the Docs](https://img.shields.io/readthedocs/interrogatio) ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ffaraone/interrogatio/build.yml)
   [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=ffaraone_interrogatio&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=ffaraone_interrogatio) [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=ffaraone_interrogatio&metric=coverage)](https://sonarcloud.io/summary/new_code?id=ffaraone_interrogatio)

  A python library to prompt users for inputs in a terminal application.




  `interrogatio` is a python 3.8+ library based on the [python-prompt-toolkit](https://github.com/prompt-toolkit/python-prompt-toolkit) and inspired by [PyInquirer](https://github.com/CITGuru/PyInquirer/) that help CLI developers to ask users for inputs.

  Questions can be rendered onto the terminal prompt or as curses-like dialogs.




  [`interrogatio` documentation](https://interrogatio.readthedocs.io/en/latest/) is hosted on _Read the Docs_.








  `interrogatio` depends on the python-prompt-toolkit library and its dependencies.







  ```
  $ pip install interrogatio
  ```




  If you want to use the shell command with yml files you can install the yml dependency:

  ```
  $ pip install interrogatio[yml]
  ```




  `interrogatio` needs a list of questions to prompt the user for answers.

  Each question is a python dictionary with at least the following keys:

  * **name**: it has to be unique within the list of questions. It represents the variable name;
  * **type**: the type of question;
  * **message**: the text of the prompt.

  Optionally you should specify:

  * a **default**: a default value;
  * a **validators**: a list of children of Validator class
  * a **values**: a list of tuples (value, label) to provide a list of choices
      for the ``selectone`` or ``selectmany`` question types.


  `interrogatio` can run into two modes: dialog and prompt.



  ![Dialog mode showcase](docs/showcase/dialogus.gif)

  ```
  from interrogatio import dialogus

  questions = [
      {
          'name': 'name',
          'type': 'input',
          'message': "What's your name ?",
          'description': 'Please enter your full name. This field is required.',
          'validators': [{'name': 'required'}],
      },
      {
          'name': 'birth_date',
          'type': 'date',
          'message': "What's your birth date ?",
          'description': 'Enter your birth date.',
      },
      {
          'name': 'nationality',
          'type': 'selectone',
          'message': "What's your nationality ?",
          'description': 'Please choose one from the list.',
          'validators': [{'name': 'required'}],
          'values': [
              ('IT', 'Italian'),
              ('ES', 'Spanish'),
              ('US', 'American'),
              ('UK', 'English'),
          ],
      },
      {
          'name': 'languages',
          'type': 'selectmany',
          'message': "What are your favorite programming languages ?",
          'description': 'Please choose your favorites from the list.',
          'values': [
              ('py', 'Python'),
              ('rb', 'Ruby'),
              ('js', 'Javascript'),
              ('go', 'Golang'),
              ('rs', 'Rust'),
              ('c', 'C'),
              ('cpp', 'C++'),
              ('java', 'Java'),
          ],
      },
  ]

  intro = """<blue>Welcome to <b><i>interrogatio 2.0</i></b>!

  This is the second major release of interrogatio with nice improvements.</blue>

  <b>What's new</b>
  <b>----------</b>

  * Curses-like dialog experience had been completely rewritten.
  * New questions handlers for dates, date ranges and masked inputs.
  * Validators are now based on the <u>validators</u> library.
  """


  answers = dialogus(questions, 'interrogatio showcase', intro=intro, summary=True)
  ```



  ![Prompt mode showcase](docs/showcase/interrogatio.gif)

  ```
  from interrogatio import interrogatio

  questions = [
      {
          'name': 'name',
          'type': 'input',
          'message': "What's your name ?",
          'description': 'Please enter your full name. This field is required.',
          'validators': [{'name': 'required'}],
      },
      {
          'name': 'birth_date',
          'type': 'date',
          'message': "What's your birth date ?",
          'description': 'Enter your birth date.',
      },
      {
          'name': 'nationality',
          'type': 'selectone',
          'message': "What's your nationality ?",
          'description': 'Please choose one from the list.',
          'validators': [{'name': 'required'}],
          'values': [
              ('IT', 'Italian'),
              ('ES', 'Spanish'),
              ('US', 'American'),
              ('UK', 'English'),
          ],
      },
      {
          'name': 'languages',
          'type': 'selectmany',
          'message': "What are your favorite programming languages ?",
          'description': 'Please choose your favorites from the list.',
          'values': [
              ('py', 'Python'),
              ('rb', 'Ruby'),
              ('js', 'Javascript'),
              ('go', 'Golang'),
              ('rs', 'Rust'),
              ('c', 'C'),
              ('cpp', 'C++'),
              ('java', 'Java'),
          ],
      },
  ]


  answers = interrogatio(questions)
  ```



  If you want to contribute to the project, you can submit bugs, feature requests or fork the github repository and submit your pull request.




  `interrogatio` is released under the [BSD 3-Clause "New" or "Revised" License](https://opensource.org/licenses/BSD-3-Clause>).


pkgId: 85ff1e6bf2adc92a933fa9838c1152d35327b06b7008ad0c6525b4c1c3af2623
name: python-interview-eval-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for interview-eval
url: https://pypi.org/project/interview-eval/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-interview-eval-0.1.2-1.src.rpm
location_href: Packages/python-interview-eval-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  An automated interview evaluation system that simulates technical interviews using AI agents. The system consists of an AI interviewer and interviewee, conducting structured conversations based on predefined rubrics and strategies.



  ```bash
  pip install interview-eval
  ```



  - AI-powered interviewer and interviewee agents
  - Configurable interview parameters and evaluation rubrics
  - Real-time conversation display with rich formatting
  - Detailed scoring and feedback system
  - Progress tracking and maximum question limits
  - Customizable OpenAI client configuration



  ```python
  from interview_eval import InterviewRunner, Interviewer, Interviewee
  from interview_eval.utils import console, load_config, setup_logging
  import logging
  import yaml


  config = load_config("config.yaml")


  logger = setup_logging("interview.log", verbose=True)


  interviewer = Interviewer(config)
  interviewee = Interviewee(config)


  runner = InterviewRunner(interviewer, interviewee, config, logger, console)
  results = runner.run()
  ```



  Create a YAML configuration file with the following structure:

  ```yaml
  interviewer:
    name: "Technical Interviewer"
    instructions: "Your interview guidelines..."
    rubric: "Evaluation criteria..."
    strategy:
      key_areas: [...]
      scoring_criteria: [...]
    client:  # Optional OpenAI client configuration
      api_key: "your-api-key"

  interviewee:
    name: "Candidate"
    instructions: "Interviewee behavior guidelines..."

  session:
    initial_message: "Welcome to the interview..."
    max_questions: 10
    max_retries: 2
    initial_context: {}
  ```





  ***Note: This feature is still under development and will be available in future releases.***

  `interview-eval` lets you define custom interview flows as directed graphs, where each node represents an interview state (like asking questions or evaluating responses) and edges represent possible transitions between states. With this feature, you can create complex interview scenarios with branching logic, follow-up questions, and adaptive feedback based on the interviewee's responses.

  Below is an example flow of interview, where the Interviewer evaluates the Interviewee's response and chooses to do one of the following actions:
  - Ask a follow-up question (Deep Dive)
  - Move on to the next topic (Next Topic)
  - Ask for clarification (Challenge)
  - End the interview (Conclude)

  ![Interview Flow](assets/interview-flow.png)




  For users conducting benchmark-based interview (like GSM8K, MMLU, etc.), `interview-eval` provides functions to prevent test set contamination through three transformation strategies:

  ```python
  from interview_eval import decontaminate_question


  question = decontaminate_question(
      question="What is 15% of 200?",
      reference_answer="30",
      method="modifying"  # or "unclarifying" or "paraphrasing"
  )
  ```

  1. **Unclarifying** (`method="unclarifying"`)
     - Removes key information while maintaining grammar
     - Forces interviewee to ask clarifying questions
     - Evaluates information-gathering skills

  2. **Paraphrasing** (`method="paraphrasing"`)
     - Preserves exact meaning with different wording
     - Changes sentence structure
     - Maintains problem complexity

  3. **Modifying** (`method="modifying"`)
     - Creates new but related questions
     - Keeps similar domain and difficulty
     - Tests same knowledge areas


  Batch processing of questions is also supported:

  ```python
  from interview_eval import batch_decontaminate

  questions = [
      {"question": "Q1...", "reference_answer": "A1..."},
      {"question": "Q2...", "reference_answer": "A2..."}
  ]

  decontaminated = batch_decontaminate(
      questions,
      method="modifying",
      model="gpt-4"
  )
  ```




  - Modifying problem ✔️
    - Python function to modify the problem `modify_problem`
    - Supported strategies: `Unclarifying`, `Paraphrasing`, and `Modifying` (given seed question, create a new question)

  - Feedback & Editing Loop
    - Proceed to next question if the response is graded as `Good`
    - 이전에 했던 feedback 주지 말기

  - Followup Questions
    - Problem, Response, Feedback, Followup Question, Response, Feedback, Followup Question, ...

  - Report Card
    - Per seed questions pool
    - Include information about the student's performance on each question that received different scores


pkgId: 9e702eadede8f89129cd5e3a873b9684645382141e3589f5ecd65408e886d3f6
name: python-intezer-sdk-help
arch: noarch
version: 1.21.7
epoch: 0
release: 1
summary: Development documents and examples for intezer-sdk
url: https://github.com/intezer/analyze-python-sdk
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-intezer-sdk-1.21.7-1.src.rpm
location_href: Packages/python-intezer-sdk-help-1.21.7-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/intezer_sdk)
  ![Build](https://github.com/intezer/analyze-python-sdk/actions/workflows/test.yml/badge.svg)


  The SDK wraps Intezer Analyze API 2.0 ([View full API documentation](https://analyze.intezer.com/api-docs.html))

  Currently, the following options are available in the SDK:

  - Analyze by file
  - Analyze by SHA256
  - Analyze Url
  - Index by file
  - Index by SHA256
  - Get Latest Analysis
  - Account and file related samples
  - Code reuse and Metadata
  - IOCs, Dynamic TTPs and Capabilities
  - Strings related samples
  - Search a family
  - Ingest an alert from any source
  - Ingest a raw email alert (.msg or .eml file)



  ```bash
  pip install intezer-sdk
  ```



  Before using the SDK functionality we should set the api key:
  ```python
      api.set_global_api('<api_key>')
  ```


  ```python
  analysis = FileAnalysis(file_path=<file_path>,
                      dynamic_unpacking=<force_dynamic_unpacking>, # optional
                      static_unpacking=<force_static_unpacking>)   # optional
  analysis.send(wait=True)
  result = analysis.result()
  ```

  ```python
  analysis = FileAnalysis(file_hash=<file_sha256>)
  analysis.send(wait=True)
  result = analysis.result()
  ```


  ```python
  {
    'analysis_id': '00000000-0000-0000-0000-000000000000',
    'analysis_time': 'Sun, 04 Aug 2019 09:38:16 GMT',
    'analysis_url': 'https://analyze.intezer.com/#/analyses/00000000-0000-0000-0000-000000000000',
    'family_name': 'Ramnit',
    'is_private': True,
    'sha256': '4e553bce90f0b39cd71ba633da5990259e185979c2859ec2e04dd8efcdafe356',
    'sub_verdict': 'malicious',
    'verdict': 'malicious'
  }
  ```

  ```python
  analysis = UrlAnalysis(url=<url>)
  analysis.send(wait=True)
  result = analysis.result()
  ```

  ```python
  {
      'analysis_id': '70d09f68-c7a3-43a3-a8de-07ec31fbf4ed',
      'domain_info': {
          'creation_date': '1997-08-13 04:00:00.000000',
          'domain_name': 'foo.com',
          'registrar': 'TUCOWS, INC.'
      },
      'indicators': [
      {
          'classification': 'informative',
          'text': 'URL is accessible'
      },
      {
          'classification': 'informative',
          'text': 'Assigned IPv4 domain'
      },
      {
          'classification': 'informative',
          'text': 'Vaild IPv4 domain'
      }
      ],
      'ip': '34.206.39.153',
      'redirect_chain': [
      {
          'response_status': 301,
          'url': 'https://foo.com/'
      },
      {
          'response_status': 200,
          'url': 'http://www.foo.com/'
      }
      ],
      'scanned_url': 'http://www.foo.com/',
      'submitted_url': 'foo.com',
      'downloaded_file': {
          'analysis_id': '8db9a401-a142-41be-9a31-8e5f3642db62',
          'analysis_summary': {
             'verdict_description': 'This file contains code from malicious software, therefore it's very likely that it's malicious.',
             'verdict_name': 'malicious',
             'verdict_title': 'Malicious',
             'verdict_type': 'malicious'
          },
          'sha256': '4293c1d8574dc87c58360d6bac3daa182f64f7785c9d41da5e0741d2b1817fc7'
       },
      'summary': {
          'description': 'No suspicious activity was detected for this URL',
          'title': 'No Threats',
          'verdict_name': 'no_threats',
          'verdict_type': 'no_threats'
      }
  }
  ```

  ```python
  from intezer_sdk import consts

  index = Index(file_path=<file_path>,
                index_as=consts.IndexType.MALICIOUS,
                family_name=<family_name>)
  index.send(wait=True)
  index_id = index.index_id
  ```

  ```python
  from intezer_sdk import consts

  index = Index(sha256=<file_sha256>,
                index_as=consts.IndexType.TRUSTED)
  index.send(wait=True)
  index_id = index.index_id
  ```


  ```python
  analysis = FileAnalysis.from_latest_hash_analysis(file_hash: <file_sha256>)
  result = analysis.result()
  ```



  ```python
  root_analysis = analysis.get_root_analysis()
  ```

  ```python
  sub_analyses = analysis.get_sub_analyses()
  ```

  ```python
  root_analysis_code_reuse = root_analysis.code_reuse
  root_analysis_metadata = root_analysis.metadata

  for sub_analysis in sub_analyses:
      sub_analyses_code_reuse = sub_analysis.code_reuse
      sub_analyses_metadata = sub_analysis.metadata
  ```

  ```python
  root_analysis_code_reuse = root_analysis.code_reuse

  for family in root_analysis_code_reuse['families']:
      operation = root_analysis.find_related_files(family['family_id'], wait=True)
      related_files = operation.get_result()
  ```

  ```python
  operation = root_analysis.get_account_related_samples()
  related_samples = operation.get_result()
  ```

  ```python
  operation = root_analysis.generate_vaccine()
  vaccine = operation.get_result()
  ```


  ```python
  operation = root_analysis.get_string_related_samples('string_to_relate_to', wait=True)
  string_related_samples = operation.get_result()
  ```


  ```python
  analysis = FileAnalysis(file_hash=<file_sha256>)
  analysis.send(wait=True, wait_timeout=datetime.timedelta(minutes=1))
  ```


   - File

  ```python
  history_results = query_file_analyses_history(
      start_date = <datetime>,
      end_date= <datetime>,
      api = <IntezerApi>
      aggregated_view: <bool>,
      sources=<source>
      verdicts=<verdicts>,
      file_hash=<file_hash>,
      family_names=<family_names>,
      file_name=<file_name>
  )
  for analyse in history_results:
      print(analyse)
  ```
   - URL
  ```python
  history_results = query_url_analyses_history(
      start_date = <datetime>,
      end_date=<datetime>,
      aggregated_view=<bool>,
      sources=<sources>,
      verdicts=<verdicts>,
  )
  for analyse in history_results:
      print(analyse)
  ```
   - End Point
  ```python
  history_results = query_endpoint_analyses_history(
      start_date = <datetime>,
      end_date=<datetime>,
      aggregated_view=<bool>,
      sources=<sources>,
      verdicts=<verdicts>,
      sub_verdicts=<verdicts>,
      did_download_file=<bool>,
      submitted_url=<submitted_url>
  )
  for analyse in history_results:
      print(analyse)
  ```



  ```python
  alert = Alert.from_id(alert_id=alert_id,
                        fetch_scans=False,
                        wait=False)
  ```



  ```python
  history_results = query_file_analyses_history(
      api = <IntezerApi>,
      **filters
  )
  for analyse in history_results:
      print(analyse)
  ```


  You can find more code examples under [analyze-python-sdk/examples/](https://github.com/intezer/analyze-python-sdk/tree/master/examples) directory


pkgId: ae6dcacabfd717df59f6a5b2d60c633d57e824b700184427840793c8f5cbf1e4
name: python-intrepid-python-sdk-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for intrepid-python-sdk
url: https://pypi.org/project/intrepid-python-sdk/
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-intrepid-python-sdk-0.1.8-1.src.rpm
location_href: Packages/python-intrepid-python-sdk-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  Create a new conda environment with `conda create -n intrepid python=3.10`

  Activate environment with

  ```
  conda activate intrepid
  ```

  Install `poetry` with `pip install poetry` and all requirements `pip install -r requirements.txt`

  Build Python Intrepid SDK

  ```Bash
  poetry build
  poetry install
  ```
  And check that all has been installed correctly

  ```
  python examples/ex0.py
  ```

  This should print

  ```
  Hello from Intrepid SDK
  ```


  <!-- `python3 -m websockets ws://localhost:9999/` -->







  A Python node is created from dashboard and rendered according to the Python function signature that is attached.

  A Python SDK allows to
  1. read from the output of a node and
  2. write to the input of a node.

  Rendering a node means defining inputs and outputs complete with types (only primitive types supported).

  ```Python
  from intrepid import Intrepid, Qos



  def my_callback_function(in1: int, in2:int) -> (float, bool):
      
      time.sleep(0.2)
      return 1. * (in1 + in2), True




  qos = Qos(reliability="BestEffort", durability="TransientLocal")
  qos.set_history("KeepLast")
  qos.set_deadline(100)  # Deadline expressed in milliseconds




  mynode = Node("my_type")
  mynode.add_input("flow", IntrepidType(Type.FLOW))
  mynode.add_input("in1", IntrepidType(Type.INTEGER))
  mynode.add_input("in2", IntrepidType(Type.FLOAT))
  mynode.add_input("in3", IntrepidType(Type.VEC3, is_array=True))
  mynode.add_output("out1", IntrepidType(Type.FLOAT))


  node_handler = Intrepid(node_id="node_type/node_id")
  node_handler.register_node(mynode)


  node_handler.create_qos(qos)


  node_handler.register_callback(my_callback_function)


  node_handler.start()
  ```

  `node_id`, `input_id`, `output_id` are in the property section of the sidebar of the relative nodes.





  A node in the Intrepid platform is a fundamental building block that represents a logical function, package, or module capable of performing computation on inputs and making results available on outputs. In the context of visual programming tools provided by Intrepid, a node is a block that users can drag and drop in the editor and connect with other nodes to create workflows or pipelines.

  From a developer’s perspective, a node can be thought of as a container for custom logic implemented in Python, Rust, C/C++. Users who want to implement their own custom logic can create a node using Python, add their desired functionality, and publish it to the Intrepid graph. Once published, these custom nodes can be seamlessly integrated into the visual programming environment, allowing users to connect them with other nodes just like any other built-in node.

  In summary, a node in Intrepid serves as a modular unit for encapsulating computational logic, enabling users to create custom functionalities and extend the capabilities of the platform’s visual programming tools.

  An example node with 3 inputs and 3 outputs is provided below

  ```Python

  mynode = Node("my_type")
  mynode.add_input("flow", IntrepidType(Type.FLOW))
  mynode.add_input("in1", IntrepidType(Type.INTEGER))
  mynode.add_input("in2", IntrepidType(Type.INTEGER))
  mynode.add_output("flow", IntrepidType(Type.FLOW))
  mynode.add_output("out1", IntrepidType(Type.FLOAT))
  mynode.add_output("is_float", IntrepidType(Type.BOOLEAN))
  ```




  Once a node has been created with its desired logic implemented, it must be registered with the Intrepid engine to become operational within the platform’s ecosystem. Registration involves associating the node with the Intrepid engine, enabling it to be recognized and utilized by other components of the system.

  After registration, the user needs to attach a callback function to the node. This callback function defines the specific actions or computations the node will perform when inputs are received. The callback function typically takes input data, processes it, and generates output data accordingly.

  Once the callback function is attached, the node is ready to start executing its logic. Starting the node initiates its operation within the Intrepid environment, allowing it to actively process inputs, execute the defined logic, and produce output data as per its functionality.

  Below is an example demonstrating the process of registering, attaching a callback, and starting a node in Python using the Python SDK:


  ```Python

  node_handler = Intrepid(node_id="node_type/node_id")
  node_handler.register_node(mynode)


  node_handler.create_qos(qos)
  ```
  ​


  ```Python

  node_handler.register_callback(my_callback_function)


  node_handler.start()
  ```

  This should show node info and status

  ```Bash
  Created node  node/sdk/ex1
  Attached QoS policy to node
  Callback registered to node
  Listening on host 127.0.0.1:9999

  ```

  Node `node/sdk/ex1` is running a websocket server at `127.0.0.1:9999`





  Execute the Intrepid runtime (`intrepid-agent`) with arguments
  `run-node` <node_name>
  `--load ws://<host>:<port>` where the node is running
  `-i input1`
  `-i input2`


  ```Bash
  ./intrepid-agent run-node node/sdk/ex1 --load ws://127.0.0.1:9999 -i 1 -i 2
  ```

  This should show

  ```Bash
  2024-10-08T14:18:42.078Z INFO  [exec_graph_connector::plugins] remote plugin initialized: ws://127.0.0.1:9999
  2024-10-08T14:18:42.104Z INFO  [exec_graph_connector::plugins] remote plugin initialized: ws://127.0.0.1:9999
  2024-10-08T14:18:42.607Z INFO  [exec_graph_connector::agent_task] 3.0

  ```

  The node is running and computing the callback function, and returning `3.0`



  In order to be viewed from the dashboard and connected to the rest of the graph, a node must be published.
  An authentication token is necessary to publish a node to a user library. Such token can be retrieved from dashboard at https://labs.intrepid.ai from the `Project` section on the left sidebar.


  ```Bash
  ./intrepid-agent publish node/sdk/ex1 --load ws://127.0.0.1:9999 https://labs.intrepid.ai/projects/34/r3Gv...otpm

  ```

  If node is published correctly, this will be printed to stdout

  ```Bash
  intrepid.ai/projects/34/Uy66ce2RCqqOniGLBuNGcaUu
  2024-10-08T15:15:28.790Z INFO  [exec_graph_connector::plugins] remote plugin initialized: ws://127.0.0.1:9999
  2024-10-08T15:15:28.795Z INFO  [exec_graph_connector::http] -> https://labs.intrepid.ai/api/nodes/sdk
  2024-10-08T15:15:28.833Z INFO  [exec_graph_connector::http] <- 201, length: 43
  ```


pkgId: 0684497b81a9efabd38cdaaf5a9f05fa995c436e3ef9fec96ac6a151cd18067e
name: python-intriniorealtime-help
arch: noarch
version: 5.3.3
epoch: 0
release: 1
summary: Development documents and examples for intriniorealtime
url: https://intrinio.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-intriniorealtime-5.3.3-1.src.rpm
location_href: Packages/python-intriniorealtime-help-5.3.3-1.noarch.rpm
checksum_type: sha256
description:
  `client.join(channels)` - Joins the given channels. This can be called at any time. The client will automatically register joined channels and establish the proper subscriptions with the WebSocket connection.
  * **Parameter** `channels` - A single channel or list of channels. You can also use the special symbol, "lobby" to join the firehose channel and recieved updates for all ticker symbols (you must have a valid "firehose" subscription).
  ```python
  client.join(["AAPL", "MSFT", "GE"])
  client.join("GOOG")
  client.join("lobby")


pkgId: 39361998b986cfe3945d3898649ac744775a5020e0352d746894a17ac7fae39f
name: python-introspection-help
arch: noarch
version: 1.9.3
epoch: 0
release: 1
summary: Development documents and examples for introspection
url: https://pypi.org/project/introspection/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-introspection-1.9.3-1.src.rpm
location_href: Packages/python-introspection-help-1.9.3-1.noarch.rpm
checksum_type: sha256
description:
  This module is a collection of introspection functions.

  Some functions are improved versions of the functions found in the [inspect module](https://docs.python.org/3/library/inspect.html), others are completely new.



  The documentation can be found [here](https://Aran-Fey.github.io/introspection/build/html/index.html).



  ```bash
  python3 -m pip install introspection
  ```


pkgId: 7540f1e0f8053bfe06f5feb51b0d70e91b00180f0848f26e8d025c50417fdf74
name: python-invariant-ai-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for invariant-ai
url: https://pypi.org/project/invariant-ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-invariant-ai-0.1.1-1.src.rpm
location_href: Packages/python-invariant-ai-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1 align="center"><img src="https://invariantlabs.ai/theme/images/logo.svg"/></h1>
    <h1 align="center">Invariant <code>testing</code></h1>

    <p align="center">
      Helps you build better AI agents through debuggable unit testing
    </p>
    <p align="center">


   <a href="https://discord.gg/dZuZfhKnJ4"><img src="https://img.shields.io/discord/1265409784409231483?style=plastic&logo=discord&color=blueviolet&logoColor=white" height=18/></a>

  [Documentation](https://explorer.invariantlabs.ai/docs/testing/)

    </p>
  </div>
  <br/>

  Invariant `testing` is a lightweight library to write and run AI agent tests. It provides helpers and assertions that enable you to write robust tests for your agentic applications.

  Using localized assertions, testing always points you to the exact part of the agent's behavior that caused a test to fail, making it easy to debug and resolve issues (think: stacktraces for agents).

  <br/>
  <br/>

  <div align="center">

  <img src="https://explorer.invariantlabs.ai/docs/testing/assets/overview.png" width="70%"/>
  </div>



  ```
  pip install invariant-ai
  ```



  The example below uses `extract(...)` to detect `locations` from messages. This uses the `gpt-4o` model from OpenAI.

  Setup your OpenAI key as

  ```bash
  export OPENAI_API_KEY=<your-key>
  ```

  Code:

  ```python

  import invariant.testing.functional as F
  from invariant.testing import Trace, assert_equals

  def test_weather():
      
      trace = Trace(
          trace=[
              {"role": "user", "content": "What is the weather like in Paris?"},
              {"role": "agent", "content": "The weather in London is 75°F and sunny."},
          ]
      )

      
      with trace.as_context():
          
          locations = trace.messages()[-1]["content"].extract("locations")

          
          assert_equals(1, F.len(locations),
              "The agent should respond about one location only")

          assert_equals("Paris", locations[0], "The agent should respond about Paris")

  ```

  **Execute it on the command line**:

  ```py
  $ invariant test
  ________________________________ test_weather _________________________________
  ERROR: 1 hard assertions failed:


      
      assert_equals(1, locations.len(),
          "The agent should respond about one location only")

  >   assert_equals("Paris", locations[0], "The agent should respond about Paris")
  ________________________________________________________________________________

  ASSERTION FAILED: The agent should respond about Paris (expected: 'Paris', actual: 'London')
  ________________________________________________________________________________






          content:   "The weather in London is 75°F and sunny."


  ```
  The test result precisely [localizes the failure in the provided agent trace](https://explorer.invariantlabs.ai/docs/testing/Writing_Tests/tests/).

  **Visual Test Viewer (Explorer):**

  As an alternative to the command line, you can also [visualize test results](https://explorer.invariantlabs.ai/docs/testing/Running_Tests/Visual_Debugger/) on the [Invariant Explorer](https://explorer.invariantlabs.ai/):

  ```py
  $ invariant test --push
  ```

  ![image](https://explorer.invariantlabs.ai/docs/testing/assets/explorer.png)


  Like the terminal output, the Explorer highlights the relevant ranges, but does so even more precisely, marking the exact words that caused the assertion to fail.



  * Comprehensive `Trace` API for easily navigating and checking agent traces.
  * Assertions library to check agent behavior, including fuzzy checkers such as _Levenshtein distance_, _semantic similarity_ and _LLM-as-a-judge_ pipelines.
  * Full `pytest` compatibility for easy integration with existing test and CI/CD pipelines.
  * Parameterized tests for testing multiple scenarios with a single test function.
  * Visual test viewer for exploring large traces and debugging test failures in [Explorer](https://explorer.invariantlabs.ai)

  To learn more [read the documentation](https://explorer.invariantlabs.ai/docs/testing/)


pkgId: 3e378ad9b986db3b4c0facfa7e79c802315dd343ea88dc60661c0bbedea8463d
name: python-inventree-help
arch: noarch
version: 0.17.2
epoch: 0
release: 1
summary: Development documents and examples for inventree
url: https://github.com/inventree/inventree-python/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inventree-0.17.2-1.src.rpm
location_href: Packages/python-inventree-help-0.17.2-1.noarch.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![PyPI](https://img.shields.io/pypi/v/inventree)](https://pypi.org/project/inventree/)
  ![Build Status](https://github.com/inventree/inventree-python/actions/workflows/ci.yaml/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/inventree/inventree-python/badge.svg)](https://coveralls.io/github/inventree/inventree-python)
  ![PEP](https://github.com/inventree/inventree-python/actions/workflows/pep.yaml/badge.svg)



  Python library for communication with the [InvenTree parts management system](https:///github.com/inventree/inventree) using the integrated REST API.

  This library provides a class-based interface for interacting with the database. Each database table is represented as a class object which provides features analogous to the REST CRUD endpoints (Create, Retrieve, Update, Destroy).



  The InvenTree python library can be easily installed using PIP:

  ```
  pip install inventree
  ```



  Refer to the [InvenTree documentation](https://docs.inventree.org/en/latest/api/python/python/)


pkgId: af96ac0edc3bcc1e948aafd4c52263aa70320e9d904ad5c8915bbd236078c444
name: python-invertedai-help
arch: noarch
version: 0.0.19
epoch: 0
release: 1
summary: Development documents and examples for invertedai
url: https://pypi.org/project/invertedai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-invertedai-0.0.19-1.src.rpm
location_href: Packages/python-invertedai-help-0.0.19-1.noarch.rpm
checksum_type: sha256
description:
  [pypi-badge]: https://badge.fury.io/py/invertedai.svg
  [pypi-link]: https://pypi.org/project/invertedai/
  [python-badge]: https://img.shields.io/pypi/pyversions/invertedai.svg?color=%2334D058
  [ci-badge]: https://github.com/inverted-ai/invertedai/actions/workflows/CI.yml/badge.svg?branch=master
  [colab-badge]: https://colab.research.google.com/assets/colab-badge.svg
  [colab-link]: https://colab.research.google.com/github/inverted-ai/invertedai/blob/develop/examples/IAI_full_demo.ipynb
  [rest-link]: https://app.swaggerhub.com/apis-docs/InvertedAI/InvertedAI
  [examples-link]: https://github.com/inverted-ai/invertedai/tree/master/examples

  [![Documentation Status](https://readthedocs.org/projects/inverted-ai/badge/?version=latest)](https://inverted-ai.readthedocs.io/en/latest/?badge=latest)
  [![PyPI][pypi-badge]][pypi-link]
  [![python-badge]][pypi-link]
  [![ci-badge]](https://github.com/inverted-ai/invertedai/actions/workflows/CI.yml)
  [![Open In Colab][colab-badge]][colab-link]




  <!-- start elevator-pitch -->
  Inverted AI provides an API for controlling non-playable characters (NPCs) in autonomous driving simulations,
  available as either a [REST API][rest-link] or a [Python SDK](https://docs.inverted.ai/en/latest/pythonapi/index.html), (and [C++ SDK](https://docs.inverted.ai/en/latest/cppapi/index.html)) built on top of it. Using the API requires an access key -
  create an account on our [user portal](https://www.inverted.ai/portal/login) to get one.  New users are given keys preloaded with an API access budget; researcher users affiliated to academic institutions generally receive a sufficient amount of credits to conduct their research for free.  This page describes how to get started quickly. For more in-depth understanding,
  see the [API usage guide](https://docs.inverted.ai/en/latest/userguide.html), and detailed documentation for the [REST API][rest-link],
  the [Python SDK](https://docs.inverted.ai/en/latest/pythonapi/index.html), and the [C++ SDK](https://docs.inverted.ai/en/latest/cppapi/index.html).
  To understand the underlying technology and why it's necessary for autonomous driving simulations, visit the
  [Inverted AI website](https://www.inverted.ai/).
  <!-- end elevator-pitch -->

  ![](docs/images/top_camera.gif)


  <!-- start quickstart -->

  For installing the Python package from [PyPI][pypi-link]:

  ```bash
  pip install --upgrade invertedai
  ```

  The Python client SDK is [open source](https://github.com/inverted-ai/invertedai),
  so you can also download it and build locally.




  ``` python
  import invertedai as iai
  from invertedai.utils import get_default_agent_properties
  from invertedai.common import AgentType

  import matplotlib.pyplot as plt

  location = "canada:drake_street_and_pacific_blvd"  # select one of available locations

  iai.add_apikey('')  # specify your key here or through the IAI_API_KEY variable

  print("Begin initialization.")


  location_info_response = iai.location_info(location=location)


  response = iai.initialize(
      location=location,  # select one of available locations
      agent_properties=get_default_agent_properties({AgentType.car:10}),  # number of NPCs to spawn
  )
  agent_properties = response.agent_properties  # get dimension and other attributes of NPCs

  rendered_static_map = location_info_response.birdview_image.decode()
  scene_plotter = iai.utils.ScenePlotter(
      rendered_static_map,
      location_info_response.map_fov,
      (location_info_response.map_center.x, location_info_response.map_center.y),
      location_info_response.static_actors
  )
  scene_plotter.initialize_recording(
      agent_states=response.agent_states,
      agent_properties=agent_properties,
  )

  print("Begin stepping through simulation.")
  for _ in range(100):  # how many simulation steps to execute (10 steps is 1 second)

      
      response = iai.drive(
          location=location,
          agent_properties=agent_properties,
          agent_states=response.agent_states,
          recurrent_states=response.recurrent_states,
          light_recurrent_states=response.light_recurrent_states,
      )

      
      scene_plotter.record_step(response.agent_states,response.traffic_lights_states)

  print("Simulation finished, save visualization.")

  fig, ax = plt.subplots(constrained_layout=True, figsize=(50, 50))
  gif_name = 'minimal_example.gif'
  scene_plotter.animate_scene(
      output_name=gif_name,
      ax=ax,
      direction_vec=False,
      velocity_vec=False,
      plot_frame_number=True
  )
  print("Done")

  ```



  Conceptually, the API is used to establish synchronous co-simulation between your own simulator running locally on
  your machine and the NPC engine running on Inverted AI servers. The basic integration in Python looks like this.

  ```python
  import invertedai as iai
  from invertedai.utils import get_default_agent_properties
  from invertedai.common import AgentType

  from typing import List
  import numpy as np
  import matplotlib.pyplot as plt

  iai.add_apikey('')  # specify your key here or through the IAI_API_KEY variable


  class LocalSimulator:
      """
      Mock up of a local simulator, where you control the ego vehicle. This example only supports single ego vehicle.
      """

      def __init__(self, ego_state: iai.common.AgentState, npc_states: List[iai.common.AgentState]):
          self.ego_state = ego_state
          self.npc_states = npc_states

      def _step_ego(self):
          """
          The simple motion model drives forward with constant speed.
          The ego agent ignores the map and NPCs for simplicity.
          """
          dt = 0.1
          dx = self.ego_state.speed * dt * np.cos(self.ego_state.orientation)
          dy = self.ego_state.speed * dt * np.sin(self.ego_state.orientation)

          self.ego_state = iai.common.AgentState(
              center=iai.common.Point(x=self.ego_state.center.x + dx, y=self.ego_state.center.y + dy),
              orientation=self.ego_state.orientation,
              speed=self.ego_state.speed,
          )

      def step(self, predicted_npc_states):
          self._step_ego()  # ego vehicle moves first so that it doesn't see future NPC movement
          self.npc_states = predicted_npc_states
          return self.ego_state

  print("Begin initialization.")
  location = "canada:drake_street_and_pacific_blvd"
  iai_simulation = iai.BasicCosimulation(  # instantiate a stateful wrapper for Inverted AI API
      location=location,  # select one of available locations
      agent_properties=get_default_agent_properties({AgentType.car:5}),  # how many vehicles in total to use in the simulation
      ego_agent_mask=[True, False, False, False, False],  # first vehicle is ego, rest are NPCs
      get_birdview=False,  # provides simple visualization - don't use in production
      traffic_lights=True,  # gets the traffic light states and used for initialization and steping the simulation
  )

  location_info_response = iai.location_info(location=location)
  rendered_static_map = location_info_response.birdview_image.decode()
  scene_plotter = iai.utils.ScenePlotter(
      rendered_static_map,
      location_info_response.map_fov,
      (location_info_response.map_center.x, location_info_response.map_center.y),
      location_info_response.static_actors
  )
  scene_plotter.initialize_recording(
      agent_states=iai_simulation.agent_states,
      agent_properties=iai_simulation.agent_properties,
  )

  print("Begin stepping through simulation.")
  local_simulation = LocalSimulator(iai_simulation.ego_states[0], iai_simulation.npc_states)
  for _ in range(100):  # how many simulation steps to execute (10 steps is 1 second)
      
      iai_simulation.step([local_simulation.ego_state])
      
      predicted_npc_behavior = iai_simulation.npc_states
      
      updated_ego_agent_state = local_simulation.step(predicted_npc_behavior)
      
      scene_plotter.record_step(iai_simulation.agent_states,iai_simulation.light_states)

  print("Simulation finished, save visualization.")

  fig, ax = plt.subplots(constrained_layout=True, figsize=(50, 50))
  gif_name = 'cosimulation_minimal_example.gif'
  scene_plotter.animate_scene(
      output_name=gif_name,
      ax=ax,
      direction_vec=False,
      velocity_vec=False,
      plot_frame_number=True
  )
  print("Done")
  ```
  To quickly check out how Inverted AI NPCs
  behave, try our
  [Colab](https://colab.research.google.com/github/inverted-ai/invertedai-drive/blob/develop/examples/IAI_full_demo.ipynb),
  where all agents are NPCs, or go to our
  [github repository](https://github.com/inverted-ai/invertedai/tree/master/examples) to execute it locally.
  When you're ready to try our NPCs with a real simulator, see the example [CARLA integration](https://github.com/inverted-ai/invertedai/tree/master/examples/carla).
  The examples are currently only provided in Python, but if you want to use the API from another language,
  you can use the [REST API][rest-link] directly.

  <!-- end quickstart -->


pkgId: c7ed02b71e36763e7eb76e5f843d58547579159b03d22d39639cbad83cd9abd6
name: python-investigator-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for investigator
url: https://zombo.com/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-investigator-1.0.2-1.src.rpm
location_href: Packages/python-investigator-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Fine-grained and Application access token needs the following permissions:

  Administration: Read-only
  Metadata: Read-only will be automatically set when you set Administration
  Dependabot Alerts: Read-only
  Secret scanning alerts: Read-only
  Code scanning alerts: Read-only


pkgId: f75bad83ad5ca950837d4cfb31e9d671cd0b6e66e17804a4abd5adeea2058d30
name: python-investing-algorithm-framework-help
arch: noarch
version: 3.8.1
epoch: 0
release: 1
summary: Development documents and examples for investing-algorithm-framework
url: https://pypi.org/project/investing-algorithm-framework/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-investing-algorithm-framework-3.8.1-1.src.rpm
location_href: Packages/python-investing-algorithm-framework-help-3.8.1-1.noarch.rpm
checksum_type: sha256
description:
  <a href=https://investing-algorithm-framework.com><img src="https://img.shields.io/badge/docs-website-brightgreen"></a>
  [![Build](https://github.com/coding-kitties/investing-algorithm-framework/actions/workflows/publish.yml/badge.svg)](https://github.com/coding-kitties/investing-algorithm-framework/actions/workflows/publish.yml)
  [![Tests](https://github.com/coding-kitties/investing-algorithm-framework/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/coding-kitties/investing-algorithm-framework/actions/workflows/test.yml)
  [![Downloads](https://pepy.tech/badge/investing-algorithm-framework)](https://pepy.tech/badge/investing-algorithm-framework)
  [![Current Version](https://img.shields.io/pypi/v/investing_algorithm_framework.svg)](https://img.shields.io/pypi/v/investing_algorithm_framework.svg)
  <a href="https://www.reddit.com/r/InvestingBots/"><img src="https://img.shields.io/reddit/subreddit-subscribers/investingbots?style=social"></a> <br/>
  [![GitHub stars](https://img.shields.io/github/stars/coding-kitties/investing-algorithm-framework.svg?style=social&label=Star&maxAge=1)](https://github.com/SeaQL/sea-orm/stargazers/) If you like what we do, consider starring, sharing and contributing!


  <p align="left">
  <a href="https://finterion.com">
    <img alt="Finterion" src="static/sponsors/finterion.png" width="200px" />
  </a>
  </p>



  The Investing Algorithm Framework is a Python framework that enables swift and elegant development of trading bots. It comes with all the necessary components for creating trading strategies, including data management, portfolio, order, position and trades management.

  Features:

  * Indicators module: A collection of indicators and utility functions that can be used in your trading strategies.
  * Order execution and tracking
  * Broker and exchange connections through [ccxt](https://github.com/ccxt/ccxt)
  * Backtesting and performance analysis reports [example](./examples/backtest_example)
  * Backtesting multiple algorithms with different backtest date ranges [example](./examples/backtests_example)
  * Portfolio management and tracking
  * Tracing for analyzing and debugging your trading bot
  * Web API for interacting with your deployed trading bot
  * Data persistence through sqlite db or an in-memory db
  * Stateless running for cloud function deployments
  * Polars dataframes support out of the box for fast data processing [pola.rs](https://pola.rs/)



  The following algorithm connects to binance and buys BTC every 5 seconds. It also exposes an REST API that allows you to interact with the algorithm.

  ```python
  import pathlib
  from investing_algorithm_framework import create_app, PortfolioConfiguration, \
      RESOURCE_DIRECTORY, TimeUnit, CCXTOHLCVMarketDataSource, Algorithm, \
      CCXTTickerMarketDataSource, MarketCredential, SYMBOLS




  symbols = ["BTC/EUR"]


  config = {
      RESOURCE_DIRECTORY: pathlib.Path(__file__).parent.resolve(),
      SYMBOLS: symbols
  }



  bitvavo_btc_eur_ohlcv_2h = CCXTOHLCVMarketDataSource(
      identifier="BTC-ohlcv",
      market="BITVAVO",
      symbol="BTC/EUR",
      time_frame="2h",
      window_size=200
  )

  bitvavo_btc_eur_ticker = CCXTTickerMarketDataSource(
      identifier="BTC-ticker",
      market="BITVAVO",
      symbol="BTC/EUR",
  )
  app = create_app(config=config)
  algorithm = Algorithm()
  app.add_market_credential(MarketCredential(
      market="bitvavo",
      api_key="<your api key>",
      secret_key="<your secret key>",
  ))
  app.add_portfolio_configuration(
      PortfolioConfiguration(
          market="bitvavo",
          trading_symbol="EUR",
          initial_balance=400
      )
  )
  app.add_algorithm(algorithm)

  @algorithm.strategy(
      
      time_unit=TimeUnit.HOUR,
      interval=2,
      
      market_data_sources=[bitvavo_btc_eur_ticker, bitvavo_btc_eur_ohlcv_2h]
  )
  def perform_strategy(algorithm: Algorithm, market_data: dict):
      
      
      
      polars_df = market_data["BTC-ohlcv"]
      print(f"I have access to {len(polars_df)} candles of ohlcv data")

      
      ticker_data = market_data["BTC-ticker"]
      unallocated_balance = algorithm.get_unallocated()
      positions = algorithm.get_positions()
      trades = algorithm.get_trades()
      open_trades = algorithm.get_open_trades()
      closed_trades = algorithm.get_closed_trades()

      
      algorithm.create_limit_order(
          target_symbol="BTC/EUR",
          order_side="buy",
          amount=0.01,
          price=ticker_data["ask"],
      )

      
      algorithm.close_trade(trades[0].id)

      
      algorithm.close_position(positions[0].get_symbol())

  if __name__ == "__main__":
      app.run()
  ```

  > You can find more examples [here](./examples) folder.



  The framework also supports backtesting and performing backtest experiments. After a backtest, you can print a report that shows the performance of your trading bot.

  To run a single backtest you can use the example code that can be found [here](./examples/backtest).



  You can use the ```pretty_print_backtest``` function to print a backtest report.
  For example if you run the [moving average example trading bot](./examples/crossover_moving_average_trading_bot)
  you will get the following backtesting report:

  ```bash

                    :%%#+-          .=*#%%        Backtest report
                    *%%%%+------=*%%%       ---------------------------
                    *%%%%%%%%%%%       Start date: 2023-08-24 00:00:00
                    .%%%%%%%%%%%#        End date: 2023-12-02 00:00:00
                     
               .:-+*%%- -+..#%%+.+-  +%%#*=-:   Number of runs: 1201
                .:-=*%%. += .%#  -+.-%%=-:..   Number of orders: 40
                .:=+#%%%*###%%#*+#%%%*+-:    Initial balance: 400.0
                      +%%%%%%%%%%=         Final balance: 428.2434
                  :++  .=#%%%%%%%*-           Total net gain: 28.2434 7.061%
                 :++:      :+%%%#-.              Growth: 28.2434 7.061%
                :++:        .%%%#=                Number of trades closed: 20
               :++:        .#%%%#*=               Number of trades open(end of backtest): 0
              :++-        :%%%%%+=              Percentage positive trades: 30.0%
             .++-        -%%%%%%+=             Percentage negative trades: 70.0%
            .++-        .%%%%%%%+=            Average trade size: 100.9692 EUR
           .++-         *%%%%%%%*+:           Average trade duration: 83.6 hours
          .++-          %%%%%%%#+=
          =++........:::%%%%%%%*+-
          .=++++++++++**#%%%%%%%++.

  Price noise

  Positions overview
  ╭────────────┬──────────┬──────────────────────┬───────────────────────┬──────────────┬───────────────┬───────────────────────────┬────────────────┬───────────────╮
  │ Position   │   Amount │   Pending buy amount │   Pending sell amount │   Cost (EUR) │   Value (EUR) │ Percentage of portfolio   │   Growth (EUR) │ Growth_rate   │
  ├────────────┼──────────┼──────────────────────┼───────────────────────┼──────────────┼───────────────┼───────────────────────────┼────────────────┼───────────────┤
  │ EUR        │  428.243 │                    0 │                     0 │      428.243 │       428.243 │ 100.0000%                 │              0 │ 0.0000%       │
  ├────────────┼──────────┼──────────────────────┼───────────────────────┼──────────────┼───────────────┼───────────────────────────┼────────────────┼───────────────┤
  │ DOT        │    0     │                    0 │                     0 │        0     │         0     │ 0.0000%                   │              0 │ 0.0000%       │
  ├────────────┼──────────┼──────────────────────┼───────────────────────┼──────────────┼───────────────┼───────────────────────────┼────────────────┼───────────────┤
  │ BTC        │    0     │                    0 │                     0 │        0     │         0     │ 0.0000%                   │              0 │ 0.0000%       │
  ╰────────────┴──────────┴──────────────────────┴───────────────────────┴──────────────┴───────────────┴───────────────────────────┴────────────────┴───────────────╯
  Trades overview
  ╭─────────┬─────────────────────┬─────────────────────┬────────────────────┬──────────────┬──────────────────┬───────────────────────┬────────────────────┬─────────────────────╮
  │ Pair    │ Open date           │ Close date          │   Duration (hours) │   Size (EUR) │   Net gain (EUR) │ Net gain percentage   │   Open price (EUR) │   Close price (EUR) │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-11-24 12:00:00 │ 2023-11-27 14:00:00 │                 74 │     107.55   │          -1.9587 │ -1.8212%              │             4.777  │              4.69   │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-11-20 00:00:00 │ 2023-11-21 08:00:00 │                 32 │     109.39   │          -4.5949 │ -4.2005%              │             4.9875 │              4.778  │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ BTC-EUR │ 2023-11-19 22:00:00 │ 2023-11-22 00:00:00 │                 50 │     109.309  │          -2.7624 │ -2.5272%              │         34159.1    │          33295.9    │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ BTC-EUR │ 2023-11-06 12:00:00 │ 2023-11-13 14:00:00 │                170 │     107.864  │           6.1015 │ 5.6567%               │         32685.9    │          34534.9    │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-10-20 12:00:00 │ 2023-10-27 08:00:00 │                164 │      99.085  │          10.9799 │ 11.0813%              │             3.5465 │              3.9395 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ BTC-EUR │ 2023-10-14 04:00:00 │ 2023-10-27 22:00:00 │                330 │      97.4278 │          24.137  │ 24.7742%              │         25638.9    │          31990.7    │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-10-14 04:00:00 │ 2023-10-17 14:00:00 │                 82 │      99.5572 │          -1.8877 │ -1.8961%              │             3.56   │              3.4925 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-10-07 08:00:00 │ 2023-10-08 08:00:00 │                 24 │      99.9498 │          -1.5708 │ -1.5716%              │             3.8815 │              3.8205 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ BTC-EUR │ 2023-09-27 10:00:00 │ 2023-10-05 20:00:00 │                202 │      98.2888 │           3.433  │ 3.4927%               │         25202.2    │          26082.5    │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-27 10:00:00 │ 2023-10-03 20:00:00 │                154 │      98.7893 │           1.2085 │ 1.2233%               │             3.842  │              3.889  │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-25 12:00:00 │ 2023-09-27 04:00:00 │                 40 │      98.9193 │          -0.5194 │ -0.5251%              │             3.809  │              3.789  │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-14 16:00:00 │ 2023-09-18 02:00:00 │                 82 │      98.9419 │          -0.0912 │ -0.0921%              │             3.799  │              3.7955 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ BTC-EUR │ 2023-09-07 06:00:00 │ 2023-09-10 16:00:00 │                 82 │      98.6093 │           0.3412 │ 0.3460%               │         24051      │          24134.3    │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-07 00:00:00 │ 2023-09-09 02:00:00 │                 50 │      98.9158 │          -0.2358 │ -0.2383%              │             3.986  │              3.9765 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-05 14:00:00 │ 2023-09-06 12:00:00 │                 22 │      99.2132 │          -1.1909 │ -1.2003%              │             3.999  │              3.951  │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-04 16:00:00 │ 2023-09-04 22:00:00 │                  6 │      99.355  │          -0.5671 │ -0.5708%              │             3.942  │              3.9195 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-09-04 10:00:00 │ 2023-09-04 14:00:00 │                  4 │      99.4774 │          -0.4889 │ -0.4914%              │             3.968  │              3.9485 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ BTC-EUR │ 2023-08-26 10:00:00 │ 2023-08-26 18:00:00 │                  8 │      99.0829 │          -0.03   │ -0.0302%              │         24166.6    │          24159.3    │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-08-25 10:00:00 │ 2023-08-28 10:00:00 │                 72 │      99.659  │          -0.6975 │ -0.6999%              │             4.1435 │              4.1145 │
  ├─────────┼─────────────────────┼─────────────────────┼────────────────────┼──────────────┼──────────────────┼───────────────────────┼────────────────────┼─────────────────────┤
  │ DOT-EUR │ 2023-08-24 00:00:00 │ 2023-08-25 00:00:00 │                 24 │      99.9999 │          -1.3626 │ -1.3626%              │             4.1465 │              4.09   │
  ╰─────────┴─────────────────────┴─────────────────────┴────────────────────┴──────────────┴──────────────────┴───────────────────────┴────────────────────┴─────────────────────╯
  ```



  The framework also supports backtest experiments. Backtest experiments allows you to
  compare multiple algorithms and evaluate their performance. Ideally,
  you would do this by parameterizing your strategy and creating a factory function that
  creates the algorithm with the different parameters. You can find an example of this
  in the [backtest experiments example](./examples/backtest_experiment).



  The framework has by default support for [ccxt](https://github.com/ccxt/ccxt).
  This should allow you to connect to a lot of brokers/exchanges.

  ```python
  from investing_algorithm_framework import PortfolioConfiguration, \
      MarketCredential, create_app
  app = create_app()
  app.add_market_credential(
      MarketCredential(
          market="<your market>",
          api_key="<your api key>",
          secret_key="<your secret key>",
      )
  )
  app.add_portfolio_configuration(
      PortfolioConfiguration(
          market="<your market>",
          initial_balance=400,
          track_from="01/01/2022",
          trading_symbol="EUR"
      )
  )
  ```



  We are continuously working on improving the performance of the framework. If
  you have any suggestions, please let us know.



  You can download the framework with pypi.

  ```bash
  pip install investing-algorithm-framework
  ```



  If you use this framework for your investments, do not risk money
  which you are afraid to lose, until you have clear understanding how
  the framework works. We can't stress this enough:

  BEFORE YOU START USING MONEY WITH THE FRAMEWORK, MAKE SURE THAT YOU TESTED
  YOUR COMPONENTS THOROUGHLY. USE THE SOFTWARE AT YOUR OWN RISK.
  THE AUTHORS AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR INVESTMENT RESULTS.

  Also, make sure that you read the source code of any plugin you use or
  implementation of an algorithm made with this framework.



  All the documentation can be found online
  at the [documentation webstie](https://investing-algorithm-framework.com)

  In most cases, you'll probably never have to change code on this repo directly
  if you are building your algorithm/bot. But if you do, check out the
  contributing page at the website.

  If you'd like to chat with investing-algorithm-framework users
  and developers, [join us on Slack](https://inv-algo-framework.slack.com) or [join us on reddit](https://www.reddit.com/r/InvestingBots/)



  We want to thank all contributors to this project. A full list of all the people that contributed to the project can be
  found [here](https://github.com/investing-algorithms/investing-algorithm-framework/blob/master/AUTHORS.md)



  If you discover a bug in the framework, please [search our issue tracker](https://github.com/investing-algorithms/investing-algorithm-framework/issues?q=is%3Aissue)
  first. If it hasn't been reported, please [create a new issue](https://github.com/investing-algorithms/investing-algorithm-framework/issues/new).



  The investing algorithm framework is a community driven project.
  We welcome you to participate, contribute and together help build the future trading bots developed in python.

  Feel like the framework is missing a feature? We welcome your pull requests!
  If you want to contribute to the project roadmap, please take a look at the [project board](https://github.com/coding-kitties/investing-algorithm-framework/projects?query=is%3Aopen).
  You can pick up a task by assigning yourself to it.

  **Note** before starting any major new feature work, *please open an issue describing what you are planning to do*.
  This will ensure that interested parties can give valuable feedback on the feature, and let others know that you are working on it.

  **Important:** Always create your feature or hotfix against the `develop` branch, not `master`.


pkgId: 0812419cda6959237318a92a0cd1e689853fde546faabcd03fc2f7b0d2b22cb2
name: python-invrs-opt-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for invrs-opt
url: https://pypi.org/project/invrs-opt/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-invrs-opt-0.10.1-1.src.rpm
location_href: Packages/python-invrs-opt-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
  `v0.10.1`



  The `invrs-opt` package defines an optimizer API intended for topology optimization, inverse design, or AI-guided design. It (currently) implements the L-BFGS-B optimization algorithm along with some variants. The API is intended to be general so that new algorithms can be accommodated, and is inspired by the functional optimizer approach used in jax. Example usage is as follows:

  ```python
  initial_params = ...

  optimizer = invrs_opt.lbfgsb()
  state = optimizer.init(initial_params)

  for _ in range(steps):
      params = optimizer.params(state)
      value, grad = jax.value_and_grad(loss_fn)(params)
      state = optimizer.update(grad=grad, value=value, params=params, state=state)
  ```

  Optimizers in `invrs-opt` are compatible with custom types defined in the [totypes](https://github.com/invrs-io/totypes) package. The basic `lbfgsb` optimizer enforces bounds for custom types, while the `density_lbfgsb` optimizer implements a filter-and-threshold operation for `DensityArray2D` types to ensure that solutions have the correct length scale.


  ```
  pip install invrs_opt
  ```

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999  Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  [This is the first released version of the Lesser GPL.  It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.]  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it.  You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below.  When we speak of free software, we are referring to freedom of use, 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 this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things.  To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights.  These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it.  For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you.  You must make sure that they, too, receive or can get the source code.  If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it.  And you must show them these terms so they know their rights.  We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library.  To protect each distributor, we want to make it very clear that there is no warranty for the free library.  Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others.  Finally, software patents pose a constant threat to the existence of any free program.  We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder.  Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license.  Most GNU software, including some libraries, is covered by the ordinary GNU General Public License.  This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License.  We use this license for certain libraries in order to permit linking those libraries into non-free programs.  When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library.  The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom.  The Lesser General Public License permits more lax criteria for linking other code with the library.  We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License.  It also provides other free software developers Less of an advantage over competing non-free programs.  These disadvantages are the reason we use the ordinary General Public License for many libraries.  However, the Lesser license provides advantages in certain special circumstances.  For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard.  To achieve this, non-free programs must be allowed to use the library.  A more frequent case is that a free library does the same job as widely used non-free libraries.  In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License.  In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software.  For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system.  Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library.  The precise terms and conditions for copying, distribution and modification follow.  Pay close attention to the difference between a "work based on the library" and a "work that uses the library".  The former contains code derived from the library, whereas the latter must be combined with the library in order to run.  GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you".  A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.  The "Library", below, refers to any such software library or work which has been distributed under these terms.  A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  "Source code" for a work means the preferred form of the work for making modifications to it.  For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it).  Whether that is true depends on what the Library does and what the program that uses the Library does.  1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) The modified work must itself be a software library.  b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.  c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.  d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.  (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application.  Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.  In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library.  To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License.  (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.)  Do not make any other change in these notices.  Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.  This option is useful when you wish to copy part of the code of the Library into a program that is not a library.  4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.  If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.  5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library".  Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.  However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library".  The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.  When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library.  The threshold for this to be true is not precisely defined by law.  If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work.  (Executables containing this object code plus portions of the Library will still fall under Section 6.)  Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.  6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.  You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License.  You must supply a copy of this License.  If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License.  Also, you must do one of these things:  a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library.  (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)  b) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with.  c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.  d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.  e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.  For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it.  However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system.  Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.  7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities.  This must be distributed under the terms of the Sections above.  b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License.  However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  9. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Library or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.  10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.  11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), 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 distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all.  For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  13. The Free Software Foundation may publish revised and/or new versions of the Lesser 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 Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.  14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "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 LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY 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 LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Libraries  If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change.  You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).  To apply these terms, attach the following notices to the library.  It is safest to attach them to the start of each source file to most effectively convey 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 library's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library 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 Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA  Also add information on how to contact you by electronic and paper mail.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker.  <signature of Ty Coon>, 1 April 1990 Ty Coon, President of Vice  That's all there is to it!


pkgId: 3e7d0ca81862c40314fb56405578813db145afa1862424b8c178c9f2215a1916
name: python-inzicht-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for inzicht
url: https://pypi.org/project/inzicht/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-inzicht-0.1.6-1.src.rpm
location_href: Packages/python-inzicht-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  - **Generic CRUD Operations:** Perform CRUD operations on SQLAlchemy models with minimal code.
  - **Flexible Querying:** Easily apply filters, sorting, and pagination.


pkgId: ddd32777c6b049232f00d26f13bf6fdeda4e8af0a6bb5f9f9da515beca23c1de
name: python-ioc-typing-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for ioc-typing
url: https://github.com/janwychowaniak/ioc-typing
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ioc-typing-0.1.0-1.src.rpm
location_href: Packages/python-ioc-typing-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python library for identifying and classifying various types of Indicators of Compromise (IOCs). IOCs are forensic artifacts that indicate potential security breaches, malware infections, or other malicious activities in a system or network.



  From PyPI (stable release):
  ```bash
  pip install ioc-typing
  ```

  For development:
  ```bash
  git clone https://github.com/janwychowaniak/ioc-typing.git
  cd ioc-typing
  pip install -e ".[dev]"  # or "make dev" for easily creating a local venv
  ```



  Basic usage:
  ```python
  from ioc_typing import IOCClassifier

  classifier = IOCClassifier()


  print(classifier.classify("192.168.1.1"))          # Output: IP_ADDRESS
  print(classifier.classify("evil.com"))             # Output: DOMAIN
  print(classifier.classify("44d88612fea8a8f36de82e1278abb02f")) # Output: MD5_HASH
  ```

  Batch classification:
  ```python
  iocs = [
      "192.168.1.1",
      "https://pages.info/malware.exe",
      "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
      "not an IOC"
  ]

  for ioc in iocs:
      ioc_type = classifier.classify(ioc)
      print(f"{ioc}: {ioc_type['type_pri']}")
  ```



  - Identifies multiple IOC types:
    - IP addresses (IPv4 and IPv6)
    - Domain names
    - URLs
    - File hashes (MD5, SHA1, SHA256)
    - as well as non-IOCs (e.g. random strings)
  - Fast and accurate classification using optimized regex patterns
  - Zero dependencies for core functionality
  - Comprehensive test suite ensuring reliability
  - Easy integration with existing security tools and SIEM systems



  Contributions are welcome! Please feel free to submit a Pull Request.



  [MIT](LICENSE)

rpm_license:
  MIT License  Copyright (c) 2024 Jan Wychowaniak  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: 8520e195eda8d6f57faa9e2320b2702773b00229da23e998cba14f79460a40f8
name: python-iocsearcher-help
arch: noarch
version: 2.4.4
epoch: 0
release: 1
summary: Development documents and examples for iocsearcher
url: https://github.com/malicialab/iocsearcher
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iocsearcher-2.4.4-1.src.rpm
location_href: Packages/python-iocsearcher-help-2.4.4-1.noarch.rpm
checksum_type: sha256
description:
  _iocsearcher_ is a Python library and command-line tool to extract
  indicators of compromise (IOCs),
  also known as cyber observables,
  from HTML, PDF, Word (.docx), and text files.
  It can identify both defanged
  (e.g., URL hx<area>xp://<area>example[DOT]com) and
  unmodified IOCs (e.g., URL ht<area>tp://<area>example.com).



  ~~~ sh
  pip install iocsearcher
  ~~~



  _iocsearcher_ can extract the following IOC types:

  - URLs (url)
  - Domain names (fqdn)
  - IP addresses (ip4, ip6)
  - IP subnets (ip4Net)
  - Hashes (md5, sha1, sha256)
  - Email addresses (email)
  - Phone numbers (phoneNumber)
  - Copyright strings (copyright)
  - CVE vulnerability identifiers (cve)
  - Tor v3 addresses (onionAddress)
  - Social network handles (facebookHandle, githubHandle, instagramHandle,
  linkedinHandle, pinterestHandle, telegramHandle, twitterHandle, whatsappHandle,
  youtubeHandle, youtubeChannel)
  - Advertisement/analytics identifiers (googleAdsense, googleAnalytics, googleTagManager)
  - Blockchain addresses (bitcoin, bitcoincash, cardano, dashcoin, dogecoin, ethereum, litecoin, monero, ripple, solana, tezos, tronix, zcash)
  - Payment addresses (webmoney)
  - Chinese Internet Content Provider licenses (icp)
  - Bank account numbers (iban)
  - Trademarks (trademark)
  - Universal unique identifiers (uuid)
  - Android package name (packageName)
  - MITRE ATT&CK Technique identifiers (ttp)
  - Spanish NIF identifiers (nif)



  To find IOCs in a given file just provide the _-f (--file)_ option.
  By default, found IOCs are printed to stdout,
  defanged IOCs are rearmed, and
  IOCs are deduplicated so they only appear once.

  ~~~ sh
  iocsearcher -f file.pdf
  iocsearcher -f page.html
  iocsearcher -f document.docx
  iocsearcher -f input.txt
  ~~~

  You can use the _-o (--output)_ option to place IOCs to a file instead
  of stdout:

  ~~~ sh
  iocsearcher -f file.pdf -o iocs.txt
  ~~~

  By default all regexp are applied to the input.
  If you are only interested in some specific IOC types,
  it is more efficient to specify those using
  the _-t (--target)_ option, which can be applied multiple times:

  ~~~ sh
  iocsearcher -f file.pdf -t url -t email
  ~~~

  We also have a shortcut to scan for all blockchain addresses with -t BLOCKCHAIN

  ~~~ sh
  iocsearcher -f file.pdf -t BLOCKCHAIN
  ~~~

  You can also search for IOCs in all files in a directory using
  the _-d (--dir)_ option.
  IOCs extracted from each file will be placed in their own .iocs file.
  You can also place all IOCs founds across the input files
  in the same output file by also adding the _-o (--output)_ option:

  ~~~ sh
  iocsearcher -d directoryWithFiles -o all.iocs
  ~~~

  In HTML files, only the readable text is examined
  (i.e., think of the text shown by Firefox's Reader View).
  If you want to scan the whole HTML content you can use the
  _-r (--raw)_ option:

  ~~~ sh
  iocsearcher -f page.html -r
  ~~~

  If you have a file that you want to interpret as text avoiding
  filetype detection, you can use the _-F (--forcetext)_ option:

  ~~~ sh
  iocsearcher -f input.txt -F
  ~~~

  You can store the text extracted from a PDF/HTML/Word file using the
  _-T (--text)_ option, which will produce a .text file for each input file:

  ~~~ sh
  iocsearcher -f file.pdf -T
  ~~~

  By default IOCs are deduplicated, you can instead output the offset of
  each IOC without deduplication by using the _-v (--verbose)_ option:

  ~~~ sh
  iocsearcher -f file.pdf -v
  ~~~

  You can also produce a ranking of IOCs by number of appearances
  (without deduplication) by using the _-C (--count)_ option:

  ~~~ sh
  iocsearcher -f file.pdf -C -o rank.iocs
  ~~~



  You can also use _iocsearcher_ as a library by creating a
  _Searcher_ object and then invoking the functions
  _search_data_ to identify rearmed and deduplicated IOCs and
  _search_raw_ to identify all matches, their offsets, and the defanged string.
  The _Searcher_ object needs to be created only once to parse the regexps.
  Then, it can be reused to find IOCs in multiple input strings.

  ~~~ sh
  python3
  >>> import iocsearcher
  >>> from iocsearcher.searcher import Searcher
  >>> test = 'Find this email contact[AT]example[dot]com'
  >>> searcher = Searcher()
  >>> searcher.search_data(test)
  {('email', 'contact@example.com'), ('fqdn', 'example.com')}
  >>> searcher.search_data(test, targets={'email'})
  {('email', 'contact@example.com')}
  >>> searcher.search_raw(test)
  [('email', 'contact@example.com', 16, 'contact[AT]example[dot]com'), ('fqdn', 'example.com', 27, 'example[dot]com')]
  ~~~

  You can also open a document without needing to provide its type,
  get its text, and then use a _Searcher_ object to search for IOCs in the text.
  For example, if you have a file called _file.pdf_ you can do:

  ~~~ sh
  python3
  >>> import iocsearcher
  >>> from iocsearcher.document import open_document
  >>> from iocsearcher.searcher import Searcher
  >>> doc = open_document("file.pdf")
  >>> text,_ = doc.get_text() if doc is not None else ""
  >>> searcher = Searcher()
  >>> searcher.search_data(text)
  ~~~

  If the file is not a PDF, HTML, Word (.docx), or text document,
  _open_document_ throws a warning and returns None



  Many security reports defang (i.e., remove the teeth from) malicious
  indicators, especially network indicators such as URLs, domains,
  IP addresses, and email addresses.
  This practice helps to prevent users from inadvertently clicking on a
  malicious indicator and start a network connection to it.
  Defanged indicators do not follow the indicator specification and thus
  require relaxed regular expressions to detect them.

  _iocsearcher_ supports some popular defang operations
  and rearms the IOCs by default so that deduplication works even if the
  same IOC has been defanged in different ways.
  However, it is not possible to support all defang operations,
  as every analyst can come up with their own.
  If you think _iocsearcher_ is missing support for some popular
  defang operation, let us know by providing pointers to reports that use them.



  _iocsearcher_ reads its regular expressions from an INI configuration file.
  If you want to modify a regexp, add a regexp,
  change the IOC type associated to a regexp, or disable validation
  for an existing regexp, you can create a copy of the
  [patterns.ini](https://github.com/malicialab/iocsearcher/blob/main/iocsearcher/data/patterns.ini)
  file in the GitHub repo,
  edit your copy, and pass it as input to _iocsearcher_
  using the _-P (--patterns)_ option:

  ~~~ sh
  iocsearcher -f file.pdf -P mypatterns.ini
  ~~~

  Note that if you add a new regexp, the output will be the outermost group
  if a group exists, and the whole match if the regexp has no groups.



  There exist multiple other open-source IOC extraction tools
  and we developed iocsearcher to improve on those.
  In our [FGCS journal paper](https://arxiv.org/abs/2208.00042)
  we propose a novel evaluation methodology for IOC extraction tools and
  apply it to compare _iocsearcher_ with the following tools:

  - [Jager](https://github.com/sroberts/jager) (Python)
  - [IOC-parser](https://github.com/armbues/ioc_parser) (Python)
  - [Cacador](https://github.com/sroberts/cacador) (Go)
  - [CyObstract](https://github.com/cmu-sei/cyobstract) (Python)
  - [IOC Finder](https://github.com/fhightower/ioc-finder) (Python)
  - [IOC Extract](https://github.com/InQuest/python-iocextract) (Python)
  - [IOC-Extractor](https://github.com/ninoseki/ioc-extractor) (Python)

  We believe the results show _iocsearcher_ performs generally best,
  but that is up to you to judge.
  We encourage you to read our paper if you have questions about how
  _iocsearcher_ compares with the above tools and to try
  the above tools if _iocsearcher_ does not meet your goals.



  Technically speaking, _iocsearcher_ is an indicator extraction tool,
  i.e., it extracts indicators regardless if they are benign or malicious.
  Currently, _iocsearcher_,
  similar to most other tools mentioned above,
  does not differentiate malicious indicators (i.e., IOCs) from benign indicators.
  For example, it will extract all URLs in the given input,
  regardless if they are malicious or benign.

  Filtering of benign indicators is typically application-specific,
  so we prefer to keep it as a separate step.
  Such filtering is oftentimes performed with blocklists or through
  Natural Language Processing (NLP) techniques.



  _iocsearcher_ is released under the MIT license

  This repository includes Base58 decoding code from the
  [monero-python](https://github.com/monero-ecosystem/monero-python/) project.
  That code is located in the iocsearcher/monero folder and it is
  licensed under BSD 3-Clause.



  The design and evaluation of _iocsearcher_ and the comparison with prior
  IOC extraction tools are detailed in our
  [FGCS journal paper](https://arxiv.org/abs/2208.00042):

  > Juan Caballero, Gibran Gomez, Srdjan Matic, Gustavo Sánchez,
  Silvia Sebastián, and Arturo Villacañas.<br>
  GoodFATR: A Platform for Automated Threat Report Collection and
  IOC Extraction.<br>
  In Future Generation Computer Systems, 2023.



  The main developer and maintainer for _iocsearcher_ is Juan Caballero.
  Other members of the MaliciaLab at the
  [IMDEA Software Institute](http://software.imdea.org)
  have contributed fixes and helped with testing:
  Gibran Gomez, Silvia Sebastian, Srdjan Matic

rpm_license:
  MIT License  Copyright (c) 2023 MaliciaLab  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: 4230b98512209ed0b1dbcc47388c9802241ed03bdb78c60333b24c7f07c02e7e
name: python-iog-randomizer-help
arch: noarch
version: 5.1.5.1
epoch: 0
release: 1
summary: Development documents and examples for iog-randomizer
url: https://iogr.app/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iog-randomizer-5.1.5.1-1.src.rpm
location_href: Packages/python-iog-randomizer-help-5.1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  This randomizer is compatible with the US version of the Illusion of Gaia ROM.

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#faq">Jump to the FAQ</a>

  <a href="https://discord.gg/KfZ4VeD">Join the Community on Discord</a>

  <a href="https://www.youtube.com/watch?v=JobLH53Q1sM">Watch a Video Tutorial (UPDATED!)</a>

  The <a href="https://emotracker.net/download/">IoGR EmoTracker</a> is now live!


  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#quick-start">Quick Start (tl;dr)</a>

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#randomizer-settings">Randomizer Settings</a>

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#beating-the-game">How to Beat the Game</a>

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#features">Features:</a>
  - <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#overworld-movement">Overworld Movement</a>
  - <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#room-rewards-and-stat-upgrades">Room Rewards and Stat Upgrades</a>
  - <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#in-game-hints">In-Game Hints</a>
  - <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#other-features">Other Features</a>

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#faq">Frequently Asked Questions</a>


  Here's a quick primer on what you need to know about most randomizer seeds.


  Uploading a US Illusion of Gaia ROM, inputting the desired settings, and hitting "Generate ROM" will allow you to download a randomized ROM (as well as a spoiler log).  The original file will remain intact.


  - Item and Ability locations have been shuffled. Check every location and Dark Space for potential items/moves.
  - Unlike the original game, only some rooms provide stat upgrades when you clear all the enemies. When you enter a dungeon room, bring up the Start menu map; if you see a pulsing Force icon on the top-left, you will receive a stat upgrade for defeating all the enemies in that room.
  - Herbs will stack in your inventory, so don't be alarmed if you know you collected more than one herb yet see only one in your inventory; they're all there. Using an herb from the stack will bring up a confirmation box that informs you how many herbs you have left.
  - Illusion of Gaia has been transformed into an open-world game for the randomizer. To accomplish this, some items have different functionalities:
    - **Lola's Letter:** Acquiring _and reading_ this letter allows you to talk to Seth, who can take you between these three locations: South Cape (seaside cave), Diamond Coast (talk to Turbo), and Watermia (talk to the guy standing at the entrance)
    - **Teapot:** Use this in the Moon Tribe Camp to heal the spirits. They will take you to the Sky Garden and, from there, can take you back to the Moon Tribe Camp, the Nazca Plain, or the Seaside Palace.
    - **Memory Melody:** Play this melody for Neil in his cottage and he can take you around in his plane. He can take you to/from his cottage, his mansion in Euro, or Dao.  He can also drop you off at Babel Tower.
    - **Will:** Like the original game, you can use this to travel between Watermia (the guy tending kruks) and Euro (the guy standing near the town entrance)
    - **Large Roast:** Give this to a hungry kid in Natives Village and he'll guide you to Dao.
    - **Necklace:** Give this to Lilly in Itory Village and she'll take a ride in your pocket. You need her to progress through Edward's Tunnel and to acquire the coffin item in the Seaside Palace.
    - **Aura:** Using this item for the first time will unlock Shadow.  This is also one of the win conditions for Gaia seeds, as well as for unlocking early Firebird.
    - **Crystal Ring:** You can use this item immediately to activate it and make space in your inventory.  This (along with the Aura) allows you to pass through the barrier in Babel tower, and it's also one of the conditions to unlock early Firebird.
    - **Black Glasses:** You can use this item immediately to activate it and make space in your inventory.  As in vanilla, this allows you to see in the bright room in Ankor Wat -- however, it also allows you to see which stat upgrade you would receive for clearing a room of enemies (e.g. "FORCE" will be replaced with "+3 HP").
    - **Blue Journal:** This is an unused item that appears in the game code.  We've converted this to an in-game tutorial to help new players learn the game.  Talk to the NOC standing in front of the school in South Cape to get one.


  - For most seeds, you must **rescue Kara** from a painting using the Magic Dust. She can show up at the end of one of the five minor dungeons (Edward's Prison, Diamond Mine, Angel Village, Mt. Temple, or Ankor Wat).
  - For most seeds, you must **collect Mystic Statues** by beating bosses. You can find out the statues you'll need to get from the teacher in South Cape.
  - Once you free Kara, collect the needed Mystic Statues, and acquire _and use_ the Aura, you can face Dark Gaia.  **Talk to Gaia in any Dark Space** when you've completed these conditions and she can take you to fight her.


  - Acquiring late-game abilities early can open up progression in unique ways. Think outside the box if you're stuck.
  - There are a couple **in-game tools** to help newcomers:
    - Talk to the guy standing in front of the school in South Cape for a guidebook. This outlines much of the information discussed above, so it's handy as a quick reference if you get stuck.
    - Enter the house to the east of Will's House in South Cape to access a world map.  When you walk over a map location, it will break down the number of items you still need to collect from that area.


  Below are explanations of the various settings of the randomizer.


  This is a non-negative integer value that initializes the randomization algorithm.  Generating randomizers with the same seed and randomizer settings will produce identical games.


  There are four difficulty settings: Easy, Normal, Hard, and Extreme. The difficulty chosen affects the following game mechanics:
  - **Item and Ability Placement:** Easy and Normal modes both include a slight bias toward making required items and abilities available to the player earlier on.
  - **In-Game Spoilers:** Hints have been removed in Extreme mode.
  - **Boss Logic:** Solid Arm can be required for Extreme seeds.
  - **Boss Shuffle:** In Extreme, dungeons keep their vanilla music so you don't know which boss is at the end.  Solid Arm is included in Boss Shuffle in Extreme, but not other modes
  - **Red Jewel Hunt:** The number of Red Jewels required to beat the game, by difficulty, is 35/40/45/50
  - **Open World:** The items that replace the five travel items are more favorable in easier difficulties.


  You choose your level from the start menu when you create a new game file.  Level does not affect game logic or item placement, so if desired players could race the same seed at varying levels.  There are four level settings: Beginner, Intermediate, Advanced, and Expert. The level chosen affects the following game mechanics:
  - **Enemies:** Enemies scale in strength with each level.
  - **Room Rewards:** The number of room-clearing rewards available to the player is affected by difficulty (see below).
  - **Herbs:**  By level, the number of HP restored by herbs are full/8/6/4
  - **Snake Game:** The number of snakes required will increase at harder difficulties.


  This allows you to choose a game mode. There are currently four goals available (see below for more details):
  - **Dark Gaia:** Rescue Kara, find and use the Aura, collect required Mystic Statues (if any), and defeat Dark Gaia on the Comet to beat the game.
  - **Red Jewel Hunt:** Beat the game by collecting a number of Red Jewels and turning them into the Jeweler (see below).
  - **Apocalypse Gaia:** Same as Dark Gaia, except you'll face the true final boss hidden in the game code!  Shoutouts to Raeven0 for uncovering and reprogramming this masterpiece. (Very hard) NOTE: This fight has five phases -- the first two are identical to the vanilla Dark Gaia fight, and phases 3-5 are new.  Once you hit Phase 3, you set a checkpoint where if you die: 1) you return to the beginning of Phase 3 with full health, and 2) you regain any herbs you had at the beginning of that phase.
  - **Random Gaia:** Same as Dark Gaia, except there's a 50/50 chance you'll face Apocalypse Gaia instead.


  You can choose the number of Mystic Statues required to complete Dark Gaia seeds (0-6), or make the number random. This parameter is ignored for Red Jewel Hunts.


  You can choose to have the game start you in random locations throughout the world. Gaia's "warp to start" will return you to wherever you begin the game.
  - **South Cape:** You start the game in the vanilla location.
  - **Safe:** You start the game in a random safe location (e.g. a town)
  - **Unsafe:** You can start the game at any random Dark Space. It can be either a safe location (town) or an unsafe location (dungeon).
  - **Forced Unsafe:** You will start the game in the middle of a random dungeon.


  There are three logic modes available to the player.
  - **Completable:** This logic ensures that every item and ability location is reachable, allowing every seed to be completed 100%. This tends to yield slightly longer gameplay experiences.
  - **Beatable:** In Beatable seeds, you are guaranteed to have access to every item and ability you need to complete your goal, though you may not have access to every item location in the game. This tends to yield slightly more streamlined seeds -- however, it could also make helpful items like status upgrades unattainable, making this mode slightly more dangerous.
  - **Chaos:** Ability placement restrictions have been drastically loosened in this mode -- for instance, Freedan abilities can show up in towns, and Dark Spaces that are typically reserved for form changes might contain abilities, preventing the player from completing dungeons and accessing certain item locations.  As in Beatable, Chaos mode still ensures that the player has access to all the items and locations necessary to beat the game.


  - **Open World:** All overworld movement is unlocked from the start -- i.e. Lola's Letter, the Teapot, the Memory Melody, the Will, and the Large Roast are all activated at start.  Additionally, these five items have been removed from the item pool and have been replaced with STR upgrades, DEF upgrades, herbs, and/or nothing (dependent on difficulty setting).
  - **Allow Glitches:** You may be required to perform simple glitches to access progression items or abilities (see below).
  - **OHKO (One Hit Knockout):** You start the game with 1 HP and will never gain an HP upgrade, so each hit kills you automatically.
  - **Red Jewel Madness:** You start the game with 40 HP (max) and lose 1 HP for every Red Jewel you turn into the Jeweler. If you reach 0 total HP, you will be caught in an infinite death loop. Note: Gaining an HP upgrade when you're at or near 40 HP may result in lost upgrades, as any HP value above 40 is ignored.
  - **Early Firebird:** In this mode, you gain access to the Firebird attack when 1) you rescure Kara, 2) you equip the Crystal Ring, and 3) you're in Shadow's form.
  - **Fluteless:** Will doesn't have a flute, so he cannot block projectiles or deal damage with normal attacks. You're guaranteed to receive Psycho Dash in your first accessible Dark Space so you have a means to damage enemies.
  - **Zelda 3 Mode:** Choosing this variant makes some significant alterations to the game, inspired by the combat system of <i>The Legend of Zelda: A Link to the Past (ALTTP)</i>.  Below are the changes made in this mode. (Where appropriate, values given by level are provided in the format Beginner/Intermediate/Advanced/Expert.)
    - You begin the game with 6 HP instead of 8 (to mirror Link's starting health).
    - 12 Red Jewels have been removed from the game and replaced with 4 HP upgrades and 8 HP Pieces.  HP upgrades add +2 HP (+1 in Expert), and HP Pieces add +1 HP (+0.5 in Advanced and Expert).
    - Room rewards (HP only) grant +1 each.  The number of HP room upgrades available, by level, are 12/12/6/6
    - STR and DEF upgrades have been removed from the room/boss rewards and have been put into the item pool.
    - The max STR upgrades you can receive by level are 3/2/1/0.
    - The max DEF upgrades you can receive by level are 2/2/1/0.
    - Jump slashes deal double damage instead of +1 damage.
    - Each STR and DEF upgrade doubles the applicable stat instead of adding +1.
    - Herbs and HP upgrades provide the following refills, by level: 40/40/14/8.
    - Max HP available to the player, by level is 40/40/28/23.
    - Non-boss enemy stats are not shuffled between level choices. All non-bosses have 0 DEF.  Enemy damage ranges from 1 to 16.  (These values correspond to the enemies in A Link to the Past.)



  Here is a list of the glitches you may be required to perform when the "Allow Glitches" variant is selected:
  - **Z-ladder skip:** In Inca, you can take damage while mounting a ladder to enter the SE door early
  - **Cage Skip:** In Sky Garden SW room, you can jump-slash the dark-side switch to activate the cage as Will
  - **Golem Skip:** In Mu, on the second level, you can jump-slash past the Golem guarding the top of one of the ramps as Will (Dark Friar is normally required)
  - **Great Wall Skip:**
    - If you have Psycho Slider, you can buffer an attack as you fly over the third room to access the first Dark Space as Will
    - If you don't have Psycho Slider, you can backtrack from the end of the third room and dash-attack the switch to access the first Dark Space as Will
  - **Earthquaker Skip:** You can destroy the Gorgon guarding the way with Dark Friar instead of Earthquaker
  - **Glasses Skip:** You can navigate the bright room in Ankor Wat without the Black Glasses
  - **Pyramid Entrance:** Logic normally requires you to have Slider or Spin to get past the Mystic Orbs at the entrance, but it's possible without these abilities


  The enemizer is (and likely will forever be) in beta, so play at your own risk. Graphical glitches abound, and some seeds may be incompletable due to enemy placement. Please report any game-breaking situations in the Discord.
  References to enemy stats refer to STR, DEF and HP.
  _Note: Non-enemy sprites in dungeons have been largely removed in every enemizer setting except for Limited._
  - **Limited:** Enemies will be shuffled, but will only appear in their vanilla dungeons.
  - **Balanced:** Enemies can appear in any dungeon, but they will retain the stats of the enemies they replace, making each dungeon's difficulty relatively balanced to vanilla levels.
  - **Full:** Enemies can appear in any dungeon and retain their vanilla stats.
  - **Insane:** Enemeies can appear in any dungeon. Furthermore, enemy stats have been shuffled, so early enemies can have the stats of later enemies, and vice versa.


  In this mode, the bosses are shuffled throughout the dungeons. Each boss guards the same Mystic Statue as they do in the vanilla game, so completing a dungeon may grant you a different Statue than normal. For Easy and Normal difficulties, each dungeon will inherit the music of the dungeon its boss typically resides in -- for example, if you hear the Inca Ruins music in Sky Garden, that means that Castoth is where Viper normally is, and defeating him will grant you the first Mystic Statue. Solid Arm will only be included in the shuffle for Extreme difficulty.


  This feature shuffles some map transitions throughout the game.


  - **Coupled:** When an entrance is shuffled, the to and from directions will be linked together. When you enter a door and go back through it, you'll end up where you started.
  - **Uncoupled:** Each shuffled entrance's to and from halves will lead to separate locations. When you enter a door and go back through it, you'll likely end up in a different location than where you started.


  This mode shuffles the 19 overworld locations among the five continents, so the locations you have access to in each continent will be different in each seed. The number of continents, as well as the number of locations in each continent, are held constant.

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#contents">Return to Top</a>


  There are currently two modes (goals) for completing the game:


  In these modes, you must find the Magic Dust and use it to free Kara from her portrait.  You must then unite with her to defeat the final boss (either Dark Gaia or Apocalypse Gaia), a process which requires you to have Shadow's form unlocked (by obtaining and using the Aura) as well as a certain number of the game's six Mystic Statues.

  Kara's portrait can be found in one of the five minor dungeons, specified below.  The location of Kara's portrait will be contained in Lance's Letter.
  - Edward's Underground Tunnel
  - The Diamond Mine
  - The Angel Village
  - Mt. Kress (Mt. Temple)
  - Ankor Wat.

  Each seed may require a certain number of the six Mystic Statues. Talking to the schoolteacher in South Cape at the start of the game will indicate which statues are required. The statues are acquired by completing the following bosses/locations:

  - Statue 1: Castoth (Inca Ruins)
  - Statue 2: Viper (Sky Garden)
  - Statue 3: Vampires (Mu)
  - Statue 4: Sang Fanger (Great Wall)
  - Statue 5: Mummy Queen (Pyramid)
  - Statue 6: Boss Rush (Babel Tower) OR Solid Arm (Jeweler's Mansion)

  Once you rescue Kara, unlock Shadow's form, and earn the applicable Statues (if any), you may talk to Gaia at any Dark Space, who will grant you the option to face Dark Gaia and win the game.


  For this mode, the sole objective is to collect the required number of Red Jewels as quickly as possible and turn them into the Jeweler.  The number of Red Jewels required is 35 for Easy, 40 for Normal, 45 for Hard, and 50 for Extreme.  Turning these into the Jeweler and speaking with him allows you to beat the game.

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#contents">Return to Top</a>




  You can speak to the NPC standing in front of the school in South Cape for an in-game tutorial.  This guide will be tailored to the seed settings.

  Additionally, enter right-most house in South Cape for an interactive overworld map that allows you to explore how many items and Dark Spaces are available in each location, as well as the number of items you've gathered for each location.


  The items in the game will be shuffled across the game.  If the randomizer is created with "Completable" logic, every item location will be accessible; if it is "Beatable" or "Chaos", certain items not required to fulfill the game's objectives may be inaccessible.


  The special attacks are shuffled throughout the Dark Spaces in the game.  In "Completable" and "Beatable" logic, Dark Spaces in peaceful locations can only contain Will abilities, whereas Dark Spaces in battle areas can contain either Will or Freedan abilities.  In "Chaos" logic, town Dark Spaces can contain Freedan abilities.

  Also, in "Completable" mode, some Dark Spaces are reserved for form changes and will never contain abilities -- such as the Dark Space in the Underground Tunnel, for example. If one of these Dark Spaces contains an ability in "Beatable" or "Chaos", the logic will assume you don't have access to the rest of the dungeon.


  The world is broken up into continents. The locations in a continent are all accessible to one another through the world map screen. The following locations are accessible to one another via the overworld:
  - South-West Continent (South Cape, Edward's Castle, Itory Village, Moon Tribe Camp, Inca Ruins)
  - South-East Continent (Diamond Coast, Freejia, Diamond Mine, Neil's Cottage, Nazca Plain)
  - North-East Continent (Angel Village, Watermia, Great Wall)
  - North Continent (Euro, Mt. Kress, Natives' Village, Ankor Wat)
  - North-West Continent (Dao, Pyramid)

  Movement between continents (and to locations not specified above) becomes possible as items are acquired, or as quest events are completed:
  - Defeating Castoth in Inca Ruins grants you access to the Gold Ship, which takes you to the Diamond Coast.
  - Defeating Viper in Sky Garden takes you to the Seaside Palace.
  - Acquiring the Teapot allows you to use it on the plateau in the Moon Tribe camp. This grants you access to the Sky Garden. (After using the Teapot, you can use the Sky Garden to travel to the Moon Tribe Camp, the Nacza Plain, or the Seaside Palace.)
  - Acquiring Lola's Letter allows you to learn Morse Code. After reading the letter, talk to Erik in the Seaside Cave in South Cape. Together you can communicate with Seth (who is in Riverson form), who can transport you to the Diamond Coast or Watermia. Turbo the dog (Diamond Coast) and the man standing at the entrance in Watermia can also communicate with Seth for you.
  - Upon acquiring the Memory Melody, you can visit Neil in his cottage, who has forgotten how to pilot his airplane. Playing this melody for him restores his memory. From then on, he is happy to take you to Euro, Dao, or Babel Tower. He can be found either in his home, in his mansion in Euro, or in his room in Dao.
  - Acquiring the Will allows you to use Kruks to travel between Watermia and Euro. When the Will is in your inventory, speak to the man tending his Kruks in Watermia just east of the town entrance, or to the man standing by the east entrance to the city of Euro.
  - Upon acquiring the Large Roast, go to the Natives' Village and talk to the young boy. If you give him the roast, he will gratefully guide you across the treacherous expanse from the village to Dao. The man in Dao who grants you two items can also hire a guide to take you back to Natives' for free.
  - In the Nazca Plain, if you go to the location of the tile buried in the sand, you can warp to the Sky Garden. However, the Moon Tribe will only appear there if you have healed them with the Teapot. You can exit to the overworld from the Sky Garden by going up into the area where you normally enter from Nazca.
  - Mu and the Seaside Palace are accessible directly from Angel Village. What is originally the guest room in the vanilla game takes you to the Passage to Mu inside the Seaside Palace. Mu is freely accessible this way, but the Mu Palace Key is required to enter the Seaside Palace via this route.
  - The man playing the flute at the entrance to Dao can hire a guide to take you to the Natives' Village.


  The number of HP, STR and DEF upgrades available in the game has been reduced to reflect the extreme balancing of enemy statistics throughout the game -- so though the number of upgrades has decreased, each upgrade is much more significant than in the vanilla game.  HP upgrades grant you +3 HP each.

  The rewards are shuffled at random throughout the entire game, map by map.  The total rewards available by level (HP/STR/DEF) are:
  - **Beginner:** 10/7/7
  - **Intermediate:** 10/4/4
  - **Advanced:** 8/2/2 (max HP 35)
  - **Expert:** 6/0/0 (max HP 29)

  Upgrades can be accessed by clearing rooms that have a "Force" in them on the start menu.  (If you have the Black Glasses or the Crystal Ring equipped, the start menu will forecast which stat upgrade you'll receive for clearing a room.)

  Alternatively, defeating a boss will grant you any unobtained upgrades in the following dungeons, by boss:
  - **Castoth:** Underground Tunnel and Inca Ruins
  - **Viper:** Diamond Mine and Sky Garden
  - **Vampires:** Mu and Angel Dungeon
  - **Sand Fanger:** Great Wall and Mt. Kress
  - **Mummy Queen:** Pyramid
  - **Babel Tower:** Ankor Wat

  Each boss (and, by extension, the dungeons under each boss) is guaranteed to grant a total number of upgrades based on level: 4 for Beginner, 3 for Intermediate, 2 for Advanced, and 1 for Expert.


  You may speak to a number of NPCs throughout the game to receive hints as to the location of certain key items in the game, as well as the contents of certain hard-to-reach locations.  The following NPCs will give you a hint (hints have been removed in Extreme difficulty):
  - Kara's Guard in Edward's Castle
  - The Elder at Itory Village
  - The Queen on the Gold Ship
  - The man at Diamond Coast
  - The empty coffin at the Seaside Palace
  - Ishtar's Apprentice in Angel Village
  - Kara's Journal in Watermia
  - Erasquez the Explorer in Euro
  - The spirit at the end of Ankor Wat
  - The girl with Jackal's note in Dao
  - The first spirit in Babel Tower


  - The location of the glowing Gold Tile in Inca Ruins has been randomized, making the Wind Melody a requirement to progress to the end of that dungeon.
  - The differences between the puzzle rooms in Ishtar's Studio in Angel Village are also random and could differ from the vanilla game. In Easy and Normal, the first room will always be vanilla; in Hard and Extreme difficulties, there could be changes in the first room from vanilla. However, there will always only be one change between the two rooms.
  - The order of the hieroglyphs in the Pyramid has been shuffled, making the Father's Journal a required item to face the Mummy Queen. (You can give the Father's Journal to the guide in the hieroglyph room of the Pyramid for safe keeping.)
  - Herbs restore HP at rates that depend on the difficulty setting, either full restore (Easy), 8 HP (Normal), 4 HP (Hard), or 2 HP (Extreme).  An HP Jewel will restore your HP to full when used in Easy mode only.
  - Upon acquiring the Aura, equip it and use it to unlock Shadow's form. From then on, you can fight as Shadow in any dungeon.
  - Shadow's form must be unlocked to enter Babel Tower, as well as face Dark Gaia.
  - If you bring the Necklace back to Lilly in Itory Village, she will accompany you.  This will allow you to progress to the end of Edward's Underground Tunnel, as well as access the item locked in the coffin in the Seaside Palace.
  - A number of new items have been added to the game to simulate ability upgrades. These jewels appear as circles of flame in your inventory and, when used, upgrade the appropriate ability -- either your HP, STR, DEF, Psycho Dash, or Dark Friar abilities. Items representing multiple Red Jewels are handled similarly and must be used -- talking to the Jeweler will not remove these items from your inventory.
  - Any barrier that can be removed with the Psycho Dash can also be destroyed with either the Psycho Slider or the Spin Dash.
  - The Dark Spaces in both Edward's Prison and Babel Tower have been relocated to prevent softlocks.
  - The spirits in Babel Tower can warp you back to the bottom of the tower, allowing you to escape if you cannot defeat one of the bosses.
  - You can talk to the NPC in front of the school in South Cape for an in-game tutorial.


  With only sixteen slots available for items, inventory management is a significant meta aspect of this randomizer.  Below are some tips to help you manage your inventory space.  Logic will never grant you access to more key items than you can carry and/or get rid of.

  - The following items can be used immediately upon acquisition, upon which they disappear: Red Jewels (including "2 Red Jewels" and "3 Red Jewels"), herbs, Lola's Letter, Black Glasses, and Crystal Ring

  - The following items can be removed from inventory at any time: herbs, Lance's Letter, Rama Statues (if Mystic Statue 3 is not required), and Father's Journal/Hieroglyphs (if Mystic Statue 5 is not required)

  - If you have access to the Pyramid, you can drop off any Hieroglyphs in the slots even if you don't have Father's Journal.  You can gain back placed hieroglyphs either by swapping them with a different hieroglyph from you inventory, or by filling in the slots completely in the wrong order.



  In Completable logic, some Dark Spaces will always be reserved for form changes and thus need not be checked when searching for abilities.  These include:
  - The Dark Space in the Underground Tunnel (just before the bridge)
  - The first Dark Space in Inca Ruins (just before the Singing Statue)
  - The first Dark Space in Mu (just to the left of where you access the second level)
  - The second Dark Space in Great Wall (vanilla Spin Dash location, with the multiple platforms)
  - The Dark Space in the Garden in Ankor Wat
  - Both Dark Spaces in the Pyramid


  - **Sky Garden:** The Dark Space in the SW room does not in fact require Dark Friar to access. You can stand below the switch as Freedan and reach it easily with his sword. Also, you can use Aura Barrier to complete the NW room instead of Dark Friar.
  - **Great Wall:** The Dark Space in the third room might have an ability, and you can reach it without Spin Dash by turning into Freedan or Shadow in the fourth room, walking back, and using the longer reach of one of these characters to hit the switch that allows entrance into that map.
  - **Ankor Wat:** The Gorgon that blocks the way (for which you are intended to use the Earthquaker) can be easily defeated if you have Dark Friar, 2nd upgrade, by standing on the platform and spamming him with fireballs before he blocks the passage.
  - **Ankor Wat:** To get to the Dark Space with vanilla Earthquaker, you are intended to have Dark Friar to defeat the Frenzy that moves along the wall across the gap.  However, if you have Shadow unlocked, his attack has enough reach to defeat this enemy, so this may be the intended way to access that Dark Space in a randomized seed.
  - **Pyramid:** Room 3 (the "killer 6" room) can be done with Fredan if you have Dark Friar.  Some might find this form to be helpful to survive in this area, especially if you have upgraded Dark Friar and/or Aura Barrier.  Similarly, Room 5 can be completed with Freedan if you have the Earthquaker ability by using that ability from the various platforms in this area.  (Tiles will fall from the ceiling, allowing you to progress.)

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#contents">Return to Top</a>


  The offical <a href="https://emotracker.net/download/">IoGR EmoTracker</a> is available for download. Furthermore, you can access a beta version of the autotracker by joining the <a href="https://discord.gg/KfZ4VeD">Discord</a> and referring to the #tracker channel.


  - Custom seeds
  - More text edits


  If you have an issue with the randomizer, please join our
  <a href="https://discord.gg/KfZ4VeD">Discord</a> and report your issue in the #bugs channel.

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#contents">Return to Top</a>



  Talk to Gaia in the Dark Space.  After saving, you'll be prompted if you want to return to start.  (This works for any Dark Space, by the way.)


  Go outside and stand in the top-left tile of the little island.  The Four-Way on the left can kill you and warp you to the start of the dungeon.


  If you're playing Completable or Beatable logic (without glitches allowed), certain Dark Spaces will always be reserved for form changes and will never have abilities in them. (Though enabling glitches or choosing Chaos logic breaks this restriction.) You can skip checking these:
  - **Underground Tunnel:** The DS behind Lily's room will never have an ability
  - **Inca Ruins:** The DS north of the singing statue will never have an ability
  - **Diamond Mine:** If one of the Dark Spaces (not counting the one behind the false wall) has an ability, the other one is guaranteed not to have one
  - **Sky Garden:** between the Dark Spaces in the SE and NW rooms, one of them is guaranteed not to have an ability
  - **Mu:** the Dark Space to the west of the row of spikes will never have an ability
  - **Great Wall:** The DS you fall down to access (vanilla Spin Dash) will never have an ability
  - **Ankor Wat:** The DS in the garden will never have an ability
  - **Pyramid:** Neither DS will ever have an ability


  No.  Anything you would need Psycho Dash for can be done with either Slider or Spin.


  It could be virtually anywhere, I'm afraid.  However, you may not need it:
  - The ramp at the end of Diamond Mine can be scaled with Spin Dash
  - The Dark Space in SW Sky Garden can be accessed with Freedan's sword alone
  - The two chests in NW Sky Garden can be accessed with Aura Barrier
  - In Ankor Wat, you can use Shadow's basic attack to access the Dark Space where Earthquaker normally is


  Sort of.  If you happen to have Aura Barrier but not Dark Friar, you can access the two chests in NW Sky Garden.  If you have Earthquaker and don't have Dark Friar with both upgrades, you can use it to progess past the spinning Gorgon in Ankor Wat.  Beyond that, they're largely useless.


  Yes. If you have one upgrade, the fireball explodes upon impact only.  With two upgrades, you can control when it explodes by hitting the attack button again.


  Not every room has a stat upgrade, only those with a pulsing "Force" icon on the map screen.


  Scaling down the range of enemy strength was necessary to make end-game enemies somewhat approachable with early-game stats; so reducing the number of upgrades available to the player accordingly was necessary to balance the game. Basically, there are less upgrades available, but each one is more significant than it was in the vanilla game.  For instance, each HP upgrade gives you +3 HP.


  No. In the vanilla game, there are a number of stat upgrades that are given through NPCs and other locations - namely, 1 DEF upgrade, 2 STR upgrades, and 3 HP upgrades.


  Inventory management is a big part of the game. You may be required to drop or use herbs to make space for key items, but the game will never give you access to more key items than you can carry or use. Try using key items, too, as some of them will disappear from your inventory and be "active" for the rest of the game (e.g. black glasses, crystal ring).  Also, keep in mind that you may be able to dump certain key items that only access bosses you don't need to fight (see below).


  Generally yes.  The Rama Statues can be discarded from inventory if Statue 3 is not required, and the Hieroglyph Tiles/journal can be discarded if Statue 5 is not required. The restrictions on which items can be discarded changes from seed to seed.  Basically, if you're given the option to discard a key item, it means you don't need it to complete the game.


  Yes. The NPC in front of the school in South Cape will keep you stocked with an infinite supply of tutorial journals, should you desire.


  For Dark Gaia seeds, you need to both acquire AND use the Aura, on top of freeing Kara and gathering the needed Mystic Statues.


  If you talk to Ishtar, the puzzle will reset and you can start again from the beginning.


  He's trying to give you an item, but your inventory's full. Make room and you can progress through that conversation.


  Due to graphical limitations, when Kara's portrait is in the Diamond Mine, we had to turn Sam into Samlet.


  That's what we named the NPC in the Seaside Palace who gives you an item after you purify the fountain.


  http://www.hrwiki.org/wiki/Nice_Try


  Over 50 at this point. Collect them all for a commemorative patch.


  The Crystal Ring is one of the items you need to pass the force field at the base of Babel Tower.  In early Firebird seeds, it also is one of the triggers that grants access to the Firebird attack.  The Black Glasses make it so you can see in the white room in Ankor Wat. It also allows you to know which stat upgrades are available in each room.




  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#contents">Return to Top</a>


  No one does a project like this for the money -- I love this game, wanted a randomizer to exist for it, and had a blast making one.  I neither need nor expect any compensation for my work -- I hope you enjoy it, no strings attached.  However, if you feel compelled to support me for this project (or if you'd like to see more game-modding from me), I humbly invite you to consider subscribing to
  <a href="https://www.twitch.tv/dontbagume">my channel on Twitch.</a>

  <a href="https://github.com/DontBaguMe/IoGR/blob/master/README.md#contents">Return to Top</a>


pkgId: 38f34b199e5c775180714c97f657a33d5c11cefd543cf3146fa5ab6db60df5e0
name: python-iop4-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for iop4
url: https://pypi.org/project/iop4/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iop4-1.4.0-1.src.rpm
location_href: Packages/python-iop4-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  <div>
  <a href="https://github.com/juanep97/iop4/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/juanep97/iop4/actions/workflows/ci.yml/badge.svg"></img></a>
  <a href="https://zenodo.org/doi/10.5281/zenodo.10222722"><img src="https://zenodo.org/badge/636786270.svg" alt="DOI"></img></a>
  <a href="https://pypi.org/project/iop4/"><img src="https://img.shields.io/pypi/v/iop4" alt="PyPI"></img></a>
  <a href="https://dx.doi.org/10.3847/1538-3881/ad5a80"><img src="https://img.shields.io/badge/Astronomical_Journal-Published-green" alt="Publication AJ"></a>
  </div>


  **IOP4** is a complete rewrite of IOP3, a pipeline to work with **photometry** and **polarimetry** of **optical data** from [CAHA](https://www.caha.es/es/) and [OSN](https://www.osn.iaa.csic.es/) observatories. It is built to ease debugging and inspection of data.

  IOP4 implements _Object Relational Mapping_ (**ORM**) to seamlessly integrate all information about the reduction and results in a database which can be used to query and plot results, flag data and inspect the reduction process in an integrated fashion with the whole pipeline. It also ships with an already **built-in web interface** which can be used out of the box to browse the database and supervise all pipeline processes.

  See details in [Juan Escudero Pedrosa et al 2024 AJ 168 84](https://dx.doi.org/10.3847/1538-3881/ad5a80).



  We recommend installing IOP4 in an isolated environment as described below. IOP4 is hosted in [PyPI software repository](https://pypi.org/project/iop4/).



  **Note:** IOP4 requires Python 3.11 or later. You can check your Python version with `python --version`. If you have a compatible version, you can skip this step.

  If you don't have Python 3.11 or later, you can install [pyenv](https://github.com/pyenv/pyenv) and [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv), which will manage python versions for you. You can use the automatic installer [pyenv-installer](https://github.com/pyenv/pyenv-installer):

  ```bash
      $ curl https://pyenv.run | bash
  ```

  Follow the instructions that this command outputs to add `pyenv` to `PATH` (or copy the commands from https://github.com/pyenv/pyenv for your shell). Restart your terminal, or source the file (e.g. `. ~/.bashrc` or `. ~/.zshrc`) Then, run
  ```bash
      $ pyenv install 3.11
      $ pyenv virtualenv 3.11 iop4-venv
      $ pyenv activate iop4-venv
  ```
  Now you will have a virtual environment with the right Python version, and you can continue with the next step. To deactivate, just run `pyenv deactivate`.

  With the environment activated, you can install IOP4 latest version by running:
  ```bash
      $ pip install iop4
  ```

  Alternatively, you can clone this repository and install IOP4:
  ```bash
      $ git clone 'git@github.com:juanep97/iop4.git'
      $ cd iop4
      $ pip install .
  ```
  or `pip install -e .` if you want to install it in developer mode.



  As the previous option, create and activate the environment as follows:
  ```bash
      $ conda create -n iop4 python=3.11
      $ conda activate iop4
  ```

  Then run:
  ```bash
      $ pip install iop4
  ```

  Alternatively, you can also clone this repository and run (inside the root directory of the cloned repository):
  ```bash
      $ pip install .
  ```
  or `pip install -e .` if you want to install it in developer mode.

  If you followed the steps in any of the two options above, you will have installed the module `iop4lib` and the `iop4` command, and the `iop4site` project.



  After installation, take a look at the example configuration file (`iop4lib/config.example.yaml`), set the appropriate variables (path to the database, data directory, astrometry index files path, credentials, etc) and save it to `~/.iop4.config.yaml`.


  To run the tests, first follow the previous steps to install IOP4 in developer mode and configure it. The test dataset will be automatically downloaded to your home directory
  ```bash
      $ pytest -vxs tests/
  ```
  If it is the first time executing IOP4, the astrometry index files will be downloaded to `astrometry_cache_path` (see `config.example.yaml`). This will take some time and a few tens of GB, depending on the exact version.

  **Warning**: in some macOS systems, the process [might hang up](https://github.com/juanep97/iop4/issues/14#issuecomment-1748465276). Execute `export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES` or add that line to your shell init script.



  If no previous database exists, make sure to create it. You can do it automatically from the `iop4site/` directory by using
  ```bash
      $ python manage.py makemigrations
      $ python manage.py migrate
  ```
  Then, create a user with
  ```bash
      $ python manage.py createsuperuser
  ```
  You can later use these credentials to login to the admin site, where you will need to add any sources of interest to the empty catalog.

  To manually back up all data from the DB, you can use
  ```bash
      $ python manage.py dumpdata --natural-primary --natural-foreign --format=yaml > priv.dumps.yaml
  ```
  This file can be used to reload the data to the DB with:
  ```bash
      $ python manage.py loaddata priv.dumps.yaml
  ```
  An utility script, `iop4site/resetdb.py`, is provided which will completely reset the DB keeping catalog and user's data.


  The pipeline script `iop4` can be invoked as
  ```bash
      $ iop4 --epoch-list tel1/yymmdd tel2/yymmdd
  ```
  to download and reduce the epoch `yymmdd` from telescopes `tel1` and `tel2` respectively. For example: `iop4 -l T090/230430`.

  To serve the results in Django debug server, change to the iop4site directory and run
  ```bash
      $ python manage.py runserver
  ```
  although this server is only recommended for debugging purposes, and you should use another server in production ([see Django documentation](https://docs.djangoproject.com/en/dev/ref/django-admin/#runserver)).


  **iop4lib** uses django ORM and it needs to be configured before using it. Therefore, you should do
  ```python
      import iop4lib
      iop4lib.Config(config_db=True)
  ```
  once at the start of your script. IOP4 configuration can be accessed anywhere without configuring the ORM doing `import iop4lib; iop4conf = iop4lib.Config(config_db=False)`.

  > This way of configuring `IOP4` should be also valid inside IPython Shell, but not for Jupyter notebooks, since their asynchronous output interferes with Django ORM. To use IOP4 inside a notebook, see below. More details can be found in the documentation for `iop4lib.Config`.

  Now you are ready to import and use IOP4 models from your Python script, e.g:
  ```python
      import iop4lib
      iop4lib.Config(config_db=True)
      from iop4lib.db import RawFit, ReducedFit, Epoch, PhotoPolResult

      
      print(Epoch.objects.filter(telescope="CAHA-T220").count())

      
      Epoch.objects.filter(telescope="CAHA-T220").last().reduce()
  ```


  You can use `IOP4` in an interactive manner inside a Jupyter notebook. The following lines also activate matplotlib's graphical output (deactivated by default, as some plots may be generated inside the server).
  ```python
  %autoawait off
  %load_ext autoreload
  %autoreload all

  import iop4lib.config
  iop4conf = iop4lib.Config(config_db=True, gonogui=False, jupytermode=True)
  ```


  You can get an IPython interactive terminal after running iop4 using the `-i` option. You can override any config option using the `-o` option, or by setting environment variables, e.g.
  ```bash
      $ IOP4_NTHREADS=20 iop4 -i -o log_file=test.log --epoch-list T090/230313 T090/230317
  ```
  Check `iop4 --help` for more info.


  To build and show the documentation, run
  ```bash
      $ make docs-sphinx
      $ make docs-show
  ```

  The documentation for the latest release is hosted in this repository's [GitHub Pages](https://juanep97.github.io/iop4/).



  You are welcome to contribute to IOP4. Fork and create a PR!



  If you use IOP4, or any result derived from it, we kindly ask you to cite the following references:

  <div>
  <a href="https://dx.doi.org/10.3847/1538-3881/ad5a80"><img src="https://img.shields.io/badge/Juan_Escudero_Pedrosa_et_al_2024-AJ_168_84-green" alt="DOI AJ"></img></a>

  <a href="https://zenodo.org/doi/10.5281/zenodo.10222722"><img src="https://zenodo.org/badge/636786270.svg" alt="DOI Zenodo"></img></a>
  </div>

  You can use the following BibTeX entries:

  ```bibtex
  @article{iop4_AJ,
    doi = {10.3847/1538-3881/ad5a80},
    url = {https://dx.doi.org/10.3847/1538-3881/ad5a80},
    year = {2024},
    month = {jul},
    publisher = {The American Astronomical Society},
    volume = {168},
    number = {2},
    pages = {84},
    author = {{Escudero Pedrosa}, Juan and {Agudo}, Ivan and {Morcuende}, Daniel and {Otero-Santos}, Jorge and {Bonnoli}, Giacomo and {Piirola}, Vilppu and {Husillos}, C{\'e}sar and {Bernardos}, Mabel and {L{\'o}pez-Coto}, Rub{\'e}n and {Sota}, Alfredo and {Casanova}, V{\'\i}ctor and {Aceituno}, Francisco and {Santos-Sanz}, Pablo},
    title = {IOP4, the Interactive Optical Photo-Polarimetric Python Pipeline},
    journal = {The Astronomical Journal},
  }

  @software{iop4_zenodo,
    author       = {{Escudero Pedrosa}, Juan and
                    {Morcuende Parrilla}, Daniel and
                    Otero-Santos, Jorge},
    title        = {IOP4},
    year         = 2024,
    publisher    = {Zenodo},
    doi          = {10.5281/zenodo.10222722},
    url          = {https://zenodo.org/doi/10.5281/zenodo.10222722}
  }
  ```


pkgId: 86f3828887b5241ce20ab277cbe2e250523e3e207e2fbf8cc95bf6b82d706784
name: python-ioxplugin-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for ioxplugin
url: https://github.com/universaldevices/ioxplugin.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ioxplugin-1.5.1-1.src.rpm
location_href: Packages/python-ioxplugin-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  ioxplugin is a python package that helps you create plugin code from simple JSON.

  Use pip to install:

  ```bash
  pip install ioxplugin


pkgId: 85cbb8b04cd6f1024b7fca53e082872768f26aa0d4e1732c49172100f85e9478
name: python-ip-geo-locator-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for ip-geo-locator
url: https://github.com/Three-mavericks/ip_finder_python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ip-geo-locator-0.1.1-1.src.rpm
location_href: Packages/python-ip-geo-locator-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python wrapper for an IP API service that fetches IP information using a given IP address and an API key.



  To install the package locally:

  ```bash
  pip install .


pkgId: 41d8166544b1044112c09f080b28b42775e8d828c12318dd79eeffe4a1d0b193
name: python-ipalab-config-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for ipalab-config
url: https://pypi.org/project/ipalab-config/
rpm_license: 0BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipalab-config-0.4.0-1.src.rpm
location_href: Packages/python-ipalab-config-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  The goal of this project is to provide a tool to create the necessary configuration to experiment with [FreeIPA](https://freeipa.org) and [ansible-freeipa](https://github.com/freeipa/ansible-freeipa) using containers.
  The tool `ipalab-config` generates the necessary files to create a compose of containers (using, for example, `podman compose`) and deploy FreeIPA on it using the ansible-freeipa collection.


pkgId: 636f22cdcde541d204081bcc7b0001a675cb745e8095a4db93a63468dd2a4526
name: python-iparapheur-internal-help
arch: noarch
version: 1.15.1
epoch: 0
release: 1
summary: Development documents and examples for iparapheur-internal
url: https://pypi.org/project/iparapheur-internal/
rpm_license: Affero GPL 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iparapheur-internal-1.15.1-1.src.rpm
location_href: Packages/python-iparapheur-internal-help-1.15.1-1.noarch.rpm
checksum_type: sha256
description:
      iparapheur v5.x main core application.  The main link between every sub-services, integrating business code logic.


pkgId: 40f471334ba98f8b946fba1ef548c6babaabf1116f5f65956082f7fee26fcfdf
name: python-ipfabric-help
arch: noarch
version: 6.10.7
epoch: 0
release: 1
summary: Development documents and examples for ipfabric
url: https://gitlab.com/ip-fabric/integrations/python-ipfabric
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfabric-6.10.7-1.src.rpm
location_href: Packages/python-ipfabric-help-6.10.7-1.noarch.rpm
checksum_type: sha256
description:
  IPFabric is a Python module for connecting to and communicating against an IP Fabric instance.

  ***For full documentation please see [IP Fabric Documentation Portal](https://docs.ipfabric.io/main/integrations/python/).***



  [IP Fabric](https://ipfabric.io) is a vendor-neutral network assurance platform that automates the
  holistic discovery, verification, visualization, and documentation of
  large-scale enterprise networks, reducing the associated costs and required
  resources whilst improving security and efficiency.

  It supports your engineering and operations teams, underpinning migration and
  transformation projects. IP Fabric will revolutionize how you approach network
  visibility and assurance, security assurance, automation, multi-cloud
  networking, and trouble resolution.

  **Integrations or scripts should not be installed directly on the IP Fabric VM unless directly communicated from the
  IP Fabric Support or Solution Architect teams.  Any action on the Command-Line Interface (CLI) using the root, osadmin,
  or autoboss account may cause irreversible, detrimental changes to the product and can render the system unusable.**



  **IP Fabric 6.10 will be the last release before 7.0.**  Major Releases will have breaking changes that will need to be
  tested including in the SDK.  Please be prepared for this prior to upgrading your IP Fabric instance to 7.0.



  A bug has been identified when ~2,000 requests are being made to the API.  The underlining issue seems to be with the
  implementation of `http2`. The workaround is to set `http2=False` in the `IPFClient` class.  Example error:

  `httpx.RemoteProtocolError: <ConnectionTerminated error_code:ErrorCodes.NO_ERROR, last_stream_id:1999, additional_data:None>`



  In `ipfabric>=v6.9.0` the following was changed/deprecated:

  - `IPFDiagram` will be removed as it is now located in `IPFClient().diagram`, the following will be changed:
    - `IPFDiagram().diagram_model()` -> `IPFClient().diagram.model()`
    - `IPFDiagram().diagram_json()` -> `IPFClient().diagram.json()`
    - `IPFDiagram().diagram_svg()` -> `IPFClient().diagram.svg()`
    -`IPFDiagram().diagram_png()` -> `IPFClient().diagram.png()`
  - Methods found in `ipfabric.models.Snapshot` class will no longer accept the `IPFClient` argument being passed.
    - Example: `ipf.snapshot.lock(ipf)` -> `ipf.snapshot.lock()`

  **In `ipfabric>=v7.1.x` Python 3.8 will be removed as a supported version as it is now
  [End of Life](https://devguide.python.org/versions/) as of 2024-10-07.**

  In `ipfabric>=v7.0.x` (Next Release after 6.10) the following will be changed/deprecated:

  - All classes including `IPFClient()` will switch to keyword only arguments to support Pydantic BaseModel.
    - `IPFClient('https//url')` -> `IPFClient(base_url='https//url')`
  - `IPFClient().intent.intent_by_name()` will be removed and is replaced by `IPFClient().intent.intents_by_name()`
  - The following endpoints were moved and the old methods will be removed:
    - `Technology.LoadBalancing.virtual_servers_f5_partitions` -> `Technology.LoadBalancing.partitions`
    - `Technology.Sdwan.sites` -> `Technology.Sdwan.versa_sites`
    - `Technology.Sdwan.links` -> `Technology.Sdwan.versa_links`



  Semantic Versioning: `Major.Minor.Patch`

  Starting with IP Fabric version 5.0.x the `ipfabric` SDK is recommended to match your IP Fabric major and minor version.
  We will try to keep some backwards compatability (SDK version `6.9.x` should work with IP Fabric API `6.8`) however new
  features may break some functionality.  By ensuring that your `ipfabric` SDK's match your IP Fabric major and minor
  version will ensure compatibility and will continue to work.

  The Patch version of the SDK is used for bug fixes and new features that are compatible with the major and minor version.



  See [Notices](NOTICES.md) for full information.

  * GET URL is limited to 4096 characters.
    * Complex queries and filters could go over this limit; however in testing it was very difficult to reach this.
  * CSV Export
    * Only supported with a streaming GET request and return a bytes string of data in the Python SDK.
    * It will also convert times to human-readable format.
    * **`reports` (returning Intent Check data) is not supported with CSV export, however is required when filtering based on Intents (colors).**

  ```python
  from ipfabric import IPFClient
  ipf = IPFClient(streaming=True)

  dev = ipf.inventory.devices.all()
  print(type(dev))  # list

  dev_csv = ipf.fetch_all('tables/inventory/devices', export='csv')
  print(type(dev_csv))  # bytes


  dev_csv_tz = ipf.inventory.devices.all(export='csv', csv_tz='UTC')


  dev_csv_reports = ipf.fetch_all('tables/inventory/devices', reports=True, export='csv')
  """CSV export does not return reports, parameter has been excluded."""
  print(type(dev_csv_reports))  # bytes



  ```



  ```
  pip install ipfabric
  ```

  To use `export='df'` on some methods please install `pandas` with `ipfabric`

  ```
  pip install ipfabric[pd]
  ```



  Please take a look at [API Programmability - Part 1: The Basics](https://ipfabric.io/blog/api-programmability-part-1/)
  for instructions on creating an API token.

  Most of the methods and features can be located in [Examples](examples) to show how to use this package.
  Another great introduction to this package can be found at [API Programmability - Part 2: Python](https://ipfabric.io/blog/api-programmability-python/)





  Supply in client:
  ```python
  from ipfabric import IPFClient
  ipf = IPFClient('https://demo3.ipfabric.io/', auth=('user', 'pass'))
  ```



  ```python
  from ipfabric import IPFClient
  ipf = IPFClient('https://demo3.ipfabric.io/', auth='token')
  ```



  The easiest way to use this package is with a `.env` file.  You can copy the sample and edit it with your environment variables.

  ```commandline
  cp sample.env .env
  ```

  This contains the following variables which can also be set as environment variables instead of a .env file.
  ```
  IPF_URL="https://demo3.ipfabric.io"
  IPF_TOKEN=TOKEN
  IPF_VERIFY=true
  ```

  Or if using Username/Password:
  ```
  IPF_URL="https://demo3.ipfabric.io"
  IPF_USERNAME=USER
  IPF_PASSWORD=PASS
  ```





  IPFabric uses [Poetry](https://pypi.org/project/poetry/) to make setting up a virtual environment with all dependencies
  installed quick and easy.

  Install poetry globally:
  ```
  pip install poetry
  ```

  To install a virtual environment run the following command in the root of this directory.

  ```
  poetry install
  ```

  To run examples, install extras:
  ```
  poetry install ipfabric -E examples
  ```



  ```
  poetry run pytest
  poetry build
  ```

  Prior to pushing changes run:
  ```
  poetry run black ipfabric
  poetry update
  ```


pkgId: e62e00290e5d155d8eccc8ef25c09bfbf077fc7d5d86d544f95bf08a0c2e5999
name: python-ipfabric-infoblox-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for ipfabric-infoblox
url: https://gitlab.com/ip-fabric/integrations/ipfabric-infoblox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfabric-infoblox-0.0.2-1.src.rpm
location_href: Packages/python-ipfabric-infoblox-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  networkViews:
    - name: default
      default: true
      managed_ip_discovery: true
      
      
  ipfabric:
    vrf_mapping:
      '':
        names:
          - default
          - main
          - ''
  ```
  2. Ensure credentials are set in the environment:
  ```bash
  IPF_TOKEN=
  IPF_URL=https://<url>/
  IB_USERNAME=
  IB_PASSWORD=
  IB_HOST=
  IB_VERIFY_SSL=false
  ```

  1. Run a diff against the current state of the network:
  ```bash
  ipfabric-infoblox diff
  ```
  2. Apply the changes to the Infoblox:
  ```bash
  ipfabric-infoblox sync
  ```

  Please open a Gitlab Issue for support.


pkgId: 603addd1cfd812d76d4182eae5dd6b942aae7bf66a0657b1739194e53051b1c6
name: python-ipfabric_netbox-help
arch: noarch
version: 3.1.2
epoch: 0
release: 1
summary: Development documents and examples for ipfabric_netbox
url: https://gitlab.com/ip-fabric/integrations/ipfabric-netbox-sync
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfabric_netbox-3.1.2-1.src.rpm
location_href: Packages/python-ipfabric_netbox-help-3.1.2-1.noarch.rpm
checksum_type: sha256
description:
  IP Fabric is a vendor-neutral network assurance platform that automates the
  holistic discovery, verification, visualization, and documentation of
  large-scale enterprise networks, reducing the associated costs and required
  resources whilst improving security and efficiency.

  It supports your engineering and operations teams, underpinning migration and
  transformation projects. IP Fabric will revolutionize how you approach network
  visibility and assurance, security assurance, automation, multi-cloud
  networking, and trouble resolution.

  **Integrations or scripts should not be installed directly on the IP Fabric VM unless directly communicated from the
  IP Fabric Support or Solution Architect teams.  Any action on the Command-Line Interface (CLI) using the root, osadmin,
  or autoboss account may cause irreversible, detrimental changes to the product and can render the system unusable.**



  This plugin allows the integration and data synchronization between IP Fabric and NetBox.

  The plugin uses IP Fabric collect network data utilizing the [IP Fabric Python SDK](https://gitlab.com/ip-fabric/integrations/python-ipfabric). This plugin relies on helpful features in NetBox like [Staged Changes](https://netboxlabs.com/docs/netbox/en/stable/plugins/development/staged-changes/) and [Background Tasks](https://netboxlabs.com/docs/netbox/en/stable/plugins/development/background-tasks/) to make the job of bringing in data to NetBox easier.

  - Multiple IP Fabric Sources
  - Transform Maps
  - Scheduled Synchronization
  - Diff Visualization



  | Netbox Version | Plugin Version |
  | -------------- | -------------- |
  | 3.4            | <=1.0.11       |
  | 3.5            | <=1.0.11       |
  | 3.6            | <=1.0.11       |
  | 3.7            | >=2.0.0        |
  | 4.0            | >=3.0.0        |
  | 4.0.1          | >=3.0.1        |
  | 4.1.0          | >=3.1.0        |
  | 4.1.5          | >=3.1.1        |



  ![Source](docs/images/user_guide/source_sync.png)

  ![Snapshots](docs/images/user_guide/snapshot_detail.png)

  ![Transform Maps](docs/images/user_guide/tm_edit_hostname.png)

  ![Ingesion](docs/images/user_guide/ingestion_detail.png)

  ![Diff](docs/images/user_guide/branch_changes_update_diff.png)



  Full documentation for this plugin can be found at [IP Fabric Docs](https://docs.ipfabric.io/main/integrations/netbox/).

  - User Guide
  - Administrator Guide



  If you would like to contribute to this plugin, please see the [CONTRIBUTING.md](CONTRIBUTING.md) file.


pkgId: 03ebf47d7d7b035ac6fa9bb6da190b871e871f22c2c0ecc94adac6f3a07566ac
name: python-ipfs-accelerate-py-help
arch: noarch
version: 0.0.42
epoch: 0
release: 1
summary: Development documents and examples for ipfs-accelerate-py
url: https://github.com/endomorphosis/ipfs_accelerate_py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfs-accelerate-py-0.0.42-1.src.rpm
location_href: Packages/python-ipfs-accelerate-py-help-0.0.42-1.noarch.rpm
checksum_type: sha256
description:
  This is meant to be an extension of the Huggingface accelerate library, is to act as a model server, which can contain lists of other endpoints to call, or can call a local instance, and can respond to external calls for inference. I have some modular back ends, such as Libp2p, Akash, Lilypad, Huggingface Zero, Vast AI, which I use for autoscaling. If the model is already listed in the ipfs_model_manager there should be an associated hw_requirements key of the manifest. In the case of libp2p the request to do inference will go out to peers in the same trusted zone, if there are no peers in the network available to fulfill the task, and it has the resources to run the model localliy it will do so, otherwise a docker container will need to be launched with one of the providers here.



  run.sh -- this will run the model server

  init.sh -- this will initialize the endpoints and models that you want to use

  queue.sh -- this will add an item to the model queue, and the endpoints will pull items from their model queue.

  infer.sh -- this will select a random endpoint for the requested model to perform inference.



  ```
  from ipfs_accelerate_py import ipfs_accelerate_py
  model_server = ipfs_accelerate_py()
  init_model_server = model_server.init_endpoints(models, endpoints)
  endpoints = model_server.resources["endpoint_handler"][model[0]]
  for endpoint in list(endpoints.keys()):
      endpoint("hello world")
  ```


  You can spin up additional model endpoints with the following:











  for huggingface transformers python library visit:
  https://github.com/endomorphosis/ipfs_transformers/

  for huggingface datasets python library visit:
  https://github.com/endomorphosis/ipfs_datasets/

  for faiss KNN index python library visit:
  https://github.com/endomorphosis/ipfs_faiss

  for transformers.js visit:
  https://github.com/endomorphosis/ipfs_transformers_js

  for orbitdb_kit nodejs library visit:
  https://github.com/endomorphosis/orbitdb_kit/

  for fireproof_kit nodejs library visit:
  https://github.com/endomorphosis/fireproof_kit

  for ipfs_kit nodejs library visit:
  https://github.com/endomorphosis/ipfs_kit/

  for python model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager/

  for nodejs model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager_js/

  for nodejs ipfs huggingface scraper with pinning services visit:
  https://github.com/endomorphosis/ipfs_huggingface_scraper/

  for ipfs agents visit:
  https://github.com/endomorphosis/ipfs_agents/

  for ipfs accelerate visit:
  https://github.com/endomorphosis/ipfs_accelerate/

  Author - Benjamin Barber
  QA - Kevin De Haan


pkgId: 4eea7b7d150c5b1f5c3fa6308cec4beff2835232ebd9d181a9448f735d97bee2
name: python-ipfs-datasets-py-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for ipfs-datasets-py
url: https://github.com/endomorphosis/ipfs_datasets_py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfs-datasets-py-0.0.10-1.src.rpm
location_href: Packages/python-ipfs-datasets-py-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  This is a model manager and wrapper for huggingface, looks up a index of models from an collection of models, and will download a model from either https/s3/ipfs, depending on which source is the fastest.


  ~~~shell
  pip install .
  ~~~

  look run ``python3 example.py`` for examples of usage.

  this is designed to be a drop in replacement, which requires only 2 lines to be changed

  In your python script
  ~~~shell
  from datasets import load_dataset
  from ipfs_datasets import load_dataset
  dataset = load_dataset.from_auto_download("bge-small-en-v1.5")
  ~~~

  or

  ~~~shell
  from datasets import load_dataset
  from ipfs_datasets import load_dataset
  dataset = load_dataset.from_ipfs("QmccfbkWLYs9K3yucc6b3eSt8s8fKcyRRt24e3CDaeRhM1")
  ~~~

  or to use with with s3 caching
  ~~~shell
  from datasets import load_dataset
  from ipfs_datasets import load_dataset
  dataset = load_dataset.from_auto_download(
      dataset_name="common-crawl",
      s3cfg={
          "bucket": "cloud",
          "endpoint": "https://storage.googleapis.com",
          "secret_key": "",
          "access_key": ""
      }
  )
  ~~~



  for transformers python library visit:
  https://github.com/endomorphosis/ipfs_transformers/

  for transformers js client visit:
  https://github.com/endomorphosis/ipfs_transformers_js/

  for orbitdb_kit nodejs library visit:
  https://github.com/endomorphosis/orbitdb_kit/

  for fireproof_kit nodejs library visit:
  https://github.com/endomorphosis/fireproof_kit

  for Faiss KNN index python library visit:
  https://github.com/endomorphosis/ipfs_faiss/

  for python model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager/

  for nodejs model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager_js/

  for nodejs ipfs huggingface scraper with pinning services visit:
  https://github.com/endomorphosis/ipfs_huggingface_scraper/


  Author - Benjamin Barber
  QA - Kevin De Haan


pkgId: 24259ff7e7167ab47758005dd64d066ddf52f908ac1d952ad2d914f2ee671c01
name: python-ipfs-faiss-py-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for ipfs-faiss-py
url: https://github.com/endomorphosis/ipfs_faiss_py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfs-faiss-py-0.0.6-1.src.rpm
location_href: Packages/python-ipfs-faiss-py-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  This is a model manager and wrapper for huggingface, looks up a index of models from an collection of models, and will download a model from either https/s3/ipfs, depending on which source is the fastest.


  ~~~shell
  pip install .
  ~~~

  look run ``python3 example.py`` for examples of usage.

  this is designed to be a drop in replacement, which requires only 2 lines to be changed

  In your python script
  ~~~shell
  import datasets
  from datasets import load_dataset
  from datasets import FaissIndex
  from transformers import AutoModel
  from ipfs_transformers import AutoModel
  from datasets import load_dataset
  from ipfs_datasets import ipfs_load_dataset
  from ipfs_datasets import auto_download_dataset
  from ipfs_faiss import IpfsFaissDataset

  model = AutoModel.from_auto_download("bge-small-en-v1.5")
  dataset = auto_download_dataset('Caselaw_Access_Project_JSON')
  knnindex = auto_download_faiss_index('Caselaw_Access_Project_FAISS_index')
  index = FaissIndex(dimension=512)
  embeddings = dataset['embeddings']
  query = "What is the capital of France?"
  query_vector = model.encode(query)
  scores, neighbors = index.search(query_vectors, k=10)
  ~~~

  or

  ~~~shell
  import datasets
  from datasets import load_dataset
  from datasets import FaissIndex
  from transformers import AutoModel
  from ipfs_transformers import AutoModel
  from datasets import load_dataset
  from ipfs_datasets import ipfs_load_dataset
  from ipfs_datasets import auto_download_dataset
  from ipfs_faiss import IpfsFaissDataset

  model = AutoModel.from_ipfs("QmccfbkWLYs9K3yucc6b3eSt8s8fKcyRRt24e3CDaeRhM1")
  dataset = ipfs_download_dataset('QmccfbkWLYs9K3yucc6b3eSt8s8fKcyRRt24e3CDaeRhM1')
  knnindex = ipfs_download_faiss_index('QmccfbkWLYs9K3yucc6b3eSt8s8fKcyRRt24e3CDaeRhM1')
  index = FaissIndex(dimension=512)
  embeddings = dataset['embeddings']
  query = "What is the capital of France?"
  query_vector = model.encode(query)
  scores, neighbors = index.search(query_vectors, k=10)
  ~~~

  or to use with with s3 caching
  ~~~shell
  import datasets
  from datasets import load_dataset
  from datasets import FaissIndex
  from transformers import AutoModel
  from ipfs_transformers import AutoModel
  from datasets import load_dataset
  from ipfs_datasets import ipfs_load_dataset
  from ipfs_datasets import auto_download_dataset
  from ipfs_faiss import IpfsFaissDataset
  s3cfg = {
          "bucket": "cloud",
          "endpoint": "https://storage.googleapis.com",
          "secret_key": "",
          "access_key": ""
      }

  model = AutoModel.from_auto_download(
      "bge-small-en-v1.5",
      s3cfg=s3cfg
  )
  dataset = load_dataset.from_auto_download(
      dataset_name="Caselaw_Access_Project_JSON",
      s3cfg=s3cfg
  )
  knnindex = ipfs_download_faiss_index.from_auto_download(
      dataset_name="Caselaw_Access_Project_FAISS_index",
      s3cfg=s3cfg
  )
  index = FaissIndex(dimension=512)
  embeddings = dataset['embeddings']
  query = "What is the capital of France?"
  query_vector = model.encode(query)
  scores, neighbors = index.search(query_vectors, k=10)

  ~~~

  The following JSON files have been uploaded to web3storage
  https://huggingface.co/datasets/endomorphosis/Caselaw_Access_Project_JSON
  or use this pin syncer notice the pins located in pin_store

  ~~~shell

  python3 upload_pins.py

  ~~~

  will upload them to web3storage, pinata, filebase, and lighthouse storage
  and there will instear be a web3storage_pins.tsv file with the new pins to import into datasets
  ... but only web3stoage is working right now.



  for huggingface datasets python library visit:
  https://github.com/endomorphosis/ipfs_datasets/

  for transformers python library visit:
  https://github.com/endomorphosis/ipfs_transformers/

  for transformers js client visit:
  https://github.com/endomorphosis/ipfs_transformers_js/

  for orbitdbkit nodejs library visit:
  https://github.com/endomorphosis/orbitdb_kit/

  for fireproof_kit nodejs library visit:
  https://github.com/endomorphosis/fireproof_kit

  for python model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager/

  for nodejs model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager_js/

  for nodejs ipfs huggingface scraper with pinning services visit:
  https://github.com/endomorphosis/ipfs_huggingface_scraper/


  Author - Benjamin Barber
  QA - Kevin De Haan


pkgId: 9d151d9fa10a59fd80eb16b73d643f28dc89028050ed4f109b7797550bfaa184
name: python-ipfs-kit-py-help
arch: noarch
version: 0.0.18
epoch: 0
release: 1
summary: Development documents and examples for ipfs-kit-py
url: https://github.com/endomorphosis/ipfs_kit_py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipfs-kit-py-0.0.18-1.src.rpm
location_href: Packages/python-ipfs-kit-py-help-0.0.18-1.noarch.rpm
checksum_type: sha256
description:
  This is a python library that installs and configures ipfs services through Kubo, ipfs_cluster_service based on the contents in the config file, for example whether the node is supposed to operate as a master, worker, or leecher, and allows ipfs cids to be reached through storacha (previously web3storage) if they are not in the cluster already.




  for huggingface transformers python library visit:
  https://github.com/endomorphosis/ipfs_transformers/

  for huggingface datasets python library visit:
  https://github.com/endomorphosis/ipfs_datasets/

  for faiss KNN index python library visit:
  https://github.com/endomorphosis/ipfs_faiss

  for transformers.js visit:
  https://github.com/endomorphosis/ipfs_transformers_js

  for orbitdb_kit nodejs library visit:
  https://github.com/endomorphosis/orbitdb_kit/

  for ipfs_kit python library visit:
  https://github.com/endomorphosis/ipfs_kit/

  for ipfs_kit nodejs library visit:
  https://github.com/endomorphosis/ipfs_kit_js/

  for python model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager/

  for nodejs model manager library visit:
  https://github.com/endomorphosis/ipfs_model_manager_js/

  for nodejs ipfs huggingface scraper with pinning services visit:
  https://github.com/endomorphosis/ipfs_huggingface_scraper/

  for ipfs agents visit:
  https://github.com/endomorphosis/ipfs_agents/

  for ipfs accelerate visit:
  https://github.com/endomorphosis/ipfs_accelerate/

  Author - Benjamin Barber
  QA - Kevin De Haan


pkgId: b8f69945744d913a9aeb5a590e9173f673319a43844ec3eb02f1297574880a91
name: python-iplens-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for iplens
url: https://github.com/aiomorphic/iplens
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iplens-0.1.7-1.src.rpm
location_href: Packages/python-iplens-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  A  lightweight CLI tool designed for fetching and displaying detailed IP address information. **No API keys are required**, making it accessible and easy to use for various use cases.

  ![IP Lens CLI Tool Screenshot](https://i.ibb.co/0DdXPtt/ksnip-20240812-020344.png)






  You can install the IP Lens CLI tool directly from PyPI:

  ```bash
  pip install iplens
  ```



  To build and install the tool from source:

  Clone the repository:

  ```bash
  git clone https://github.com/aiomorphic/iplens.git
  cd iplens
  pip install -e .
  ```





  Basic usage:

  ```bash
  iplens 8.8.8.8 1.1.1.1
  ```

  Using an input file:

  ```bash
  iplens --input-file ips.txt
  ```

  The input **file** can be in one of the following formats:

  - Plain text file with one IP address per line
  - Text file containing a Python list of IP addresses
  - JSON file with a list of IP addresses or a dictionary containing a list of IP addresses in any field
  - CSV file with a column containing IP addresses (the column name should include "ip", case-insensitive)
  - Log file containing IP addresses (the tool will extract unique IP addresses from the log)

  Using an Input **Folder** to Parse Files for IP Addresses:

  You can also specify a directory, and the tool will parse all non-binary files within that folder to extract IP addresses:

  ```bash
  iplens --input-folder /path/to/logs/
  ```

  Use Cases:

  Scan system logs: For example, to scan the UFW log for IP addresses, you can run:

  ```bash
  iplens --input-folder /var/log/ufw.log
  ```

  or for e.g. analyze web server logs: Parse your web server logs to gather and analyze IP addresses.

  Save output to a file:

  ```bash
  iplens 8.8.8.8 1.1.1.1 --output results --format json
  ```

  Available options:

  - `--input-file` or `-i`: Specify an input file containing IP addresses
  - `--input-folder` or `-d`: Specify an input folder containing files to parse for IP addresses
  - `--output` or `-o`: Specify output file (without extension)
  - `--format` or `-f`: Specify output format (csv or json)

  Note: The tool will automatically detect the input file format and extract valid IP addresses. Invalid IP addresses will be ignored.



  ```json
  [
    {
      "ip": "8.8.8.8",
      "rir": "ARIN",
      "is_bogon": "False",
      "is_datacenter": "True",
      "is_tor": "False",
      "is_proxy": "False",
      "is_vpn": "True",
      "is_abuser": "True",
      "company_name": "Google LLC",
      "company_abuser_score": "0.0039 (Low)",
      "company_type": "business",
      "company_domain": "google.com",
      "company_network": "8.8.8.0 - 8.8.8.255",
      "company_whois": "https://api.incolumitas.com/?whois=8.8.8.0",
      "abuse_email": "network-abuse@google.com",
      "asn_asn": "AS15169",
      "asn_abuser_score": "0 (Very Low)",
      "asn_route": "8.8.8.0/24",
      "asn_descr": "GOOGLE, US",
      "asn_country": "us",
      "asn_active": "True",
      "asn_org": "Google LLC",
      "asn_domain": "google.com",
      "asn_abuse": "network-abuse@google.com",
      "asn_type": "business",
      "asn_created": "2000-03-30",
      "asn_updated": "2012-02-24",
      "asn_rir": "ARIN",
      "asn_whois": "https://api.incolumitas.com/?whois=AS15169",
      "location_country": "United States",
      "location_country_code": "US",
      "location_state": "California",
      "location_city": "Sunnyvale",
      "location_latitude": "37.36883",
      "location_longitude": "-122.03635",
      "location_zip": "95196",
      "location_timezone": "America/Los_Angeles"
    }
  ]
  ```

  ```csv
  ip,rir,is_bogon,is_datacenter,is_tor,is_proxy,is_vpn,is_abuser,company_name,company_abuser_score,company_type,company_domain,company_network,company_whois,abuse_email,asn_asn,asn_abuser_score,asn_route,asn_descr,asn_country,asn_active,asn_org,asn_domain,asn_abuse,asn_type,asn_created,asn_updated,asn_rir,asn_whois,location_country,location_country_code,location_state,location_city,location_latitude,location_longitude,location_zip,location_timezone
  8.8.8.8,ARIN,False,True,False,False,True,True,Google LLC,0.0039 (Low),business,google.com,8.8.8.0 - 8.8.8.255,https://api.incolumitas.com/?whois=8.8.8.0,network-abuse@google.com,AS15169,0 (Very Low),8.8.8.0/24,"GOOGLE, US",us,True,Google LLC,google.com,network-abuse@google.com,business,2000-03-30,2012-02-24,ARIN,https://api.incolumitas.com/?whois=AS15169,United States,US,California,Sunnyvale,37.36883,-122.03635,95196,America/Los_Angeles

  ```



  IP Lens can also be utilized as a Python library for direct integration into your Python projects.

  ```python
  from iplens.api import IPInfoAPI

  api = IPInfoAPI()
  results = api.process(['8.8.8.8', '1.1.1.1'])
  ```

  This will fetch and process the IP information for the given IP addresses. The results will include detailed information such as ASN, location, company details, and more, extracted and formatted for easy access



  The configuration file is located at `src/iplens/config.cfg`. You can modify the configuration file to suit your specific requirements. The available fields and their purposes are defined in the `src/config_loader.py`.



  Note that the API has rate limits in its free, unregistered mode. If you encounter a rate limit, simply wait for 20 minutes and then continue using the tool.



  IP Lens includes a caching mechanism to store fetched IP information locally. This helps reduce the number of API calls, especially when processing large lists of IPs. The cache is automatically cleared after a configurable expiration period, which can be set in the `config.cfg` file.



  If there are specific fields you wish to exclude from the output, you can configure this in the `src/utils.py` file, where the list of field names is defined. This allows you to customize the output based on your needs.





  1. Clone the repository
     ```bash
     git clone https://github.com/aiomorphic/iplens.git
     cd iplens
     ```
  2. Create a virtual environment: `python -m venv venv`
  3. Activate the virtual environment:
      - Windows: `venv\Scripts\activate`
      - Unix or MacOS: `source venv/bin/activate`
  4. Install development dependencies: `pip install -r requirements.txt`



  ```bash
  make pre-commit
  ```



  Implement new functionality in the appropriate module under iplens/.
  Add tests for the new functionality in tests/.
  Update iplens_cli.py if the new feature should be accessible via CLI.


pkgId: 9448ee11f7c3f067a6d16c79bc170ace649caea106bcec7a48edb9ed8ca404bd
name: python-iprecommit-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for iprecommit
url: https://pypi.org/project/iprecommit/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iprecommit-0.7.0-1.src.rpm
location_href: Packages/python-iprecommit-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  A dead-simple tool to manage pre-commit hooks for Git.

  `iprecommit` runs shell commands and fails the hook if they fail. You can filter commands on glob patterns (e.g., `*.py` for Python-only checks) and define fix commands (e.g., for auto-formatters).

  ```toml
  [[pre_commit]]
  cmd = ["black", "--check"]
  filters = ["*.py"]
  fix_cmd = ["black"]

  [[pre_commit]]
  cmd = ["./run_tests"]
  pass_files = false
  ```

  That's it.


  Install it with `pip` or [`pipx`](https://github.com/pypa/pipx):

  ```shell
  pip install iprecommit
  ```

  Then, initialize a pre-commit check in your git repository:

  ```shell
  cd path/to/some/git/repo
  iprecommit install
  ```

  `iprecommit install` will create a file called `precommit.toml` to configure your pre-commit checks.

  Now, whenever you run `git commit`, the checks in `precommit.toml` will be run automatically. You can also run the pre-commit checks manually:

  ```shell
  iprecommit run
  ```

  Some pre-commit issues can be fixed automatically:

  ```shell
  iprecommit fix
  ```

  By default, `iprecommit run` and `iprecommit fix` operate only on staged changes. To only consider unstaged changes as well, pass the `--unstaged` flag. To run on every file in the repository (committed, unstaged, and staged), pass the `--all` flag.




  [pre-commit](https://pre-commit.com/) is (as far as I can tell) the most widely-used library for pre-commit hook management.

  I used pre-commit for a while. Here's why I created `iprecommit`:

  - I hated configuring my pre-commit checks in YAML.
  - The colored output is hard to read with a dark theme, and [this won't be fixed](https://github.com/pre-commit/pre-commit/issues/2325).
  - I just wanted an intelligent way to run shell commands before `git commit`, not a "multi-language package manager".
  - With a custom template at `IPRECOMMIT_TOML_TEMPLATE`, and `autofix` and `fail_fast` set to true, `iprecommit` does what I want and I rarely have to think about it.

  Reasons you might prefer pre-commit:

  - You like pre-commit's [more extensive configuration options](https://pre-commit.com/#creating-new-hooks).
  - You need one of the [Git hooks that pre-commit supports](https://pre-commit.com/#supported-git-hooks) and `iprecommit` doesn't.


  Set `skip = true` in the `precommit.toml` file, or pass `--skip <name>` to `iprecommit run`.




  ```toml
  [[pre_commit]]
  name = "PythonFormat"
  cmd = ["black", "--check"]
  filters = ["*.py"]
  fix_cmd = ["black"]
  ```

  - `name` is optional.
  - Changed files are passed to the command unless `pass_files = false`.
  - `filters` is applied to the set of staged files. If the result is empty, the check is not run. Filters may be literal paths (`example.py`), glob patterns (`*.py`), or exclude patterns (`!example.py`, `!*.py`).
  - If `fix_cmd` is present, then `iprecommit fix` will *unconditionally* run the command. `filters` still applies as usual.
  - Commands run in the root of the Git repository by default. If you need the command to run elsewhere, set `working_dir`.


  ```toml

  [[commit_msg]]
  name = "CommitMessageFormat"
  cmd = ["iprecommit-commit-msg-format", "--max-line-length", "72"]
  ```

  - `name` and `cmd` are the only supported keys for `commit_msg` checks.
  - `cmd` is passed the name of a single file which holds the message's contents.


  ```toml

  [[pre_push]]
  name = "NoForbiddenStrings"
  cmd = ["iprecommit-no-forbidden-strings", "--commits"]
  ```

  - `name` and `cmd` are the only supported keys for `pre_push` checks.
  - `cmd` is passed a list of Git revisions to be pushed to the remote repository.


  If the top-level `autofix` option is set to `true` in the TOML file, then when a fixable check fails, `iprecommit run` will automatically invoke `iprecommit fix`, and then re-run `iprecommit run` after. This is useful if you have, e.g., auto-formatting checks that can fix themselves without human intervention.


  These commands are designed to be used with `iprecommit`, but they can also be used independently.

  - `iprecommit-commit-msg-format` checks the format of the commit message.
  - `iprecommit-newline-at-eof` checks that each file ends with a newline.
  - `iprecommit-no-forbidden-strings` checks for forbidden strings.
  - `iprecommit-typos` checks for common typos.


  - If you want to create your own template for `precommit.toml` to be used by `iprecommit install`, then set the environment variable `IPRECOMMIT_TOML_TEMPLATE` to the path to the file.


pkgId: 3824eeb14bedaf43376caf7b2c7b63533228670cb994ace504be3d798d6725e9
name: python-ipsh-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for ipsh
url: https://gitlab.com/blackstream-x/pseudoshell
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipsh-0.1.7-1.src.rpm
location_href: Packages/python-ipsh-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  _Python library providing a shell-like interface in pure Python,
  supporting limited in-line editing and History on Unix and Windows systems._

  Built around the `getch()` and `getkey()` functions from
  <https://gitlab.com/MatteoCampinoti94/PythonRead>
  (and originally forked from that repository).

rpm_license:
  European Union Public Licence V. 1.2  EUPL © the European Union 2007, 2016  This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).  The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Work: “Licensed under the EUPL”, or has expressed by any other means his willingness to license under the EUPL.  1. Definitions  In this Licence, the following terms have the following meaning: — ‘The Licence’: this Licence. — ‘The Original Work’: the work or software distributed or communicated by the ‘Licensor under this Licence, available as Source Code and also as ‘Executable Code as the case may be. — ‘Derivative Works’: the works or software that could be created by the ‘Licensee, based upon the Original Work or modifications thereof. This ‘Licence does not define the extent of modification or dependence on the ‘Original Work required in order to classify a work as a Derivative Work; ‘this extent is determined by copyright law applicable in the country ‘mentioned in Article 15. — ‘The Work’: the Original Work or its Derivative Works. — ‘The Source Code’: the human-readable form of the Work which is the most convenient for people to study and modify.  — ‘The Executable Code’: any code which has generally been compiled and which is meant to be interpreted by a computer as a program. — ‘The Licensor’: the natural or legal person that distributes or communicates the Work under the Licence. — ‘Contributor(s)’: any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work. — ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of the Work under the terms of the Licence. — ‘Distribution’ or ‘Communication’: any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential functionalities at the disposal of any other natural or legal person.  2. Scope of the rights granted by the Licence  The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for the duration of copyright vested in the Original Work:  — use the Work in any circumstance and for all usage, — reproduce the Work, — modify the Work, and make Derivative Works based upon the Work, — communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work, — distribute the Work or copies thereof, — lend and rent the Work or copies thereof, — sublicense rights in the Work or copies thereof.  Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.  In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.  The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.  3. Communication of the Source Code  The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute or communicate the Work.  4. Limitations on copyright  Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations thereto.  5. Obligations of the Licensee  The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:  Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.  Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless the Original Work is expressly distributed only under this version of the Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.  Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, ‘Compatible Licence’ refers to the licences listed in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.  Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute or communicate the Work.  Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or 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 copyright notice.  6. Chain of Authorship  The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.  Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.  Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.  7. Disclaimer of Warranty  The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work and may therefore contain defects or ‘bugs’ inherent to this type of development.  For the above reason, the Work is provided under the Licence on an ‘as is’ basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.  This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.  8. Disclaimer of Liability  Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.  9. Additional agreements  While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or 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 the fact You have accepted any warranty or additional liability.  10. Acceptance of the Licence  The provisions of this Licence can be accepted by clicking on an icon ‘I agree’ placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.  Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution or Communication by You of the Work or copies thereof.  11. Information to the public  In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.  12. Termination of the Licence  The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence. Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.  13. Miscellaneous  Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work.  If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid and enforceable.  The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. New versions of the Licence will be published with a unique version number.  All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take advantage of the linguistic version of their choice.  14. Jurisdiction  Without prejudice to specific agreement between parties, — any litigation resulting from the interpretation of this License, arising between the European Union institutions, bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union, — any litigation arising between other parties and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.  15. Applicable Law  Without prejudice to specific agreement between parties, — this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, resides or has his registered office, — this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside a European Union Member State.  Appendix  ‘Compatible Licences’ according to Article 5 EUPL are: — GNU General Public License (GPL) v. 2, v. 3 — GNU Affero General Public License (AGPL) v. 3 — Open Software License (OSL) v. 2.1, v. 3.0 — Eclipse Public License (EPL) v. 1.0 — CeCILL v. 2.0, v. 2.1 — Mozilla Public Licence (MPL) v. 2 — GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3 — Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software — European Union Public Licence (EUPL) v. 1.1, v. 1.2 — Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+)  — The European Commission may update this Appendix to later versions of the above licences without producing a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the covered Source Code from exclusive appropriation. — All other changes or additions to this Appendix require the production of a new EUPL version.


pkgId: 87376432594289d2da60ad12d45d3f2ccbfcea9238adee7ad5c815e24ca7e2df
name: python-ipsurv-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for ipsurv
url: https://github.com/deer-hunt/ipsurv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipsurv-1.1.1-1.src.rpm
location_href: Packages/python-ipsurv-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <div>
  <img width="165" height="165" src="https://raw.githubusercontent.com/deer-hunt/ipsurv/main/docs/images/ipsurv-logo.png" align="left" />

  ```IpSurv``` is a command-line program for surveying IP addresses, host information, and more. Also ```IpSurv``` is extensible program by Python.

  <div>

  <a href="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests.yml"><img alt="CI - Test" src="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests.yml/badge.svg"></a>
  <a href="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests-windows.yml"><img alt="CI - Test" src="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests-windows.yml/badge.svg"></a>
  <a href="https://github.com/deer-hunt/ipsurv/actions/workflows/lint.yml"><img alt="GitHub Actions build status (Lint)" src="https://github.com/deer-hunt/ipsurv/workflows/Lint/badge.svg"></a>
  <a href="https://codecov.io/gh/deer-hunt/ipsurv"><img alt="Coverage" src="https://codecov.io/github/deer-hunt/ipsurv/coverage.svg?branch=main"></a>
  <img alt="PyPI - Status" src="https://img.shields.io/pypi/status/ipsurv">
  <a href="https://github.com/deer-hunt/ipsurv/blob/main/LICENSE.md"><img alt="License - MIT" src="https://img.shields.io/pypi/l/ipsurv.svg"></a>
  <a href="https://pypi.org/project/ipsurv/"><img alt="Newest PyPI version" src="https://img.shields.io/pypi/v/ipsurv.svg"></a>
  <a href="https://pypi.org/project/ipsurv/"><img alt="Number of PyPI downloads" src="https://img.shields.io/pypi/dm/ipsurv.svg"></a>
  <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/deer-hunt/ipsurv">
  <a href="https://pypi.org/project/ipsurv"><img alt="Supported Versions" src="https://img.shields.io/pypi/pyversions/ipsurv.svg"></a>
  <a href="https://deer-hunt.github.io/ipsurv/" alt="IpSurv's documentation site"><img src="https://img.shields.io/badge/stable%20docs-github.io-brightgreen?style=flat&color=%2373DC8C&label=Docs"/></a>
  <a href="https://app.fossa.com/projects/git%2Bgithub.com%2Fdeer-hunt%2Fipsurv?ref=badge_shield" alt="FOSSA Status"><img src="https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdeer-hunt%2Fipsurv.svg?type=shield"/></a>

  </div>
  </div>

  <p>&nbsp;</p>

  <img src="https://raw.githubusercontent.com/deer-hunt/ipsurv/main/docs/images/ipsurv.gif" alt="ipsurv visual image" width="100%" />



  ```bash
  $ pip install ipsurv
  or
  $ pip3 install ipsurv
  ```



  - ```python``` and ```pip``` command
  - Python 3.0 or later version.

  > If you'd like to use in Python 2.7, you can refactor to Python 2.7 code easily. See "development_debug.md".



  IpSurv's documentation site is [https://deer-hunt.github.io/ipsurv/](https://deer-hunt.github.io/ipsurv/).




  **Specify Target using Argument**

  ```bash
  $ ipsurv 192.168.1.10
  $ ipsurv 192.168.1.10 192.168.1.11
  $ ipsurv test-example-sample-ipsurv.com --add_ip
  $ ipsurv x.x.x.x --format=geo
  ```

  **Specify Target using PIPE**

  ```bash
  $ cat ips.txt|ipsurv
  $ cat apache.log|ipsurv --add_ip
  ```

  **Example result**

  ```bash
  8.8.8.8:53,8.8.8.0,US,ICMP_OK,TCP_OK,UDP_OK
  ```



  ```IpSurv``` have two Survey-mode. Those are "Survey IPs" and "Survey Self".

  | Survey-mode              | Description              |
  |-------------------|------------------------|
  | **Survey IPs**     | Primary mode. Surveying IP or Host or URL.     |
  | **Survey Self**    | Surveying self IP.     |

  **Survey Self e.g.**

  ```bash
  $ ipsurv self
  Ip: 144.160.*.*
  Hostname:
  Organization: AS797 AT&T Services, Inc.
  Country: US
  City: San Jose
  Region: California
  Postal: 95103
  Geo: 37.3394,-121.8950
  Timezone: America/Los_Angeles
  LocalIp: 10.0.2.5
  LocalDns: ['8.8.8.8', '8.8.4.4']
  ```



  - Grouping by IP or Subnet.
  - Skip duplicate by the group.
  - Autodetect IP in line. Trying to resolve the name automatically.
  - Autodetect delimiter-char.
  - Customize output format. There are many format.
  - Output JSON format.
  - Show headers.
  - Check ICMP, TCP, UDP, HTTP.
  - Set timeout.
  - Load env variable. And changing arguments and internal configures.
  - Use GeoIP2 via IpSurv optionally.



  ```IpSurv``` have many options. Please read [Command arguments(.md) reference](https://github.com/deer-hunt/ipsurv/blob/main/docs/command_arguments.md).

  **Options**

  ```
  [-h] [--verbose {0,1,2,3}] [--debug] [--log LOG]
  [--disable_env] [--resolve RESOLVE] [--identify_int]
  [--autodetect AUTODETECT] [--begin BEGIN] [--end END]
  [--collect COLLECT] [--all_collect] [--timeout TIMEOUT]
  [--group GROUP] [--skip_duplicate {0,1,2}] [--range RANGE]
  [--format FORMAT] [--no_original] [--sequence] [--add_ip]
  [--ident] [--enclose ENCLOSE] [--delimiter DELIMITER]
  [--alt_delimiter ALT_DELIMITER] [--headers {0,1,2,3}]
  [--json {0,1,2}] [--json_list] [--exhaustive] [--icmp ICMP]
  [--tcp TCP] [--udp UDP] [--http {0,1,2}] [--json_all]
  [--geoip_only] [--version]
  [target [target ...]]
  ```

  **Example options**

  ```bash
  $ cat ips.txt|ipsurv --group=24
  $ cat ips.txt|ipsurv --group=network
  $ cat ips.txt|ipsurv --format=country
  $ cat ips.txt|ipsurv --format=hostname
  $ cat ips.txt|ipsurv --format="{country},{name}"
  $ cat ips.txt|ipsurv --format="{country},{ip_int},{handle},{port43}"
  $ cat /var/log/httpd/access_log|ipsurv --ident --no_original

  $ cat ips.txt|ipsurv --group=255.255.255.0
  $ cat ips.txt|ipsurv --delimiter="\t"
  $ cat ips.txt|ipsurv --format="{group}\t{ip_int}\t{country}\t{handle}\t{port43}"
  $ cat ips.txt|ipsurv --format="{country},{ip_int},{handle},{port43},{icmp},{port},{tcp}" --group=network --icmp=1 --tcp=1 --timeout=2
  ```



  **Show headers**

  ```bash
  $ cat ./example_data/government.txt|ipsurv --headers=1 --format="{status},{group},{country},{name},{cidr},{http},{http_h2}" --group=network --http=2
  original,status,group,country,name,cidr,http,http_h2
  www.whitehouse.gov,OK,192.0.64.1,US,AUTOMATTIC,192.0.64.0/18,HTTP_OK,HTTP2
  www.state.gov,OK,3.165.0.1,US,AMAZON-CF,3.165.0.0/16,HTTP_OK,HTTP2
  www.treasury.gov,OK,23.32.0.1,US,AKAMAI,23.32.0.0/11,HTTP_OK,HTTP2
  www.gov.uk,OK,151.101.0.1,US,SKYCA-3,151.101.0.0/16,HTTP_OK,HTTP2
  www.gouvernement.fr,OK,217.70.184.1,FR,GANDIFR-NET4,217.70.184.0/24,HTTP_OK,HTTP1
  www.diplomatie.gouv.fr,OK,77.128.0.1,FR,FR-SFR-20100831,77.128.0.0/11,HTTP_OK,HTTP1
  www.economie.gouv.fr,OK,141.101.88.1,EU,CLOUDFLARE-EU,141.101.88.0/21,HTTP_OK,HTTP2
  www.bundesregierung.de,OK,185.173.230.1,DE,BABIEL-NET-230,185.173.230.0/24,HTTP_OK,HTTP2
  ```

  **Add line-number**

  ```bash
  $ cat ./example_data/government.txt|ipsurv --sequence --add_ip
  1,www.whitehouse.gov,192.0.66.168,OK,US,AUTOMATTIC,192.0.64.0,192.0.127.255
  2,www.state.gov,3.165.39.61,OK,US,AMAZON-CF,3.165.0.0,3.165.255.255
  3,www.treasury.gov,23.50.118.187,OK,US,AKAMAI,23.32.0.0,23.67.255.255
  4,www.gov.uk,151.101.192.144,OK,US,SKYCA-3,151.101.0.0,151.101.255.255
  ```

  **Output by JSON**

  ```bash
  $ ipsurv wikipedia.org --format=default --json=2 --add_ip
  {
    "original": "wikipedia.org",
    "ip": "103.102.166.224",
    "status": "OK",
    "group": "",
    "country": "US",
    "name": "WIKIMEDIA-AP",
    "network_start": "103.102.166.0",
    "network_end": "103.102.166.255"
  }
  ```

  **Output detailed data by JSON**

  ```bash
  $ ipsurv wikipedia.org --json_all    # `--json_all` is equivalent to `--json=2 --exhaustive`
  $ ipsurv wikipedia.org --format=default --json=2 --exhaustive
  {
    "success": true,
    "status": "OK",
    "requests": [
      "RDAP"
    ],
    "errors": [],
    "sequence": 1,
    "original": "wikipedia.org",
    "target": "103.102.166.224",
    "ip": "103.102.166.224",
    "ip_int": 1734780640,
    "port": null,
    "group_int": 0,
    "group": "",
    "group_found": false,
    "group_status": "-",
    "country": "US",
    "name": "WIKIMEDIA-AP",
    "network_start": "103.102.166.0",
    "network_end": "103.102.166.255",
    "ip_hex": "67.66.A6.E0",
    "ip_reversed": "224.166.102.103",
    "ip_type": "PUBLIC",
  ~~~~~~~~~~~~~
    "org": "Wikimedia Foundation, Inc.",
    "address": "1 Montgomery Street Suite 1600",
    "description": "Wikimedia Foundation, Inc.",
    "target.raw": "wikipedia.org",
    "target.identifier": "103.102.166.224",
    "target.identifier_int": 1734780640,
    "target.identified": true,
    "target.ip": "103.102.166.224",
    "target.url": null,
    "target.fqdn": "wikipedia.org",
    "target.port": null,
    "target.status": "EXIST"
  }
  ```

  More examples are [here](https://deer-hunt.github.io/ipsurv/pages/command_examples.html).




  You can customize "Output Format" by ```--format``` option as follows. There are ```parameter - {}``` and ```profile - <>``` in ```--format```.
  For more information, please read [--format description](https://deer-hunt.github.io/ipsurv/pages/command_arguments.html#format).

  ```
  $ ipsurv github.io --format=heavy            # Profile
  $ ipsurv github.io --format=simple           # Profile

  $ ipsurv 8.8.8.8 --format="{status},{ip},{country},{address}"   # Paramaters
  $ ipsurv 8.8.8.8 --format="{status}\t{ip}\t{hostname}"         # Paramaters, TAB char

  $ ipsurv cloudflare.com --format="{ip},<address>,<system>"      # Paramaters + Profile
  $ ipsurv wikipedia.org --format="<address>,{hostname},{ip_type}"     # Profile + Paramaters
  ```




  ```IpSurv``` support [GeoIP2](https://github.com/maxmind/GeoIP2-python) optionally. If ```GeoIP2``` module is installed and there are ```mmdb``` files, You can use GeoIP2 features via ```IpSurv```.
  When using the GeoIP2 module, network communication does not occur, which enables faster processing.

  Please refer to the [Using GeoIP2](https://deer-hunt.github.io/ipsurv/pages/using_geoip2.html) documentation in detail.

  **Examples**

  ```
  $ ipsurv 8.8.8.8 --geoip_only
  8.8.8.8,NA,North America,US,United States,America/Chicago,AS15169,37.751;-97.822
  ```

  ```
  $ ipsurv www.wikipedia.org --format="{country},{geo}" --collect=geoip --headers=1
  original,country,geo
  www.wikipedia.org,US,37.751;-97.822

  $ ipsurv 8.8.8.8 --format="{continent},{continent_name},{country},{geo}" --collect="geoip" --headers=1
  original,continent,continent_name,country,geo
  8.8.8.8,NA,North America,US,37.751;-97.822
  ```

  > `IpSuv` support customizing GeoIP2 data path by `IPSURV_CONF` env. Please read [here](https://deer-hunt.github.io/ipsurv/pages/command_arguments.html#environment-variable-ipsurv-conf) about `IPSURV_CONF`.




  The following documents exist in ```IpSurv```. You can read documents in [Documentation site](https://deer-hunt.github.io/ipsurv/).

  | Title                       | Path                                        |
  |-------------------------------|---------------------------------------------|
  | **Command arguments**    | [command_arguments.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/command_arguments.md) |
  | **Command examples**               | [command_examples.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/command_examples.md)   |
  | **Program architecture and Classes** | [program_architecture_classes.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/program_architecture_classes.md) |
  | **Customizing and Examples**       | [customize_examples.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/customize_examples.md) |
  | **Development and Debugging**          | [development_debug.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/development_debug.md)   |
  | **About Using GeoIP2** | [using_geoip2.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/using_geoip2.md)  |
  | **IpSurv's Major Modules and Classes** | [github.io / Modules and Classes reference](https://deer-hunt.github.io/ipsurv/py-modindex.html)  |




  | Directory        | Description                                         |
  |-----------------------|-----------------------------------------------------|
  | `.github`            | GitHub Actions files          |
  | `docs`               | Documentation files                                 |
  | `example_data`       | Sample data files for testing                       |
  | `examples`           | Example programs                 |
  | `ipsurv`             | Main package/Sources                            |
  | `tests`              | Test files                     |




  In verbose mode, outputting internal data and behaviors in detail.

  ```bash
  $ ipsurv ***** --verbose=2    #INFO
  $ ipsurv ***** --verbose=3    #DEBUG

  $ ipsurv ***** --debug     #DEBUG  This option is equivalent to "--verbose=3"
  ```



  ```IpSurv``` is implemented as customizable program architecture. ```IpSurv``` provide extending features and several classes.
  And you can use IpSurv's internal classes in your program. Please read ```program_architecture_classes.md```.

  **Classes for major customization**

  | Classes    | Description            |
  |----------------------|----------------------------------------------|
  | **Pipeline**   | Pipeline class provide catching and customizing the data in each processing. ```./examples/pipeline_customize.py```         |
  | **ObjectFactory**   | ObjectFactory class provide customizing classes and creating original classes. ```./examples/object_factory.py```      |
  | **Serializer, LineSerializer, JsonSerializer**   | Serializer class provide displaying data and transforming data for presentation. ```./examples/object_factory_original_headers.py```      |




  - [dnspython](https://github.com/rthalley/dnspython)
  - [geoip2](https://github.com/maxmind/GeoIP2-python) [Optional]


pkgId: 48dbf54b48fb1c0c116b28f82b5163ac95d2192bac76f9edb60f946f51b27a60
name: python-iptv-spider-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for iptv-spider
description: This is an application for testing the speed of IPTV.
url: https://github.com/malidong/iptv_spider
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iptv-spider-0.1.0-1.src.rpm
location_href: Packages/python-iptv-spider-help-0.1.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Win2er  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: d26ca9ab43643328c27a8e12ae59863e533dd13513bcaa65064750dae162c4ad
name: python-ipyautoui-help
arch: noarch
version: 0.7.22
epoch: 0
release: 1
summary: Development documents and examples for ipyautoui
url: https://github.com/maxfordham/ipyautoui
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipyautoui-0.7.22-1.src.rpm
location_href: Packages/python-ipyautoui-help-0.7.22-1.noarch.rpm
checksum_type: sha256
description:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/maxfordham/ipyautoui/HEAD?urlpath=voila%2Frender%2Fdocs%2Fdemo.ipynb) [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![PyPI version](https://badge.fury.io/py/ipyautoui.svg)](https://badge.fury.io/py/ipyautoui) [![Test Python Package](https://github.com/maxfordham/ipyautoui/actions/workflows/test-and-lint.yml/badge.svg)](https://github.com/maxfordham/ipyautoui/actions/workflows/test-python-package.yml)

  ![](images/logo.png)



  [https://maxfordham.github.io/ipyautoui/](https://maxfordham.github.io/ipyautoui/)



  launch [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/maxfordham/ipyautoui/HEAD?urlpath=voila%2Frender%2Fdocs%2Fdemo.ipynb).



  ```sh
  pip install ipyautoui
  mamba install ipyautoui -c conda-forge  # mamba ... TODO: add to conda-forge.
  conda install ipyautoui -c conda-forge  # or conda ... TODO: add to conda-forge.
  ```



  A high-level wrapper library that sits on top of [**ipywidgets**](https://github.com/jupyter-widgets/ipywidgets) (and other ipy- widget libraries), [**pydantic**](https://github.com/samuelcolvin/pydantic/) and Jupyter rich display system to template and automate the creation of widget forms / user-interfaces. The core user-facing classes in this library are **AutoUi**, **AutoVjsf** and **AutoDisplay**:

  ```python
  from ipyautoui import AutoUi, AutoVjsf, AutoDisplay, demo

  demo()
  ```
  ![demo](images/demo.png)
  ipyautoui aims to give you as much as possible out-the-box, whilst also supporting a simple workflow to extend and customise the interface to specific user requirements.





  ```python
  from pydantic import BaseModel, Field
  from ipyautoui import AutoUi

  class LineGraph(BaseModel):
      """parameters to define a simple `y=m*x + c` line graph"""
      title: str = Field(default='line equation', description='add chart title')
      m: float = Field(default=2, description='gradient')
      c: float = Field(default=5, ge=0, le=10, description='intercept')
      x_range: tuple[int, int] = Field(
          default=(0,5), ge=0, le=50, description='x-range for chart')
      y_range: tuple[int, int] = Field(
          default=(0,5), ge=0, le=50, description='y-range for chart')

  ui = AutoUi(schema=LineGraph)
  ui
  ```

  ![autoui-linegraph](images/autoui-linegraph.png)

  ```python
  ui.value  # there is a `value` trait that is always kept in-sync with the widget input form







  ui.file(path) #  file data to .json file
  ui.value #  input form value dict
  ui.model #  pydantic model (if given as input, AutoUi can be called from a jsonschema only also)
  ui.schema #  jsonschema
  AutoUi.create_autoui_renderer #  creates a json-serializable pointer
  AutoUi.parse_file #  init ui with data from .json file
  ```

  * AutoUi uses [**pydantic**](https://github.com/samuelcolvin/pydantic/) to define the schema of User Input form, and then infers the widget to use based on type and user-directives
  * `ipyautoui.custom.` provides useful widgets (e.g. iterable) that aren't included within the core ipywidgets library
  * ipyautoui defines a best practice for creating and integrating custom widgets, and as default includes some widgets from other popular widget libraries (e.g. ipydatagrid, ipyfilechooser).
  * ipyautoui handles observing the values, and maintains a stateful and validated `.value` parameter for the whole user input form.
  * AutoUi also allows the user to specify the usage of [**ipyvuetify**](https://github.com/widgetti/ipyvuetify) and

    * **note**. this is the recommended approach for simple and generic input forms. Where custom UI objects are required these can be built using the ipyautoui core library.



  `AutoVjsf` works in exactly the same way as `AutoUi` , but instead of using `ipywidgets` to render the JSON schema it uses [ipyvuetify](https://github.com/widgetti/ipyvuetify) and [vuetify-jsonschema-form](https://github.com/koumoul-dev/vuetify-jsonschema-form).





  The excellent documentation for [**vuetify-jsonschema-form**](https://koumoul-dev.github.io/vuetify-jsonschema-form/latest/) can be used to create your schema. Anything possible in vjsf is therefore possible using AutoVjsf. This has a much more complete coverage of the json-schema specification, as well as the added benefit of out-the-box support of mobile applications. It falls down if you want to specify custom renderer objects.

  ```{note}
  when you're using pydantic to make the schema, "-" cannot be used field names,
  but vuetify-jsonschema-form requires them (e.g. "x-display");
  use "x_display" instead and AutoVjsf does the conversion).

  ```



  The main benefit of AutoUi (and main the reason for continuing to develop it), is that it makes it simple to create custom renderers for specific parts of the json-schema, facilitating the bespoke the requirements of a custom project. See [custom-renderers](custom-renderers.ipynb).



  * AutoDisplay uses Jupyter's rich display system and large ecosystem of 3rd party packages to create a simple and unified display wrapper to various filetypes.
  * The renderer for a given file is inferred from the file extension.
    * TODO: where the datasource is not a file, the extension is a mapping code that maps a renderer to the datastructure of the data.
  * Custom renderer's can be passed to `AutoDisplay` allowing it to display user-defined filetypes (or compound extension filetypes)



  `ipyautoui` inherits the `openpath` command from [maplocal](https://github.com/maxfordham/maplocal) when it is in use. Refer to [maplocal](https://github.com/maxfordham/maplocal) for how to use.
  `maplocal` is not a requirement for `ipyautoui`, but if it is installed the `openfile` and `runcmd` functions will be taken from their.



  * Make a pydantic model (or json schema) that defines the UI
  * Pass the model to `AutoUi` or `AutoVjsf` to generate an user-interface
  * Save the UI fields to file
  * Assign a compound-json filetype to the schema and generate `AutoDisplay` rendererer
  * Use `AutoDisplay` to display the json file using the AutoUi interface



  This package intends to be high-level, and unifies many other ipy- libraries under a simple and familiar API.

  * [pydantic](https://github.com/samuelcolvin/pydantic/)
  * [ipywidgets](https://github.com/jupyter-widgets/ipywidgets)
  * [ipydatagrid](https://github.com/bloomberg/ipydatagrid)
  * [ipyfilechooser](https://github.com/crahan/ipyfilechooser)
  * [ipyvuetify](https://github.com/widgetti/ipyvuetify)
  * [vuetify-jsonschema-form](https://github.com/koumoul-dev/vuetify-jsonschema-form)
  * [Plotly](https://github.com/plotly/plotly.py) (for viewing `.plotly.json` files. note. this needs to be added by the user)
  * [maplocal](https://github.com/maxfordham/maplocal) (for mapping rootdir between remote server and user machine)

  It is also obviously wholly dependent on the excellent json-schema specification:

  * [json-schema](https://json-schema.org/)



  ```sh
  $ git clone https://github.com/maxfordham/ipyautoui
  $ cd ipyautoui


  $ mamba env create -f environment.yml


  $ pytest
  ```

  ```{note}
  [Jupytext](https://github.com/mwouts/jupytext) is used throughout to allow the `.py` files
  to be ran as notebooks to facillitate easy testing. You can use JupyterLab, or if you are
  using VS Code then install the Jupytext extension. In the `.vscode/settings.json` file
  `"jupyter.notebookFileRoot": "${fileDirname}"` matching with the jupyterlab default.
  ```



  ```sh

  mamba create -n hatcher python hatch
  mamba activate hatcher # or conda env with hatch installed
  hatch build  # builds to local folder
  hatch publish -u __token__ -a <your-pypi-token>  # publishes to pypi
  ```



  AutoVjsf is a very thin wrapper where ipyvuetify and vuetify-jsonschema-form are doing all the work.
  Many thanks to @mariobuikhuizen for providing me with the [boiler-plate code](https://github.com/widgetti/ipyvuetify/issues/182).
  Contributions welcome.

  **Note**: this is a 3rd party that is developed independently of the pydantic.dev company; other than relying
  heavily on their excellent package (pydantic), it is not affiliated with pydantic.dev in any way.


pkgId: 3971610eff8e5f1e87592bd6a2d63843562d9ab0cc311f84cf4dde0c46fc8e9d
name: python-ipybox-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for ipybox
url: https://github.com/gradion-ai/ipybox
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipybox-0.2.1-1.src.rpm
location_href: Packages/python-ipybox-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  A secure, lightweight Python code execution sandbox based on IPython and Docker, specifically designed for AI/ML applications and LLM agents.

  <p align="center">
    <img src="docs/logo.png" alt="logo">
  </p>



  This project provides a sandboxed Python code execution environment built on IPython and Docker. It offers:

  - **Secure Execution**: Code runs in Docker containers, preventing unauthorized system access
  - **Flexible Dependencies**: Supports static and runtime dependency management
  - **Real-time Streaming**: Chunked streaming of execution output as it's generated
  - **Image Support**: Handle image outputs from matplotlib and other visualization libraries
  - **Resource Control**: Container lifecycle management and built-in timeout mechanisms
  - **Reproducible Environment**: Consistent execution environment across different systems
  - **LLM Agent Ready**: Ideal for AI applications that need to execute Python code

  This project is in early beta, with active development of new features ongoing.





  ```bash
  pip install ipybox
  ```



  **Note**: Building the container image requires [Docker](https://www.docker.com/) to be installed. Containers will run with the same user and group IDs as the user who built the image, ensuring proper file permissions on mounted host directories.



  To build a container image with default settings and no extra dependencies:

  ```bash
  python -m ipybox build
  ```

  This creates a Docker image tagged as `gradion/ipybox` with base Python dependencies required for the code execution environment.



  To create a custom image with additional dependencies for your application, create a dependencies file (e.g., `dependencies.txt`) following. For example:

  ```txt
  pandas = "^2.2"
  scikit-learn = "^1.5"
  matplotlib = "^3.9"
  ```

  To build the image with custom tag and dependencies:

  ```bash
  python -m ipybox build \
      --tag my-box:v1 \
      --dependencies path/to/dependencies.txt
  ```

  The dependencies file should list Python packages in [Poetry dependency specification format](https://python-poetry.org/docs/dependency-specification/). These will be installed in addition to the base dependencies required for the execution environment. The execution container also supports [installing dependencies at runtime](#installing-dependencies-at-runtime).



  The following examples demonstrate how to use the `ExecutionContainer` and `ExecutionClient` context managers to execute Python code in an IPython environment running in a Docker container. Runnable scripts of the following code snippets are available in the [examples](examples/) directory.



  Here's a simple example that demonstrates how to execute Python code in an execution container. The `ExecutionContainer` context manager creates and starts a container for code execution, and the `ExecutionClient` context manager connects to an IPython kernel running in the container. The example below executes the code `print('Hello, world!')` and prints the output text:

  ```python
  from ipybox import ExecutionContainer, ExecutionClient


  async with ExecutionContainer(tag="gradion/ipybox") as container:
      
      async with ExecutionClient(host="localhost", port=container.port) as client:
          
          result = await client.execute("print('Hello, world!')")
          
          print(f"Output: {result.text}")  # Output: Hello, world!
  ```

  The default image used by `ExecutionContainer` is `gradion/ipybox`. You can specify a custom image with the `tag` argument like in `ExecutionContainer(tag="my-box:v1")`, for example.



  Code execution within the same client context is stateful i.e. you can reference variables from previous executions. Code executions in different client contexts are isolated from each other:

  ```python
  async with ExecutionContainer() as container:
      async with ExecutionClient(host="localhost", port=container.port) as client_1:
          
          result = await client_1.execute("x = 1")
          assert result.text is None

          
          result = await client_1.execute("print(x)")
          assert result.text == "1"

      async with ExecutionClient(host="localhost", port=container.port) as client_2:
          
          try:
              await client_2.execute("print(x)")
          except ExecutionError as e:
              assert e.args[0] == "NameError: name 'x' is not defined"
  ```



  The execution client supports streaming output as it's generated during code execution:

  ```python
  async with ExecutionContainer() as container:
      async with ExecutionClient(host="localhost", port=container.port) as client:
          
          code = """
          import time
          for i in range(5):
              print(f"Processing step {i}")
              time.sleep(1)
          """

          
          execution = await client.submit(code)
          async for chunk in execution.stream():
              
              print(f"Received output: {chunk}")
              
              
              
              
              

          
          result = await execution.result()
          
          print(f"Aggregated output:\n{result.text}")
          
          
          
          
          
          
  ```

  The `stream()` method accepts an optional `timeout` argument (defaults to 120 seconds). In case of timeout, the execution is automatically terminated by interrupting the kernel.



  ```python
  async with ExecutionContainer() as container:
      async with ExecutionClient(host="localhost", port=container.port) as client:
          
          await client.execute("!pip install einops")
          
          
          result = await client.execute("""
              import einops
              print(einops.__version__)
          """)
          print(f"Output: {result.text}")  # Output: 0.8.0
  ```



  Plots created with `matplotlib` or other libraries are returned as PIL images:

  ```python
  async with ExecutionContainer() as container:
      async with ExecutionClient(host="localhost", port=container.port) as client:
          execution = await client.submit("""
              !pip install matplotlib

              import matplotlib.pyplot as plt
              import numpy as np
              import time

              x = np.linspace(0, 10, 100)
              plt.figure(figsize=(8, 6))
              plt.plot(x, np.sin(x))
              plt.title('Sine Wave')
              plt.show()

              print("Plot generation complete!")
              """)

          
          async for chunk in execution.stream():
              print(chunk, end="", flush=True)

          
          result = await execution.result()
          assert "Plot generation complete!" in result.text

          
          result.images[0].save(f"output.png")
  ```

  Images are not part of the output stream, but are available as a `images` list in the `result` object. The example above saves the created image as [output.png](docs/sine.png):



  You can mount host directories into the container to allow code execution to access external files:

  ```python




  binds = {
      "./data": "data",  # Read data from host
      "./output": "output"  # Write results to host
  }


  async with aiofiles.open("data/input.txt", "w") as f:
      await f.write("hello world")

  async with ExecutionContainer(binds=binds) as container:
      async with ExecutionClient(host="localhost", port=container.port) as client:
          
          result = await client.execute("""
              with open('data/input.txt') as f:
                  data = f.read()

              
              processed = data.upper()

              
              with open('output/result.txt', 'w') as f:
                  f.write(processed)
          """)


  async with aiofiles.open("output/result.txt", "r") as f:
      assert await f.read() == "HELLO WORLD"
  ```



  Environment variables can be passed to the container for configuration or secrets:

  ```python
  env = {
      "API_KEY": "secret-key-123",
      "DEBUG": "1"
  }

  async with ExecutionContainer(env=env) as container:
      async with ExecutionClient(host="localhost", port=container.port) as client:
          
          result = await client.execute("""
              import os

              api_key = os.environ['API_KEY']
              print(f"Using API key: {api_key}")

              debug = bool(int(os.environ.get('DEBUG', '0')))
              if debug:
                  print("Debug mode enabled")
          """)
          print(result.text)
          
          
  ```


