# packages

pkgId: 6481943a6cb4a925c3030fa766ed804da7cd4f08e4e79596afd140c2c2eda3e4
name: python-antchain-ak-195dff03d395462ea294bafdba69df3f-help
arch: noarch
version: 1.3.10
epoch: 0
release: 1
summary: Development documents and examples for antchain-ak-195dff03d395462ea294bafdba69df3f
url: https://github.com/alipay/antchain-openapi-prod-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antchain-ak-195dff03d395462ea294bafdba69df3f-1.3.10-1.src.rpm
location_href: Packages/python-antchain-ak-195dff03d395462ea294bafdba69df3f-help-1.3.10-1.noarch.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install antchain-ak_195dff03d395462ea294bafdba69df3f
  ```



  [Opening an Issue](https://github.com/alipay/antchain-openapi-prod-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/alipay/antchain-openapi-prod-sdk)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/alipay/antchain-openapi-prod-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 69471e919660df3188884a1f4935c1991a47fd5fc7a340e7a0f4c9064d403a7b
name: python-antchain-ak-66d0b62c20644717870b45e5087b8007-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for antchain-ak-66d0b62c20644717870b45e5087b8007
url: https://github.com/alipay/antchain-openapi-prod-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antchain-ak-66d0b62c20644717870b45e5087b8007-1.0.1-1.src.rpm
location_href: Packages/python-antchain-ak-66d0b62c20644717870b45e5087b8007-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install antchain-ak_66d0b62c20644717870b45e5087b8007
  ```



  [Opening an Issue](https://github.com/alipay/antchain-openapi-prod-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/alipay/antchain-openapi-prod-sdk)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/alipay/antchain-openapi-prod-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 0dfc032cce585db7349b2cae3b8b5fed3e5a45cba75a00f97a188c43ff7bf72d
name: python-antchain-bot-help
arch: noarch
version: 1.12.1
epoch: 0
release: 1
summary: Development documents and examples for antchain-bot
url: https://github.com/alipay/antchain-openapi-prod-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antchain-bot-1.12.1-1.src.rpm
location_href: Packages/python-antchain-bot-help-1.12.1-1.noarch.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install antchain-bot
  ```



  [Opening an Issue](https://github.com/alipay/antchain-openapi-prod-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/alipay/antchain-openapi-prod-sdk)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/alipay/antchain-openapi-prod-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


pkgId: 3faf97717a76bde9f8c5d74b4687a0a26a6a8bc096580c5571a860dac0732107
name: python-antchain-riskplus-help
arch: noarch
version: 1.22.3
epoch: 0
release: 1
summary: Development documents and examples for antchain-riskplus
url: https://github.com/alipay/antchain-openapi-prod-sdk
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antchain-riskplus-1.22.3-1.src.rpm
location_href: Packages/python-antchain-riskplus-help-1.22.3-1.noarch.rpm
checksum_type: sha256
description:
  English | [简体中文](README-CN.md)





  - Python >= 3.6



  - **Install with pip**

  Python SDK uses a common package management tool named `pip`. If pip is not installed, see the [pip user guide](https://pip.pypa.io/en/stable/installing/ "pip User Guide") to install pip.

  ```bash

  pip install antchain-riskplus
  ```



  [Opening an Issue](https://github.com/alipay/antchain-openapi-prod-sdk/issues/new), Issues not conforming to the guidelines may be closed immediately.



  [Quick Examples](https://github.com/alipay/antchain-openapi-prod-sdk)



  Detailed changes for each release are documented in the [release notes](./ChangeLog.md).



  - [Latest Release](https://github.com/alipay/antchain-openapi-prod-sdk/tree/master/python)



  [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Copyright (c) 2009-present, Alibaba Cloud All rights reserved.


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

  ```console
  pip install anthropic-haystack
  ```

  `hatch` is the best way to interact with this project, to install it:
  ```sh
  pip install hatch
  ```
  With `hatch` installed, to run all the tests:
  ```
  hatch run test
  ```
  > Note: there are no integration tests for this project.
  To run the linters `ruff` and `mypy`:
  ```
  hatch run lint:all
  ```

  You can find an example of how to do a simple RAG with Claude using online documentation in the `example/` folder of this repo.

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


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

  The Anthropic Python library provides convenient access to the Anthropic REST API from any Python 3.8+
  application. It 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 [docs.anthropic.com](https://docs.anthropic.com/claude/reference/). The full API of this library can be found in [api.md](https://github.com/anthropics/anthropic-sdk-python/tree/main/api.md).



  ```sh

  pip install anthropic
  ```



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

  ```python
  import os
  from anthropic import Anthropic

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

  message = client.messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
  )
  print(message.content)
  ```

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



  Simply import `AsyncAnthropic` instead of `Anthropic` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from anthropic import AsyncAnthropic

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


  async def main() -> None:
      message = await client.messages.create(
          max_tokens=1024,
          messages=[
              {
                  "role": "user",
                  "content": "Hello, Claude",
              }
          ],
          model="claude-3-5-sonnet-latest",
      )
      print(message.content)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



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

  ```python
  from anthropic import Anthropic

  client = Anthropic()

  stream = client.messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
      stream=True,
  )
  for event in stream:
      print(event.type)
  ```

  The async client uses the exact same interface.

  ```python
  from anthropic import AsyncAnthropic

  client = AsyncAnthropic()

  stream = await client.messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
      stream=True,
  )
  async for event in stream:
      print(event.type)
  ```



  This library provides several conveniences for streaming messages, for example:

  ```py
  import asyncio
  from anthropic import AsyncAnthropic

  client = AsyncAnthropic()

  async def main() -> None:
      async with client.messages.stream(
          max_tokens=1024,
          messages=[
              {
                  "role": "user",
                  "content": "Say hello there!",
              }
          ],
          model="claude-3-5-sonnet-latest",
      ) as stream:
          async for text in stream.text_stream:
              print(text, end="", flush=True)
          print()

      message = await stream.get_final_message()
      print(message.to_json())

  asyncio.run(main())
  ```

  Streaming with `client.messages.stream(...)` exposes [various helpers for your convenience](https://github.com/anthropics/anthropic-sdk-python/tree/main/helpers.md) including accumulation & SDK-specific events.

  Alternatively, you can use `client.messages.create(..., stream=True)` which only returns an async iterable of the events in the stream and thus uses less memory (it does not build up a final message object for you).



  To get the token count for a message without creating it you can use the `client.beta.messages.count_tokens()` method. This takes the same `messages` list as the `.create()` method.

  ```py
  count = client.beta.messages.count_tokens(
      model="claude-3-5-sonnet-20241022",
      messages=[
          {"role": "user", "content": "Hello, world"}
      ]
  )
  count.input_tokens  # 10
  ```

  You can also see the exact usage for a given request through the `usage` response property, e.g.

  ```py
  message = client.messages.create(...)
  message.usage

  ```



  This SDK provides beta support for the [Message Batches API](https://docs.anthropic.com/en/docs/build-with-claude/message-batches) under the `client.beta.messages.batches` namespace.




  Message Batches take the exact same request params as the standard Messages API:

  ```python
  await client.beta.messages.batches.create(
      requests=[
          {
              "custom_id": "my-first-request",
              "params": {
                  "model": "claude-3-5-sonnet-latest",
                  "max_tokens": 1024,
                  "messages": [{"role": "user", "content": "Hello, world"}],
              },
          },
          {
              "custom_id": "my-second-request",
              "params": {
                  "model": "claude-3-5-sonnet-latest",
                  "max_tokens": 1024,
                  "messages": [{"role": "user", "content": "Hi again, friend"}],
              },
          },
      ]
  )
  ```




  Once a Message Batch has been processed, indicated by `.processing_status === 'ended'`, you can access the results with `.batches.results()`

  ```python
  result_stream = await client.beta.messages.batches.results(batch_id)
  async for entry in result_stream:
      if entry.result.type == "succeeded":
          print(entry.result.message.content)
  ```



  This SDK provides support for tool use, aka function calling. More details can be found in [the documentation](https://docs.anthropic.com/claude/docs/tool-use).



  This library also provides support for the [Anthropic Bedrock API](https://aws.amazon.com/bedrock/claude/) if you install this library with the `bedrock` extra, e.g. `pip install -U anthropic[bedrock]`.

  You can then import and instantiate a separate `AnthropicBedrock` class, the rest of the API is the same.

  ```py
  from anthropic import AnthropicBedrock

  client = AnthropicBedrock()

  message = client.messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello!",
          }
      ],
      model="anthropic.claude-3-5-sonnet-20241022-v2:0",
  )
  print(message)
  ```

  The bedrock client supports the following arguments for authentication

  ```py
  AnthropicBedrock(
    aws_profile='...',
    aws_region='us-east'
    aws_secret_key='...',
    aws_access_key='...',
    aws_session_token='...',
  )
  ```

  For a more fully fledged example see [`examples/bedrock.py`](https://github.com/anthropics/anthropic-sdk-python/blob/main/examples/bedrock.py).



  This library also provides support for the [Anthropic Vertex API](https://cloud.google.com/vertex-ai?hl=en) if you install this library with the `vertex` extra, e.g. `pip install -U anthropic[vertex]`.

  You can then import and instantiate a separate `AnthropicVertex`/`AsyncAnthropicVertex` class, which has the same API as the base `Anthropic`/`AsyncAnthropic` class.

  ```py
  from anthropic import AnthropicVertex

  client = AnthropicVertex()

  message = client.messages.create(
      model="claude-3-5-sonnet-v2@20241022",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hello!",
          }
      ],
  )
  print(message)
  ```

  For a more complete example see [`examples/vertex.py`](https://github.com/anthropics/anthropic-sdk-python/blob/main/examples/vertex.py).



  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 Anthropic 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 anthropic import Anthropic

  client = Anthropic()

  all_batches = []

  for batch in client.beta.messages.batches.list(
      limit=20,
  ):
      
      all_batches.append(batch)
  print(all_batches)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from anthropic import AsyncAnthropic

  client = AsyncAnthropic()


  async def main() -> None:
      all_batches = []
      
      async for batch in client.beta.messages.batches.list(
          limit=20,
      ):
          all_batches.append(batch)
      print(all_batches)


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


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.beta.messages.batches.list(
      limit=20,
  )

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


  ```



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

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

  All errors inherit from `anthropic.APIError`.

  ```python
  import anthropic
  from anthropic import Anthropic

  client = Anthropic()

  try:
      client.messages.create(
          max_tokens=1024,
          messages=[
              {
                  "role": "user",
                  "content": "Hello, Claude",
              }
          ],
          model="claude-3-5-sonnet-latest",
      )
  except anthropic.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except anthropic.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except anthropic.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

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



  > For more information on debugging requests, see [these docs](https://docs.anthropic.com/en/api/errors#request-id)

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

  ```python
  message = client.messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
  )
  print(message._request_id)  # req_018EeWyXxfu5pfWkrYcMdjWG
  ```

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



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

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

  ```python
  from anthropic import Anthropic


  client = Anthropic(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
  )
  ```



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

  ```python
  from anthropic import Anthropic


  client = Anthropic(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).messages.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

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



  We automatically send the `anthropic-version` header set to `2023-06-01`.

  If you need to, you can override it by setting default headers per-request or on the client object.

  Be aware that doing so may result in incorrect types and other unexpected or undefined behavior in the SDK.

  ```python
  from anthropic import Anthropic

  client = Anthropic(
      default_headers={"anthropic-version": "My-Custom-Value"},
  )
  ```





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

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

  ```shell
  $ export ANTHROPIC_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 anthropic import Anthropic

  client = Anthropic()
  response = client.messages.with_raw_response.create(
      max_tokens=1024,
      messages=[{
          "role": "user",
          "content": "Hello, Claude",
      }],
      model="claude-3-5-sonnet-latest",
  )
  print(response.headers.get('X-My-Header'))

  message = response.parse()  # get the object that `messages.create()` would have returned
  print(message.content)
  ```

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

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

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



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

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

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

  ```python
  with client.messages.with_streaming_response.create(
      max_tokens=1024,
      messages=[
          {
              "role": "user",
              "content": "Hello, Claude",
          }
      ],
      model="claude-3-5-sonnet-latest",
  ) 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) 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 anthropic import Anthropic, DefaultHttpxClient

  client = Anthropic(
      
      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 anthropic import Anthropic

  with Anthropic() 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/anthropics/anthropic-sdk-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 anthropic
  print(anthropic.__version__)
  ```



  Python 3.8 or higher.



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


pkgId: b70f80e288153d8e9d659a1010be7aea3f2ae5e3428e3f3126ab7e68a3b08c9e
name: python-antimeridian-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for antimeridian
url: https://pypi.org/project/antimeridian/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antimeridian-0.4.0-1.src.rpm
location_href: Packages/python-antimeridian-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI Status](https://img.shields.io/github/actions/workflow/status/gadomski/antimeridian/ci.yaml?style=for-the-badge&label=CI)](https://github.com/gadomski/antimeridian/actions/workflows/ci.yaml)
  [![Docs](https://img.shields.io/github/actions/workflow/status/gadomski/antimeridian/docs.yaml?style=for-the-badge&label=Docs)](https://www.gadom.ski/antimeridian/)
  [![PyPI](https://img.shields.io/pypi/v/antimeridian?style=for-the-badge)](https://pypi.org/project/antimeridian/)
  [![Conda Downloads](https://img.shields.io/conda/d/conda-forge/antimeridian?style=for-the-badge)](https://anaconda.org/conda-forge/antimeridian)
  [![GitHub](https://img.shields.io/github/license/gadomski/antimeridian?style=for-the-badge)](https://github.com/gadomski/antimeridian/blob/main/LICENSE)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg?style=for-the-badge)](https://github.com/gadomski/antimeridian/blob/main/CODE_OF_CONDUCT)

  [![status](https://joss.theoj.org/papers/2a6c626b3774c8310e46c05fdf8d10de/status.svg)](https://joss.theoj.org/papers/2a6c626b3774c8310e46c05fdf8d10de)
  [![DOI](https://zenodo.org/badge/626665725.svg)](https://doi.org/10.5281/zenodo.14335984)

  ![Demonstration image](./docs/img/complex-split.png)

  Fix shapes that cross the antimeridian.
  See [the documentation](https://antimeridian.readthedocs.io) for information about the underlying algorithm.
  Depends on [shapely](https://shapely.readthedocs.io) and [numpy](https://numpy.org/).

  Can fix:

  - Shapely [`Polygon`](https://shapely.readthedocs.io/en/stable/reference/shapely.Polygon.html#shapely.Polygon), [`MultiPolygon`](https://shapely.readthedocs.io/en/stable/reference/shapely.MultiPolygon.html#shapely.MultiPolygon), [`LineString`](https://shapely.readthedocs.io/en/stable/reference/shapely.LineString.html#shapely.LineString), and [`MultiLineString`](https://shapely.readthedocs.io/en/stable/reference/shapely.MultiLineString.html#shapely.MultiLineString) objects
  - GeoJSON [Polygons](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6), [MultiPolygons](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.7), [Features](https://datatracker.ietf.org/doc/html/rfc7946#section-3.2) and [FeatureCollections](https://datatracker.ietf.org/doc/html/rfc7946#section-3.3), as dictionaries
  - Anything that has a [`__geo_interface__`](https://gist.github.com/sgillies/2217756)



  ```shell
  python -m pip install antimeridian
  ```

  Then:

  ```python
  import antimeridian

  fixed = antimeridian.fix_geojson(geojson)
  ```

  We also have some utilities to create [bounding boxes](https://antimeridian.readthedocs.io/en/latest/api.html#antimeridian.bbox) and [centroids](https://antimeridian.readthedocs.io/en/latest/api.html#antimeridian.centroid) from antimeridian-crossing polygons and multipolygons.
  See [the documentation](https://www.gadom.ski/antimeridian/) for a complete API reference.



  Use the `cli` optional dependency to install the `antimeridian` CLI:

  ```shell
  python -m pip install 'antimeridian[cli]'
  antimeridian fix input.json > output.json
  ```



  Get [uv](https://docs.astral.sh/uv/getting-started/installation/).
  Then:

  ```shell
  git clone https://github.com/gadomski/antimeridian
  cd antimeridian
  uv sync
  ```

  We use [pytest](https://docs.pytest.org) for tests:

  ```shell
  uv run pytest
  ```

  To build and serve the docs locally:

  ```shell
  uv run mkdocs serve
  ```



  See [CONTRIBUTING.md](./CONTRIBUTING.md).



  [Apache-2.0](https://github.com/gadomski/antimeridian/blob/main/LICENSE)


pkgId: cc56cd68bc46aed4038bf85345352358e9aab4ac3efc3768e07fda43984cbaf6
name: python-antithesis-help
arch: noarch
version: 0.1.17
epoch: 0
release: 1
summary: Development documents and examples for antithesis
url: https://pypi.org/project/antithesis/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antithesis-0.1.17-1.src.rpm
location_href: Packages/python-antithesis-help-0.1.17-1.noarch.rpm
checksum_type: sha256
description:
  This library provides methods for Python programs to configure the [Antithesis](https://antithesis.com) platform. Functionality is grouped into the packages [`assert`](https://antithesis.com/docs/generated/sdk/python/antithesis/assertions.html) for defining new test properties, [`random`](https://antithesis.com/docs/generated/sdk/python/antithesis/random.html) for Antithesis input, and [`lifecycle`](https://antithesis.com/docs/generated/sdk/python/antithesis/lifecycle.html) for controlling the Antithesis simulation.

  For general usage guidance see the [Antithesis Python SDK Documentation](https://antithesis.com/docs/using_antithesis/sdk/python/)

rpm_license:
  MIT License  Copyright (c) 2024 Antithesis, LLC  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: 4ec02b177b081965d3dd3c0243364cd66dac4bb6af68bf5da74317e0d4859c1c
name: python-ants-fts-help
arch: noarch
version: 0.1.13
epoch: 0
release: 1
summary: Development documents and examples for ants-fts
url: https://ants.abc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ants-fts-0.1.13-1.src.rpm
location_href: Packages/python-ants-fts-help-0.1.13-1.noarch.rpm
checksum_type: sha256
description:
  This repository is used to extract features from Antsomi's features.



  ```python
  import pandas as pd
  from datetime import datetime, timedelta
  from ants_extractor.IntervalExtractor import IntervalExtractor
  from ants_extractor.SkewnessScoreExtractor import SkewnessScoreExtractor
  from ants_extractor.DatetimeExtractor import DatetimeExtractor
  from ants_extractor.DeductionExtractor import DeductionExtractor
  from ants_extractor.PurchasingPowerExtractor import PurchasingPowerExtractor
  from ants_extractor.RFMExtractor import RFMExtractor
  from datetime import datetime, timedelta
  import warnings
  warnings.filterwarnings('ignore')

  data = {'customer_phone': {
    35452:  '640327a34',
    40030:  '640327a34',
    54858:  'be3e7573a',
    72959:  'be3e7573a',
    73009:  'be3e7573a',
    84052:  '89a90516c',
    85677:  '89a90516c',
    99817:  'be3e7573a',
    106287: 'be3e7573a',
    123339: '89a90516c',
    134011: '89a90516c',
    150009: '89a90516c',
    168649: 'be3e7573a',
    200112: '640327a34',
    228401: '640327a34',
    234409: '640327a34'},
   'date_created': {35452: pd.Timestamp('2024-11-10 10:02:19'),
    40030: pd.Timestamp('2024-11-06 12:30:11'),
    54858: pd.Timestamp('2024-10-28 20:13:48'),
    72959: pd.Timestamp('2024-09-20 19:05:52'),
    73009: pd.Timestamp('2024-09-19 21:53:27'),
    84052: pd.Timestamp('2024-09-24 18:39:17'),
    85677: pd.Timestamp('2024-09-24 18:33:07'),
    99817: pd.Timestamp('2024-08-24 20:21:43'),
    106287: pd.Timestamp('2024-09-29 20:27:43'),
    123339: pd.Timestamp('2024-05-01 14:42:02'),
    134011: pd.Timestamp('2024-06-14 17:10:20'),
    150009: pd.Timestamp('2024-05-01 13:37:05'),
    168649: pd.Timestamp('2024-03-10 20:22:56'),
    200112: pd.Timestamp('2024-04-19 18:40:13'),
    228401: pd.Timestamp('2024-02-19 19:14:53'),
    234409: pd.Timestamp('2024-04-22 12:07:14')},
   'discount_amount': {35452: 0.0,
    40030: 0.0,
    54858: 75000.0,
    72959: 100000.0,
    73009: 84000.0,
    84052: 108000.0,
    85677: 1000000.0,
    99817: 174500.0,
    106287: 187500.0,
    123339: 0.0,
    134011: 395000.0,
    150009: 150000.0,
    168649: 179000.0,
    200112: 0.0,
    228401: 100000.0,
    234409: 0.0},
   'subtotal_amount': {35452: 100000.0,
    40030: 1500000.0,
    54858: 750000.0,
    72959: 144000.0,
    73009: 840000.0,
    84052: 1870000.0,
    85677: 1785000.0,
    99817: 1745000.0,
    106287: 1875000.0,
    123339: 90000.0,
    134011: 2290000.0,
    150009: 10745000.0,
    168649: 1790000.0,
    200112: 850000.0,
    228401: 1700000.0,
    234409: 0.0},
   'revenue': {35452: 100000.0,
    40030: 1500000.0,
    54858: 675000.0,
    72959: 44000.0,
    73009: 756000.0,
    84052: 1762000.0,
    85677: 785000.0,
    99817: 1570500.0,
    106287: 1687500.0,
    123339: 90000.0,
    134011: 1895000.0,
    150009: 10595000.0,
    168649: 1611000.0,
    200112: 850000.0,
    228401: 1600000.0,
    234409: 0.0}}
  df = pd.DataFrame(data)
  fts_01 = IntervalExtractor.extract(df, ['customer_phone'], 'date_created')
  fts_02 = SkewnessScoreExtractor.extract(df, ['customer_phone'], 'date_created');
  fts_03 = DatetimeExtractor.extract(df, ['customer_phone'], 'date_created');
  fts_04 = DeductionExtractor.extract(df, ['customer_phone'], 'discount_amount', 'subtotal_amount');
  fts_05 = PurchasingPowerExtractor.extract(df, ['customer_phone'], "revenue");
  fts_06 = RFMExtractor.extract(df, ['customer_phone'], "date_created", "revenue", "2024-12-15 00:00:00");
  fts = fts_01.merge(fts_02, how="left").merge(fts_03,how='left').merge(fts_04,how='left').merge(fts_04,how='left').merge(fts_05,how='left').merge(fts_06,how='left');

  fts.round(3).T.to_markdown()
  |:---------------------------|:----------|:-----------|:------------|
  | customer_phone             | 640327a34 | 89a90516c  | be3e7573a   |
  | _cnt                       | 5         | 5          | 6           |
  | _avg_itv                   | 66.154    | 36.552     | 46.399      |
  | _var_itv                   | 8441.535  | 2338.825   | 4681.767    |
  | _skewness_score            | 0.415     | 0.366      | -2.106      |
  | _weekend_rate              | 0.2       | 0.0        | 0.5         |
  | _weekday_rate              | 0.8       | 1.0        | 0.5         |
  | _monday_rate               | 0.4       | 0.0        | 0.167       |
  | _tuesday_rate              | 0.0       | 0.4        | 0.0         |
  | _wednesday_rate            | 0.2       | 0.4        | 0.0         |
  | _thurday_rate              | 0.0       | 0.0        | 0.167       |
  | _friday_rate               | 0.2       | 0.2        | 0.167       |
  | _saturday_rate             | 0.0       | 0.0        | 0.167       |
  | _sunday_rate               | 0.2       | 0.0        | 0.333       |
  | _am_rate                   | 0.2       | 0.0        | 0.0         |
  | _pm_rate                   | 0.8       | 1.0        | 1.0         |
  | _dawn_rate                 | 0.0       | 0.0        | 0.0         |
  | _morning_rate              | 0.2       | 0.0        | 0.0         |
  | _afternoon_rate            | 0.4       | 0.6        | 0.0         |
  | _evening_rate              | 0.4       | 0.4        | 1.0         |
  | _midnight_rate             | 0.0       | 0.0        | 0.0         |
  | _avg_deduction             | 0.015     | 0.161      | 0.199       |
  | _var_deduction             | 0.001     | 0.054      | 0.059       |
  | _ratio_discount_camp_usage | 0.2       | 0.8        | 1.0         |
  | _total_revenue             | 4050000.0 | 15127000.0 | 6344000.0   |
  | _aov                       | 810000.0  | 3025400.0  | 1057333.333 |
  | _median_ov                 | 850000.0  | 1762000.0  | 1163250.0   |
  | _percentage_rank           | 0.333     | 1.0        | 0.667       |
  | _recency                   | 34.582    | 81.223     | 47.157      |
  | _frequency                 | 5         | 5          | 6           |
  | _monetary                  | 4050000.0 | 15127000.0 | 6344000.0   |

  ```


pkgId: f5a3090a3b83c603e737ac3317ea9bbc1493f15f2571dda33bce08052c4251cd
name: python-antsibull-docutils-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for antsibull-docutils
url: https://pypi.org/project/antsibull-docutils/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antsibull-docutils-1.1.0-1.src.rpm
location_href: Packages/python-antsibull-docutils-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) Ansible Project
  GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
  SPDX-License-Identifier: GPL-3.0-or-later
  -->


  [![Discuss on Matrix at #antsibull:ansible.com](https://img.shields.io/matrix/antsibull:ansible.com.svg?server_fqdn=ansible-accounts.ems.host&label=Discuss%20on%20Matrix%20at%20%23antsibull:ansible.com&logo=matrix)](https://matrix.to/#/#antsibull:ansible.com)
  [![Nox badge](https://github.com/ansible-community/antsibull-docutils/workflows/nox/badge.svg?event=push&branch=main)](https://github.com/ansible-community/antsibull-docutils/actions?query=workflow%3A%22nox%22+branch%3Amain)
  [![Codecov badge](https://img.shields.io/codecov/c/github/ansible-community/antsibull-docutils)](https://codecov.io/gh/ansible-community/antsibull-docutils)
  [![REUSE status](https://api.reuse.software/badge/github.com/ansible-community/antsibull-docutils)](https://api.reuse.software/info/github.com/ansible-community/antsibull-docutils)

  A Python library with some [docutils](https://www.docutils.org/) helpers used by Antsibull tools.

  antsibull-docutils is covered by the [Ansible Code of Conduct](https://docs.ansible.com/ansible/latest/community/code_of_conduct.html).



  In CI, compatibility with docutils 0.18+ is tested. Older versions of docutils might work as well, depending on your use-case. The tests do not pass for 0.16 and 0.17, as these versions emit different IDs and HTML (for tables). 0.16 also handles code blocks differently, and they will not be emitted with the MarkDown renderer.



  Install and run `nox` to run all tests. That's it for simple contributions!
  `nox` will create virtual environments in `.nox` inside the checked out project
  and install the requirements needed to run the tests there.

  To run specific tests:

  1. `nox -e test` to only run unit tests;
  2. `nox -e coverage` to display combined coverage results after running `nox -e
     test integration`;
  3. `nox -e lint` to run all linters and formatters at once;
  4. `nox -e formatters` to run `isort` and `black`;
  5. `nox -e codeqa` to run `flake8`, `pylint`, `reuse lint`, and `antsibull-changelog lint`;
  6. `nox -e typing` to run `mypy`.



  1. Run `nox -e bump -- <version> <release_summary_message>`. This:
     * Bumps the package version in `src/antsibull_docutils/__init__.py`.
     * Creates `changelogs/fragments/<version>.yml` with a `release_summary` section.
     * Runs `antsibull-changelog release` and adds the changed files to git.
     * Commits with message `Release <version>.` and runs `git tag -a -m 'antsibull-docutils <version>' <version>`.
     * Runs `hatch build --clean`.
  2. Run `git push` to the appropriate remotes.
  3. Once CI passes on GitHub, run `nox -e publish`. This:
     * Runs `hatch publish`;
     * Bumps the version to `<version>.post0`;
     * Adds the changed file to git and run `git commit -m 'Post-release version bump.'`;
  4. Run `git push --follow-tags` to the appropriate remotes and create a GitHub release.



  Unless otherwise noted in the code, it is licensed under the terms of the GNU
  General Public License v3 or, at your option, later. See
  [LICENSES/GPL-3.0-or-later.txt](https://github.com/ansible-community/antsibull-docutils/tree/main/LICENSE)
  for a copy of the license.

  The repository follows the [REUSE Specification](https://reuse.software/spec/) for declaring copyright and
  licensing information. The only exception are changelog fragments in ``changelog/fragments/``.


pkgId: c835cf4b6ba458dfe9d40015ca16eb31f6c6fba632bfa50008bc4126a8ba4107
name: python-anygen-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for anygen
url: https://github.com/macabdul9/AnyGen
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-anygen-1.0.2-1.src.rpm
location_href: Packages/python-anygen-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  `AnyGen` is a minimal Python library that unifies text generation tasks using Hugging Face, OpenAI, and Gemini models. It offers a minimalistic and unified pipeline for loading models and generating outputs with ease and efficiency.


  - Support for Hugging Face models
  - Support for OpenAI's GPT models
  - Support for Gemini models
  - Easy-to-use interface for text generation



  You can install `AnyGen` from PyPI:
  ```bash
  pip install -U anygen
  ```


  Clone the repository and install it manually:
  ```bash
  git clone https://github.com/macabdul9/AnyGen.git
  cd AnyGen
  pip install .
  ```


  Ensure the following libraries are installed:
  ```bash
  pip install transformers google-generativeai requests openai
  ```


  Below are step-by-step instructions to generate text using each model type.


  ```python
  from anygen import AnyGen


  model_name_or_path = "meta-llama/Llama-3.2-1B-Instruct"  # Replace with your Hugging Face model name
  device = "cuda"  # Use "cpu" if GPU is not available
  hf_generator = AnyGen(model_type="huggingface", model_name_or_path=model_name_or_path, device=device)


  prompt = "Write python code for binary search"
  generated_text = hf_generator.generate(prompt)
  print(generated_text)
  ```


  ```python
  from anygen import AnyGen


  api_key_fp = "openai_keys.json"  # Path to your OpenAI credentials file
  openai_generator = AnyGen(model_type="openai", api_key_fp=api_key_fp)


  prompt = "Write python code for binary search"
  generated_text = openai_generator.generate(prompt)
  print(generated_text)
  ```


  ```python
  from anygen import AnyGen


  api_key_fp = "gemini_keys.json"  # Path to your Gemini credentials file
  gemini_generator = AnyGen(model_type="gemini", api_key_fp=api_key_fp)


  prompt = "Write python code for binary search"
  generated_text = gemini_generator.generate(prompt)
  print(generated_text)
  ```


  ```python
  from anygen import AnyGen


  api_key_fp = "openai_keys.json"  # Example for OpenAI
  openai_generator = AnyGen(model_type="openai", api_key_fp=api_key_fp)


  prompt = "Write python code for binary search"
  parameters = {"temperature": 0.7, "max_tokens": 512}
  generated_text = openai_generator.generate(prompt, parameters)
  print(generated_text)
  ```


  Both OpenAI and Gemini models require an API key stored in a JSON file. Below is an example format:

  `openai_keys.json`:
  ```json
  {
      "gpt-4o-mini": {
          "api_key": "your-openai-api-key",
          "endpoint": "your_endpoint"
      }
  }
  ```

  `gemini_keys.json`:
  ```json
  {
      "gemini-model-name": {
          "api_key": "your-gemini-api-key"
      }
  }
  ```


  - `temperature`: Controls the randomness of the output. Higher values produce more random results.
  - `max_tokens`: The maximum number of tokens to generate.
  - `top_p`: The cumulative probability of the top tokens to sample from.
  - `top_k`: The number of highest probability vocabulary tokens to keep for top-k-filtering.
  - `beam_size`: The number of beams to use for beam search.


  Feel free to submit issues and/or contribute to this repository!


  This project is licensed under the MIT License.


pkgId: c410a62d3ba5c35bbf431b87c2077c0063e72f9d80f9af2d0e8960e800311467
name: python-aoc-helper-help
arch: noarch
version: 1.13.1
epoch: 0
release: 1
summary: Development documents and examples for aoc-helper
url: https://github.com/Starwort/aoc_helper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aoc-helper-1.13.1-1.src.rpm
location_href: Packages/python-aoc-helper-help-1.13.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  @salt-die's aoc_helper package, rewritten from the ground up



  This project aims to be compliant with the [Advent of Code Automation Guidelines](https://www.reddit.com/r/adventofcode/wiki/faqs/automation). Here are the strategies it uses:

  - Once inputs are downloaded, they are cached in `~/.config/aoc_helper/YEAR/DAY.in` (or a similar path for Windows users) - [`interface.fetch`](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L97-L155) (lines [107-108](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L107-L108), [152](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L152))
  - The `User-Agent` header declares the package name, version, and my contact info - [`data.HEADERS`](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/data.py#L20-L25), [used](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L118) [in](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L139) [every](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L210) [outbound](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L266) [request](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L341)
  - If requesting input before the puzzle unlocks, [the library will wait for unlock before sending any requests](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L130-L133) (except on day 1, where it will send a request to validate the session token)
  - If sending an answer too soon after an incorrect one, [the library will wait the cooldown specified in the response](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L231-L234) (sending only one extra request; it *is* however possible for a user to send multiple requests in quick succession, by repeatedly calling `submit` before the cooldown is over)
  - Advent of Code will not be queried at all [if the puzzle has already been solved](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L182-L190) or [if an answer has already been submitted](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L193-L199)
  - If, for some reason, the user decides they wish to clear their cache (for example, if they believe their input to be corrupted) they can do so by using the [`aoc clean`](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/main.py#L91-L121) command.



  Install `aoc_helper` with `pip`!

  ```bash
  pip install aoc_helper

  pip install aoc_helper[cli]

  pip install aoc_helper[fancy]

  pip install aoc_helper[cli,fancy]

  pip install aoc_helper[full]
  ```



  When you first use any function that interfaces with Advent of Code, you will be prompted to enter your session token.

  Your session token is stored as a *HTTPOnly cookie*. This means there is no way of extracting it with JavaScript, you either must
  use a browser extension such as [EditThisCookie](http://www.editthiscookie.com/), or follow [this guide](https://github.com/wimglenn/advent-of-code-wim/issues/1)

  This token is stored in `~/.config/aoc_helper/token.txt` (`C:\Users\YOUR_USERNAME\.config\aoc_helper\token.txt` on Windows,
  probably), and other `aoc_helper` data is stored in this folder (such as your input and submission caches).

  If, for whatever reason, you feel the need to clear your caches, you can do so by deleting the relevant folders in `aoc_helper`'s
  configuration folder.



  `aoc_helper` has a command line interface, accessed by running `python -m aoc_helper` or `aoc` followed by the command line arguments. Its commands are detailed below:



  `aoc fetch <DAY> [--year <YEAR>]`

  Fetch your input for a given day.
  YEAR is the current year by default.

  Examples (written during 2020):

  ```bash
  aoc fetch 2 # fetches input for 2020 day 2
  aoc fetch 24 --year 2019 # fetches input for 2019 day 24
  ```



  `aoc submit <DAY> <PART> <ANSWER> [--year <YEAR>]`

  Submits your answer for a given day and part.
  YEAR is the current year by default.

  Examples (written during 2020):

  ```bash
  aoc submit 2 1 643 # submits 643 as the answer for 2020 day 2 part 1
  aoc submit 24 1 12531574 --year 2019 # submits 12531574 as the answer for 2019 day 2 part 1
  ```



  `aoc template <DAYS> [--year YEAR]`

  Generates templates for your advent of code folder.
  YEAR is the current year by default.

  `DAYS` must be a comma-separated list of date ranges, which may be one of:

  - `all`, to generate a template for every day in the year
  - A single integer in the range \[1, 25] to generate a single template
  - A pair of integers in the range \[1, 25], separated with a hyphen, to generate template for each day in the range

  Note that even if a day is included in the list of days more than once (including implicitly, within ranges or `all`), it will only be generated once.

  Filenames are formatted as `day_NUMBER.py` where `NUMBER` is the 2-digit day number.

  Examples (written during 2020):

  ```bash
  aoc template all # generates day_01.py to day_25.py, with aoc_helper methods referencing 2020, in the current folder
  aoc template 3 --year 2019 # generates day_03.py, with aoc_helper methods referencing 2019, in the current folder
  aoc template 3-5 --year 2017 # generates day_03.py to day_05.py, with aoc_helper methods referencing 2017, in the current folder
  aoc template 3-5,7,9,9-10 # generates files for days 3, 4, 5, 7, 9, and 10
  ```


pkgId: f0c53acdb57ac60411291dc94a2c2c531ec6271e1eadf7bc9938209a29b39dd3
name: python-aoc-tiles-help
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: Development documents and examples for aoc-tiles
url: https://pypi.org/project/aoc-tiles/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aoc-tiles-0.6.3-1.src.rpm
location_href: Packages/python-aoc-tiles-help-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  This script creates a graphic for each day for each year of the Advent of Code.
  A tile is an image which represents both parts of a day, it looks like this:

  ![AoC Tiles](examples/showcase.png)

  It uses the personal [AoC Leaderboard](https://adventofcode.com/2023/leaderboard/self) to get the data for each day using your cookie.




  For this year (2023) I have rewritten this script to make it a lot easier to use.
  Now you **only** need to install `pre-commit`, add a pre-commit hook and add two HTML comments to your README. More details below.



  ```bash
  pip install pre-commit
  ```

  or the more modern way below (either is fine, modern pip in Python 3.11+
  will [not allow the above command to run though](https://veronneau.org/python-311-pip-and-breaking-system-packages.html)):

  ```bash

  pipx install pre-commit
  ```



  Add this pre-commit hook to your `.pre-commit-config.yaml` (create it, if you don't have it):

  ```yaml
  repos:
      - repo: https://github.com/LiquidFun/aoc_tiles
        rev: 0.6.2
        hooks:
            - id: aoc-tiles
              
              
              
              
              
              
              
              
              
              
  ```

  Now **install** the hook with:

  ```
  pre-commit install --hook-type post-commit
  ```

  The **--hook-type post-commit** flag is important, otherwise the hook will not run.

  There are a lot more flags, see the customization section for all of them.
  Note that you have to prepend `- ` to the flags if you add it to the .pre-commit config, due to the yaml syntax.
  Auto add tiles is recommended as it will automatically add the tiles to your git repository, otherwise you might
  forget it and the tiles will not be updated. Note that this will amend your just created commit. If you do not want
  this, remove that flag.




  Add this to your .gitignore:

  ```
  .aoc_tiles/*
  !.aoc_tiles/tiles/
  ```

  Now add `<!-- AOC TILES BEGIN -->` and `<!-- AOC TILES END -->` in your README, everything between these 2 tags
  will always be replaced by the script, so do not add additional information there. Note that these are HTML comments,
  so they will not be visible in the rendered README.

  Now you are done and the basic version should trigger once you commit with git.



  If you care about your submit-time and rank, you need to add your session cookie to the script.
  By default, if no session cookie is found, checkmarks will be used instead of the time and rank.
  Add in the `.aoc_tiles` directory as `session.cookie`.
  Make sure that this file is in your `.gitignore`, i.e. do **not** add it to `.aoc-tiles/tiles/`!
  It should contain a single line, the "session" cookie from https://adventofcode.com when you are logged in.
  No prefix is needed, only the string of length 128.
  It resets after 30 days, so you need to renew it for each year.




  There are various flags which can be set to change the look of your tiles. Some of them are listed here
  with examples showing how it changes the look.

  <!-- **Note that in order to regenerate images you have to either delete the images or delete the .aoc-tiles-cache!** -->

  * `--what-to-show-on-right-side=`:

  | `auto` (default)                                         | `checkmark`               | `time_and_rank`                |
  |----------------------------------------------------------|---------------------------|--------------------------------|
  | `time_and_rank` if cookie is available, else `checkmark` | ![](examples/01checkmarks.png) | ![](examples/01basic.png) |

  * `--contrast-improvement-type=`:

  | `outline` (default)          | `dark`                 | `none`                 |
  |-----------------------------|--------------------------|--------------------------|
  | ![](examples/05outline.png) | ![](examples/05dark.png) | ![](examples/05none.png) |



  ```
    --what-to-show-on-right-side WHAT_TO_SHOW_ON_RIGHT_SIDE
      What information to display on the right side of each tile. 'checkmark' only displays a checkmark for each
      part if the day is solved. 'time_and_rank' displays the time and rank on the global leaderboard (requires
      session.cookie). 'loc' displays the number of lines of code of the solution (not implemented). 'auto' will use
      'time_and_rank' if session.cookie exists, otherwise 'checkmark'. Possible values:
      [auto,checkmark,time_and_rank] Default: "auto"

    --count-as-solved-when COUNT_AS_SOLVED_WHEN
      Condition to count a task as solved. Note that 'on_leaderboard', 'either' and 'both' require a session cookie.
      'auto' will use 'both' if session.cookie exists, otherwise 'file_exists'. Possible values:
      [auto,on_leaderboard,file_exists,either,both] Default: "auto"

    --language-sorting LANGUAGE_SORTING
      Preferred language extensions order for sorting. For example 'py,rs,js' will make Python solutions appear
      first, then Rust, then JavaScript, then everything else (alphabetically).

    --create-all-days     Whether to create entries for all days upfront. Default: "False"

    --auto-add-tiles-to-git AUTO_ADD_TILES_TO_GIT
      Whether to automatically add the tile images to git. 'add' will add new files, 'amend' will add and amend the
      commit with the new files. 'no' will not add the files to git. Possible values: [no,add,amend] Default: "no"

    --only-use-solutions-in-git
      If true, only solutions will be considered which are tracked by git (git added), otherwise all solutions will
      be used. This is useful for example to ignore auto-generatedfiles, like '.d' in Rust or '.o' files in C++.
      Default: "True"

    --show-total-stars-for-all-years SHOW_TOTAL_STARS_FOR_ALL_YEARS
      Whether to add an additional header in front which shows the total collected stars for all years.'auto' will
      only show the header if you have stars in at least 3 separate years. 'yes' will always show the header. 'no'
      will never show the header. Possible values: [no,auto,yes] Default: "auto"

    --year-pattern YEAR_PATTERN
      Regex pattern for matching years. This extracts the first group as the year and parses it as an integer. Make
      sure that other numbers are not matched by this pattern! For example, using negative lookbehind and lookaheads
      is encouraged to avoid matching longer numbers! Default: "(?<!\d)(20[123]\d)(?!\d)"

    --day-pattern DAY_PATTERN
      Regex pattern for matching days. Same as year_pattern. Default: "(?<!\d)([012]?\d)(?!\d)"

    --exclude-patterns EXCLUDE_PATTERNS
      A list of comma separated glob patterns to ignore when looking for solutions. Listing the paths works too. For
      example: '*.py,*.js', '2023/05/05.c' or '2021/**.py'.Make sure to escape the patterns with single quotes when
      running from the shell! Do NOT escape them when using the flag in the yaml! Otherwise the qoute will be part
      of the pattern.

    --overwrite-year OVERWRITE_YEAR
      If your repository only contains a single year and it cannot be parsed from the path, then you should use this
      to overwrite the year. Every solution is presumed to be for this year. Default: "None"

    --contrast-improvement-type CONTRAST_IMPROVEMENT_TYPE
      Some languages have very light colors and are hard to see with a white font. Here you can choose how the text
      color changes when the background is too light. 'dark' makes the font dark, 'outline' adds a black outline.
      Possible values: [none,outline,dark] Default: "outline"

    --contrast-improvement-threshold CONTRAST_IMPROVEMENT_THRESHOLD
      Threshold for contrast improvement feature (between 0 and 255). Default: "30"

    --outline-color OUTLINE_COLOR
      Color used for outlining elements. Default: "#6C6A6A"

    --not-completed-color NOT_COMPLETED_COLOR
      Color to signify incomplete tasks. Default: "#333333"

    --top100-color TOP100_COLOR
      Color to highlight top 100 ranking. Only used if sessioncookie is provided. Default: "#ffdd00"

    --text-color TEXT_COLOR
      Text color. Default: "#FFFFFF"

    --tile-width-px TILE_WIDTH_PX
      Width of tiles in pixels. You likely don't needto change this. Default: "161px"
  ```


pkgId: 6ccacb074daed142664fd1bda751187c2a91f324fcd9ae13bfc210eaa47d6033
name: python-aomaker-help
arch: noarch
version: 2.4.13
epoch: 0
release: 1
summary: Development documents and examples for aomaker
url: https://github.com/ae86sen/aomaker
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aomaker-2.4.13-1.src.rpm
location_href: Packages/python-aomaker-help-2.4.13-1.noarch.rpm
checksum_type: sha256
description:
  ![jRL5nO.md.png](https://s1.ax1x.com/2022/07/13/jRL5nO.md.png)

  > Quickly Arrange,Quickly Test!

  [![pyversions](https://img.shields.io/pypi/pyversions/httprunner.svg)](https://pypi.python.org/pypi/httprunner)
  [详细使用指南🧭](https://aomaker.github.io/)



  **AoMaker**，即 Api object Maker，那什么是**API Object**呢？

  **API Object**是**Page Object**设计模式在接口测试上的一种延伸，顾名思义，这里是将各种基础接口进行了一层抽象封装，将其作为 object，通过不同的 API 对象调用来组装成不同的业务流场景。

  举个简单例子：

  有一个购物车功能，它有如下接口：

  - add，将物品添加到购物车
  - list，查看购物车内所有物品
  - delete，清空购物车内所有物品

  那么，我们通过`ao` 的思想来封装这个功能所有接口：

  ```python
      class ShoppingTrolley:
          def add(self):
              """添加物品到购物车"""
              pass

          def delete(self):
              """清空购物车"""
              pass

          def list(self):
              """查看购物车内所有物品"""
              pass
  ```

  当我们需要测试购物车的增-查-删流程时，只需要实例化`ShoppingTrolley` 类，通过调用对应的接口对象，即可完成业务场景的组装：

  ```python
      class TestShoppingTrolley:
          def test_shopping(self):
              """测试购物车增-查-删流程"""
              st = ShoppingTrolley()
              
              st.add()
              
              st.list()
              
              st.delete()
  ```

  解释了**API Object**，那**Maker**又怎么理解呢？

  **Maker**其实就是框架本身提供各种辅助手段帮助快速的去编排`ao` 和`case` 。

  **什么手段？怎么辅助呢？**
  栗子：
  ```python
  class Instance(BaseApi):

      @aomaker.dependence(image_api.describe_images, "describe_images")
      @aomaker.dependence("instance.describe_instance_types", "instance_types", imp_module="apis.iaas.instance.instance")
      @aomaker.async_api(ins_listener, "instances")
      def create_instance(self, test_data: dict, **kw_params):
          """创建主机"""

          kw_params["describe_images"] = self.cache.get_by_jsonpath("describe_images", "$..image_id")
          kw_params["instance_types"] = self.cache.get_by_jsonpath("instance_types", "$..instance_type_id")

          kw_params["cpu"] = test_data["cpu"]
          kw_params["memory"] = test_data["memory"]

          params_model = model.RunInstanceModel(**kw_params)
          resp = self.send_http(params_model)

          return resp
  ```
  对于一个接口的封装，其实核心的处理就是接口参数进行参数化处理，一个接口的参数一般可分为以下三种情况：
  - 常量：即不需要参数化的参数，写死即可
  - 上游依赖变量：即该参数需要调用另一个接口，从其返回值中提取
  - 测试数据：即需要从用例层传入的测试数据，一般会做数据驱动

  其中，对于上游依赖变量的处理是每个接口测试框架必须要面对的问题，`aomaker`的解法是通过`@dependence`装饰器去标注该接口的依赖，让其自动识别并调用依赖，并结合`aomaker`特殊的变量管理机制去灵活存取依赖值。

  此外，如果该接口是一个异步接口，那么还需要对其进行异步处理，`aomaker`的解法依然是通过装饰器标注，通过`@async_api`指定该接口的异步处理函数，在接口调用并正常收到返回后，将进行异步处理。

  通过上面的栗子可以看出，`aomaker`对于一个接口的定义，包括：
  - 前置：接口的上游依赖调用（同一个依赖只会调用一次）
  - 定义：对接口进行http协议填充，包括接口参数的参数化处理、请求发送（`headers`等公共数据隐藏在基类中自动处理）
  - 后置（如果是异步）：在接口调用完成并得到正常反馈后，开始自动进行轮询处理，直到得到异步任务完成的反馈

  这样的目的是为了保证接口定义功能单一、简洁，方法中只有接口的定义，没有过多的数据处理、逻辑判断等操作，另一方面，提高了复用性，不用反复处理前后置并且同样的依赖不会重复调用。

  当完成了这样一个`ao`的定义，就可以供上层（用例层或业务层）调用，在调用层不用再去关心该怎么处理它的依赖关系，该怎么处理后置操作，只需要调用`ao`这块积木去组装你的用例或业务即可，内部 细节全由框架自动帮你完成。

  `aomaker` 早期1.0版本中，其实还提供了两种自动生成`ao`和`case`的方式：
  - 通过`yaml`模板自动生成（包括`har`和`swagger`转换）
  - 通过流量录制自动生成

  当时受`httprunner` 的影响较大，陷入了一些思维定式，觉得通过模板转换自动生成代码感觉很高效，但经过长时间的项目实践，发现模板会有很多条条款款的限制，每个项目又不尽相同，这样反而限制了灵活性（没有说`httprunner`不好的意思，hr设计得非常优秀，收益良多，可以说没有hr就没有aomaker），处处掣肘不能放飞自我策马奔腾。所以后来在2.0版本中，基本弃用了这两种方式（但代码依然保留，或许有人喜欢呢），还是更推荐直接撸代码来得快，`aomaker`只是提供了一些辅助工具，帮你撸得更快更稳更方便，可扩展性还是非常高的，不会限制你的发挥。



  一款基于`pytest` ，将接口通过**ao 对象**方式来编排管理的接口自动化框架，让测试人员能快速完成自动化项目搭建和高可维护性脚本的编写，快速开始测试。



  - 提供 CLI 命令
  - 提供脚手架一键安装，开箱即用
  - 变量管理简单
  - 简洁处理依赖和异步接口
  - 不同粒度的重试机制
  - 三种方式快速编写 ao 和 case
  - 支持多进程和多线程
  - 易扩展
  - 丰富的断言
  - 支持流量录制
  - 支持 pytest 所有用法和插件
  - allure 报告优化
  - 测试报告消息通知
  - ...



  如果对该框架感兴趣以及有更多好的想法，欢迎交流探讨~

  [![v9XorQ.jpg](https://s1.ax1x.com/2022/07/28/v9XorQ.jpg)](https://imgtu.com/i/v9XorQ)


pkgId: 295ce8aa716a228f08f3d2a20ce25da2852d5638860464feda27d32cb2ccb3e6
name: python-aopc-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for aopc
url: https://pypi.org/project/aopc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aopc-0.1.0-1.src.rpm
location_href: Packages/python-aopc-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The `Aopc` package provides a framework for evaluating model faithfulness using the Area Over the Perturbation Curve (AOPC) metric. It supports Hugging Face models and datasets, specifically tailored for sequence label classification tasks.



  Install the package via pip:

  ```bash
  pip install aopc
  ```



  - **Support for Hugging Face models and datasets**: Utilize pre-trained models and standard datasets seamlessly.
  - **AOPC Evaluation**: Calculate AOPC metrics for attributions.
  - **Beam Size Suggestion**: Automatically estimate optimal beam sizes for normalized AOPC using our approximation method.





  Start by configuring `Aopc` with a Hugging Face model, such as `prajjwal1/bert-tiny`:

  ```python
  from aopc import Aopc

  aopc = Aopc(model_id="prajjwal1/bert-tiny")
  ```



  Load your dataset with Hugging Face's `datasets` library and evaluate it with `Aopc`:
  > **Note**: If the dataset has not been tokenized `Aopc` will take care of it.
  ```python
  import datasets


  dset = datasets.load_dataset("stanfordnlp/imdb")


  new_dset = aopc.evaluate(dset)
  ```
  **Note**: `Aopc.evaluate()` allow either a dictionary, datasets.Dataset or datasets.DatasetDict as input.


  Estimate

  ```python
  new_dset = aopc.evaluate(dset, normalization="exact")
  ```


  Calculate the suggested beam size for normalized AOPC approximation:

  ```python

  beam_size = aopc.get_suggested_beam_size(dset)


  new_dset = aopc.evaluate_dset(dset, normalization="approx", beam_size=beam_size)
  ```



  This project is licensed under the MIT License.


pkgId: 74ecd72dbf693521d5560b47ecd2ecb71674ae4e84e3ac646b7ddff1983ae8a3
name: python-apache-airflow-help
arch: noarch
version: 2.10.4
epoch: 0
release: 1
summary: Development documents and examples for apache-airflow
url: https://airflow.apache.org/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apache-airflow-2.10.4-1.src.rpm
location_href: Packages/python-apache-airflow-help-2.10.4-1.noarch.rpm
checksum_type: sha256
description:
  <!--
  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.
  -->

  <!-- PLEASE DO NOT MODIFY THIS FILE. IT HAS BEEN GENERATED AUTOMATICALLY FROM THE `README.md` FILE OF THE
  PROJECT BY THE `generate-pypi-readme` PRE-COMMIT. YOUR CHANGES HERE WILL BE AUTOMATICALLY OVERWRITTEN.-->



  [![PyPI version](https://badge.fury.io/py/apache-airflow.svg)](https://badge.fury.io/py/apache-airflow)
  [![GitHub Build](https://github.com/apache/airflow/actions/workflows/ci.yml/badge.svg?branch=v2-10-test)](https://github.com/apache/airflow/actions/workflows/ci.yml?query=branch%3Av2-10-test)
  [![Coverage Status](https://codecov.io/gh/apache/airflow/graph/badge.svg?token=WdLKlKHOAU)](https://codecov.io/gh/apache/airflow)
  [![License](https://img.shields.io/:license-Apache%202-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0.txt)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/apache-airflow.svg)](https://pypi.org/project/apache-airflow/)
  [![Docker Pulls](https://img.shields.io/docker/pulls/apache/airflow.svg)](https://hub.docker.com/r/apache/airflow)
  [![Docker Stars](https://img.shields.io/docker/stars/apache/airflow.svg)](https://hub.docker.com/r/apache/airflow)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/apache-airflow)](https://pypi.org/project/apache-airflow/)
  [![Artifact HUB](https://img.shields.io/endpoint?url=https://artifacthub.io/badge/repository/apache-airflow)](https://artifacthub.io/packages/search?repo=apache-airflow)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Twitter Follow](https://img.shields.io/twitter/follow/ApacheAirflow.svg?style=social&label=Follow)](https://twitter.com/ApacheAirflow)
  [![Slack Status](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://s.apache.org/airflow-slack)
  [![Contributors](https://img.shields.io/github/contributors/apache/airflow)](https://github.com/apache/airflow/graphs/contributors)
  [![OSSRank](https://shields.io/endpoint?url=https://ossrank.com/shield/6)](https://ossrank.com/p/6)

  <picture width="500">
    <img
      src="https://github.com/apache/airflow/blob/19ebcac2395ef9a6b6ded3a2faa29dc960c1e635/docs/apache-airflow/img/logos/wordmark_1.png?raw=true"
      alt="Apache Airflow logo"
    />
  </picture>

  [Apache Airflow](https://airflow.apache.org/docs/apache-airflow/stable/) (or simply Airflow) is a platform to programmatically author, schedule, and monitor workflows.

  When workflows are defined as code, they become more maintainable, versionable, testable, and collaborative.

  Use Airflow to author workflows as directed acyclic graphs (DAGs) of tasks. The Airflow scheduler executes your tasks on an array of workers while following the specified dependencies. Rich command line utilities make performing complex surgeries on DAGs a snap. The rich user interface makes it easy to visualize pipelines running in production, monitor progress, and troubleshoot issues when needed.



  Apache Airflow is tested with:

  |             | Main version (dev)           | Stable version (2.10.4)      |
  |-------------|------------------------------|------------------------------|
  | Python      | 3.9, 3.10, 3.11, 3.12        | 3.8, 3.9, 3.10, 3.11, 3.12   |
  | Platform    | AMD64/ARM64(\*)              | AMD64/ARM64(\*)              |
  | Kubernetes  | 1.26, 1.27, 1.28, 1.29, 1.30 | 1.26, 1.27, 1.28, 1.29, 1.30 |
  | PostgreSQL  | 12, 13, 14, 15, 16           | 12, 13, 14, 15, 16           |
  | MySQL       | 8.0, 8.4, Innovation         | 8.0, Innovation              |
  | SQLite      | 3.15.0+                      | 3.15.0+                      |

  \* Experimental

  **Note**: MariaDB is not tested/recommended.

  **Note**: SQLite is used in Airflow tests. Do not use it in production. We recommend
  using the latest stable version of SQLite for local development.

  **Note**: Airflow currently can be run on POSIX-compliant Operating Systems. For development, it is regularly
  tested on fairly modern Linux Distros and recent versions of macOS.
  On Windows you can run it via WSL2 (Windows Subsystem for Linux 2) or via Linux Containers.
  The work to add Windows support is tracked via [#10388](https://github.com/apache/airflow/issues/10388), but
  it is not a high priority. You should only use Linux-based distros as "Production" execution environment
  as this is the only environment that is supported. The only distro that is used in our CI tests and that
  is used in the [Community managed DockerHub image](https://hub.docker.com/p/apache/airflow) is
  `Debian Bookworm`.



  Visit the official Airflow website documentation (latest **stable** release) for help with
  [installing Airflow](https://airflow.apache.org/docs/apache-airflow/stable/installation/),
  [getting started](https://airflow.apache.org/docs/apache-airflow/stable/start.html), or walking
  through a more complete [tutorial](https://airflow.apache.org/docs/apache-airflow/stable/tutorial/).

  > Note: If you're looking for documentation for the main branch (latest development branch): you can find it on [s.apache.org/airflow-docs](https://s.apache.org/airflow-docs/).

  For more information on Airflow Improvement Proposals (AIPs), visit
  the [Airflow Wiki](https://cwiki.apache.org/confluence/display/AIRFLOW/Airflow+Improvement+Proposals).

  Documentation for dependent projects like provider packages, Docker image, Helm Chart, you'll find it in [the documentation index](https://airflow.apache.org/docs/).



  We publish Apache Airflow as `apache-airflow` package in PyPI. Installing it however might be sometimes tricky
  because Airflow is a bit of both a library and application. Libraries usually keep their dependencies open, and
  applications usually pin them, but we should do neither and both simultaneously. We decided to keep
  our dependencies as open as possible (in `pyproject.toml`) so users can install different versions of libraries
  if needed. This means that `pip install apache-airflow` will not work from time to time or will
  produce unusable Airflow installation.

  To have repeatable installation, however, we keep a set of "known-to-be-working" constraint
  files in the orphan `constraints-main` and `constraints-2-0` branches. We keep those "known-to-be-working"
  constraints files separately per major/minor Python version.
  You can use them as constraint files when installing Airflow from PyPI. Note that you have to specify
  correct Airflow tag/version/branch and Python versions in the URL.


  1. Installing just Airflow:

  > Note: Only `pip` installation is currently officially supported.

  While it is possible to install Airflow with tools like [Poetry](https://python-poetry.org) or
  [pip-tools](https://pypi.org/project/pip-tools), they do not share the same workflow as
  `pip` - especially when it comes to constraint vs. requirements management.
  Installing via `Poetry` or `pip-tools` is not currently supported.

  There are known issues with ``bazel`` that might lead to circular dependencies when using it to install
  Airflow. Please switch to ``pip`` if you encounter such problems. ``Bazel`` community works on fixing
  the problem in `this PR <https://github.com/bazelbuild/rules_python/pull/1166>`_ so it might be that
  newer versions of ``bazel`` will handle it.

  If you wish to install Airflow using those tools, you should use the constraint files and convert
  them to the appropriate format and workflow that your tool requires.


  ```bash
  pip install 'apache-airflow==2.10.4' \
   --constraint "https://raw.githubusercontent.com/apache/airflow/constraints-2.10.4/constraints-3.8.txt"
  ```

  2. Installing with extras (i.e., postgres, google)

  ```bash
  pip install 'apache-airflow[postgres,google]==2.8.3' \
   --constraint "https://raw.githubusercontent.com/apache/airflow/constraints-2.10.4/constraints-3.8.txt"
  ```

  For information on installing provider packages, check
  [providers](http://airflow.apache.org/docs/apache-airflow-providers/index.html).



  Apache Airflow is an [Apache Software Foundation](https://www.apache.org) (ASF) project,
  and our official source code releases:

  - Follow the [ASF Release Policy](https://www.apache.org/legal/release-policy.html)
  - Can be downloaded from [the ASF Distribution Directory](https://downloads.apache.org/airflow)
  - Are cryptographically signed by the release manager
  - Are officially voted on by the PMC members during the
    [Release Approval Process](https://www.apache.org/legal/release-policy.html#release-approval)

  Following the ASF rules, the source packages released must be sufficient for a user to build and test the
  release provided they have access to the appropriate platform and tools.




  Want to help build Apache Airflow? Check out our [contributing documentation](https://github.com/apache/airflow/blob/main/contributing-docs/README.rst).

  Official Docker (container) images for Apache Airflow are described in [images](dev/breeze/doc/ci/02_images.md).




  * Commits need a +1 vote from a committer who is not the author
  * When we do AIP voting, both PMC member's and committer's `+1s` are considered a binding vote.



  We know about around 500 organizations that are using Apache Airflow (but there are likely many more)
  [in the wild](https://github.com/apache/airflow/blob/main/INTHEWILD.md).

  If you use Airflow - feel free to make a PR to add your organisation to the list.




  Airflow is the work of the [community](https://github.com/apache/airflow/graphs/contributors),
  but the [core committers/maintainers](https://people.apache.org/committers-by-project.html#airflow)
  are responsible for reviewing and merging PRs as well as steering conversations around new feature requests.
  If you would like to become a maintainer, please review the Apache Airflow
  [committer requirements](https://github.com/apache/airflow/blob/main/COMMITTERS.rst#guidelines-to-become-an-airflow-committer).


pkgId: 27c1a52057e97f22eeedca891b460d6d2f5e7bf06eefccce657bb048c114e6ed
name: python-ape-foundry-help
arch: noarch
version: 0.8.7
epoch: 0
release: 1
summary: Development documents and examples for ape-foundry
url: https://github.com/ApeWorX/ape-foundry
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ape-foundry-0.8.7-1.src.rpm
location_href: Packages/python-ape-foundry-help-0.8.7-1.noarch.rpm
checksum_type: sha256
description:
  Foundry network provider plugin for Ape.
  Foundry is a development framework written in Rust for Ethereum that includes a local network implementation.



  - [python3](https://www.python.org/downloads) version 3.9 up to 3.12.
  - Foundry. See Foundry's [Installation](https://github.com/foundry-rs/foundry#installation) documentation for steps.





  You can install the latest release via [`pip`](https://pypi.org/project/pip/):

  ```bash
  pip install ape-foundry
  ```



  You can clone the repository and use [`setuptools`](https://github.com/pypa/setuptools) for the most up-to-date version:

  ```bash
  git clone https://github.com/ApeWorX/ape-foundry.git
  cd ape-foundry
  python3 setup.py install
  ```



  Use the `--network ethereum:local:foundry` command line flag to use the foundry network (if it's not already configured as the default).

  This network provider takes additional Foundry-specific configuration options. To use them, add these configs in your project's `ape-config.yaml`:

  ```yaml
  foundry:
    host: https://127.0.0.1:8555
  ```

  To select a random port, use a value of "auto":

  ```yaml
  foundry:
    host: auto
  ```

  This is useful for multiprocessing and starting up multiple providers.

  You can also adjust the request timeout setting:

  ```yaml
  foundry:
    request_timeout: 20  # Defaults to 30
    fork_request_timeout: 600  # Defaults to 300
  ```



  The `ape-foundry` plugin also includes a mainnet fork provider.
  It requires using another provider that has access to mainnet.

  Use it in most commands like this:

  ```bash
  ape console --network :mainnet-fork:foundry
  ```

  Specify the upstream archive-data provider in your `ape-config.yaml`:

  ```yaml
  foundry:
    fork:
      ethereum:
        mainnet:
          upstream_provider: alchemy
  ```

  Otherwise, it defaults to the default mainnet provider plugin.
  You can also specify a `block_number` and `evm_version`.

  If the block number is specified, but no EVM version is specified, it is automatically set based on the block height for known networks.

  **NOTE**: Make sure you have the upstream provider plugin installed for ape.

  ```bash
  ape plugins install alchemy
  ```



  To connect to a remote anvil node, set up your config like this:

  ```yaml
  foundry:
    host: https://anvil.example.com
  ```

  Now, instead of launching a local process, it will attempt to connect to the remote anvil node and use this plugin as the ape interface.

  To connect to a remote anvil node using an environment variable, set `APE_FOUNDRY_HOST`:

  ```bash
  export APE_FOUNDRY_HOST=https://your-anvil.example.com`
  ```



  You can impersonate accounts using the `ape-foundry` plugin.
  To impersonate an account, do the following:

  ```python
  import pytest

  @pytest.fixture
  def whale(accounts):
      return accounts["example.eth"]
  ```

  To transact, your impersonated account must have a balance.
  You can achieve this by using a forked network and impersonating an account with a balance.
  Alternatively, you can set your node's base fee and priority fee to `0`.

  To programtically set an account's balance, do the following:

  ```python
  from ape import accounts

  account = accounts["example.eth"]
  account.balance = "1000 ETH"  # This calls `anvil_setBalance` under-the-hood.
  ```



  Configure your node's base fee and priority fee using the `ape-config.yaml` file.

  ```yaml
  foundry:
    base_fee: 0
    priority_fee: 0
  ```



  Anvil nodes by default auto-mine.
  However, you can disable auto-mining on startup by configuring the foundry plugin like so:

  ```yaml
  foundry:
    auto_mine: false
  ```

  Else, you can disable auto-mining using the provider instance:

  ```python
  from ape import chain

  anvil = chain.provider
  anvil.auto_mine = False  # calls `anvil_setAutomine` RPC.
  ```



  By default, Anvil will mine a new block every time a transaction is submitted.
  To mine on an interval instead, set the `block_time` config:

  ```yaml
  foundry:
    block_time: 10  # mine a new block every 10 seconds
  ```



  To change the EVM version for local foundry networks, use the `evm_version` config:

  ```yaml
  foundry:
    evm_version: shanghai
  ```

  To change the EVM version for forked networks, set it the specific forked-network config(s):

  ```yaml
  foundry:
    fork:
      ethereum:
        mainnet:
          evm_version: shanghai
  ```


pkgId: 7b5f74b5bffd3389bc984ad73b00925598efd1180b61c57f47393767865aa6b7
name: python-ape-safe-help
arch: noarch
version: 0.8.5
epoch: 0
release: 1
summary: Development documents and examples for ape-safe
url: https://github.com/ApeWorX/ape-safe
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ape-safe-0.8.5-1.src.rpm
location_href: Packages/python-ape-safe-help-0.8.5-1.noarch.rpm
checksum_type: sha256
description:
  Account plugin for the [Safe](https://safe.global//) Multisig wallet (previously known as Gnosis Safe).



  - [python3](https://www.python.org/downloads) version 3.9 up to 3.12.





  You can install using the [ape](https://github.com/ApeWorX/ape) built-in plugin manager:

  ```bash
  $ ape plugins install safe
  ```



  You can install the latest release via [`pip`](https://pypi.org/project/pip/):

  ```bash
  $ pip install ape-safe
  ```



  You can clone the repository and use [`setuptools`](https://github.com/pypa/setuptools) for the most up-to-date version:

  ```bash
  $ git clone https://github.com/ApeWorX/ape-safe.git
  $ cd ape-safe
  $ python3 setup.py install
  ```



  To use the plugin, first use the CLI extension to add a safe you created:

  ```sh
  ape safe add --network ethereum:mainnet "my-safe.eth" my-safe
  ```

  If you made a mistake or just need to remove the safe, use the `remove` command:

  ```sh
  ape safe remove my-safe --yes
  ```

  **NOTE** `--yes` is a way to skip the prompt.

  If you only add one safe, you will not have to specify which safe to use other commands.
  Otherwise, for most `pending` commands, you specify the safe to use (by alias) via the `--safe` option.

  Additionally, you can configure a safe to use as the default in your `ape-config.yaml` file:

  ```yaml
  safe:
    default_safe: my-safe
  ```

  **NOTE**: Also, to avoid always needing to specify `--network`, you can set a default ecosystem, network, and provider in your config file.
  The rest of the guide with not specify `--network` on each command but assume the correct one is set in the config file.
  Here is an example:

  ```yaml
  default_ecosystem: optimism

  ethereum:
    default_network: sepolia
    sepolia:
      default_provider: infura
  ```

  Once you have a safe, you can view pending transactions:

  ```sh
  ape safe pending list
  ```

  It should show transactions like this:

  ```sh
  Transaction 8 rejection (1/2) safe_tx_hash=0x09ab9a229fc60da66ec0fa8fa886ab7c95902fdf5df5a5009ba06010fbb9a9a7
  Transaction 8 transfer  (1/2) safe_tx_hash=0xed43d80255bcd5ffacb755e8f51bee825913373705d6baea006419d2a33a0a5b
  ```

  **NOTE**: Use the `--verbose` flag to see more information about each transaction.

  ```sh
  ape safe pending list --verbose
  ```

  There are several operations you can do on a pending transaction.
  One of them is "approve" which adds your local signers' signatures to the transaction.

  ```sh
  ape safe pending approve 0x09ab9a229fc60da66ec0fa8fa886ab7c95902fdf5df5a5009ba06010fbb9a9a7
  ```

  **NOTE**: Here we are using the transaction hash `0x09ab9a229fc60da66ec0fa8fa886ab7c95902fdf5df5a5009ba06010fbb9a9a7` to specify the transaction because there are more than one.
  However, you can also use the nonce if there is only a single transaction.

  If you want to both execute and approve at the same time, you can use the `--execute` option on approve and specify a sender:

  ```sh
  ape safe pending approve 2 --execute my_account
  ```

  Else, you can use the `execute` command directly:

  ```sh
  ape safe pending execute 2
  ```

  **NOTE**: `execute` requires a full signed transaction ready to be submitted on-chain.

  The last main operation is `reject`.
  Rejecting a transaction replaces that transaction with a zero-value transfer from the safe to itself.

  ```sh
  ape safe pending reject 2
  ```



  The following example shows how to use multisend:

  ```python
  from ape_safe import multisend
  from ape import accounts
  from ape_tokens import tokens

  safe = accounts.load("my-safe")


  dai = tokens["DAI"]
  vault = tokens["yvDAI"]
  amount = dai.balanceOf(safe)  # How much we want to deposit


  txn = multisend.MultiSend()
  txn.add(dai.approve, vault, amount)
  txn.add(vault.deposit, amount)






  txn(sender=safe,gas=0)
  ```



  Please see the [contributing guide](CONTRIBUTING.md) to learn more how to contribute to this project.
  Comments, questions, criticisms and pull requests are welcomed.



  This package was inspired by [the original ape-safe](https://github.com/banteg/ape-safe#readme) by [banteg](https://github.com/banteg).
  For versions prior to v0.6.0, the original package should be referenced.


pkgId: d374e9377a6c0bc551e9117b7c66f82a6b2bd673134acaed64fd17d56d5621d8
name: python-api-client-pydantic-help
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Development documents and examples for api-client-pydantic
url: https://github.com/mom1/api-client-pydantic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-api-client-pydantic-3.1.0-1.src.rpm
location_href: Packages/python-api-client-pydantic-help-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub issues](https://img.shields.io/github/issues/mom1/api-client-pydantic.svg)
  ![GitHub stars](https://img.shields.io/github/stars/mom1/api-client-pydantic.svg)
  ![GitHub Release Date](https://img.shields.io/github/release-date/mom1/api-client-pydantic.svg)
  ![GitHub commits since latest release](https://img.shields.io/github/commits-since/mom1/api-client-pydantic/latest.svg)
  ![GitHub last commit](https://img.shields.io/github/last-commit/mom1/api-client-pydantic.svg)
  [![GitHub license](https://img.shields.io/github/license/mom1/api-client-pydantic)](https://github.com/mom1/api-client-pydantic/blob/master/LICENSE)

  [![PyPI](https://img.shields.io/pypi/v/api-client-pydantic.svg)](https://pypi.python.org/pypi/api-client-pydantic)
  [![PyPI](https://img.shields.io/pypi/pyversions/api-client-pydantic.svg)]()
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/api-client-pydantic.svg?label=pip%20installs&logo=python)

  <a href="https://gitmoji.dev"><img src="https://img.shields.io/badge/gitmoji-%20😜%20😍-FFDD67.svg" alt="Gitmoji"></a>
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)





  ```bash
  pip install api-client-pydantic
  ```



  The following decorators have been provided to validate request data and converting json straight to pydantic class.

  ```python
  from apiclient_pydantic import serialize, serialize_all_methods



  @serialize(config: Optional[ConfigDict] = None, validate_return: bool = True, response: Optional[Type[BaseModel]] = None)


  @serialize_all_methods(config: Optional[ConfigDict] = None)
  ```

  Usage:

  1. Define the schema for your api in pydantic classes.
      ```python
      from pydantic import BaseModel, Field


      class Account(BaseModel):
          account_number: int = Field(alias='accountNumber')
          sort_code: int = Field(alias='sortCode')
          date_opened: datetime = Field(alias='dateOpened')
      ```

  2. Add the `@serialize` decorator to the api client method to transform the response
     directly into your defined schema.
     ```python
      @serialize(response=List[Account])
      def get_accounts():
          ...
      
      @serialize
      def get_accounts() -> List[Account]:
          ...
      ```
  3. Add the `@serialize` decorator to the api client method to translate the incoming kwargs
     into the required dict or instance for the endpoint:
     ```python
      from apiclient_pydantic import ModelDumped

      @serialize
      def create_account(data: AccountHolder):
          
          ...

      create_account(data={'last_name' : 'Smith','first_name' : 'John'})
      

      @serialize
      def create_account(data: ModelDumped[AccountHolder]):
          
          ...

      create_account(data={'last_name' : 'Smith','first_name' : 'John'})
      
      ```
  4. For more convenient use, you can wrap all APIClient methods with `@serialize_all_methods`.
     ```python
      from apiclient import APIClient
      from apiclient_pydantic import serialize_all_methods
      from typing import List

      from .models import Account, AccountHolder


      @serialize_all_methods
      class MyApiClient(APIClient):
          def decorated_func(self, data: Account) -> Account:
              ...

          def decorated_func_holder(self, data: AccountHolder) -> List[Account]:
              ...
      ```





  This code generator creates a [ApiClient](https://github.com/MikeWooster/api-client) app from an openapi file.

  [apiclient-pydantic-generator](https://github.com/mom1/apiclient-pydantic-generator)


pkgId: 4753fe87e71a3a5d2acddbd2152339c43dcad818f66adb155694bf4cd7a7f7c0
name: python-apidance-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for apidance
url: https://pypi.org/project/apidance/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apidance-0.1.1-1.src.rpm
location_href: Packages/python-apidance-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python SDK for interacting with the Apidance API (https://apidance.pro/).



  ```bash
  pip install apidance-sdk
  ```



  Create a `.env` file in your project root with your API credentials:

  ```env
  APIDANCE_API_KEY=your_api_key_here
  ```

  Or provide the API key directly when initializing the client:

  ```python
  client = TwitterClient(api_key="your_api_key_here")
  ```



  ```python
  from apidance import TwitterClient


  client = TwitterClient()


  tweets = client.search_timeline(
      query="python",
  )


  user = client.get_user_by_screen_name("example")


  list_tweets = client.get_list_latest_tweets(
      list_id="your_list_id",
  )
  ```



  - Search Twitter timeline with various filters (Latest, Top, People, Photos, Videos)
  - Get detailed user information by screen name
  - Fetch tweets from Twitter lists
  - Automatic rate limit handling and retries
  - Type hints and data models for better development experience



  The SDK provides two main data models:

  - `Tweet`: Represents a Twitter post with all its metadata
  - `User`: Contains detailed user information including profile data, stats, and verification status



  The SDK includes built-in error handling for:
  - Rate limiting with automatic retries
  - Connection timeouts
  - API response validation



  MIT License


pkgId: c4141356de34bfd9d4682f7c6dbbb1f43431806d0ec87f6c7478c1135287850c
name: python-apify-client-help
arch: noarch
version: 1.8.1
epoch: 0
release: 1
summary: Development documents and examples for apify-client
url: https://docs.apify.com/api/client/python/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apify-client-1.8.1-1.src.rpm
location_href: Packages/python-apify-client-help-1.8.1-1.noarch.rpm
checksum_type: sha256
description:
  The Apify API Client for Python is the official library to access the [Apify API](https://docs.apify.com/api/v2) from your Python applications.
  It provides useful features like automatic retries and convenience functions to improve your experience with the Apify API.

  If you want to develop Apify Actors in Python,
  check out the [Apify SDK for Python](https://docs.apify.com/sdk/python) instead.



  Requires Python 3.8+

  You can install the package from its [PyPI listing](https://pypi.org/project/apify-client).
  To do that, simply run `pip install apify-client` in your terminal.



  For usage instructions, check the documentation on [Apify Docs](https://docs.apify.com/api/client/python/).



  ```python
  from apify_client import ApifyClient

  apify_client = ApifyClient('MY-APIFY-TOKEN')


  actor_call = apify_client.actor('john-doe/my-cool-actor').call()


  dataset_items = apify_client.dataset(actor_call['defaultDatasetId']).list_items().items
  ```



  Besides greatly simplifying the process of querying the Apify API, the client provides other useful features.



  Based on the endpoint, the client automatically extracts the relevant data and returns it in the
  expected format. Date strings are automatically converted to `datetime.datetime` objects. For exceptions,
  we throw an `ApifyApiError`, which wraps the plain JSON errors returned by API and enriches
  them with other context for easier debugging.



  Network communication sometimes fails. The client will automatically retry requests that
  failed due to a network error, an internal error of the Apify API (HTTP 500+) or rate limit error (HTTP 429).
  By default, it will retry up to 8 times. First retry will be attempted after ~500ms, second after ~1000ms
  and so on. You can configure those parameters using the `max_retries` and `min_delay_between_retries_millis`
  options of the `ApifyClient` constructor.



  Starting with version 1.0.0, the package offers an asynchronous version of the client, [`ApifyClientAsync`](https://docs.apify.com/api/client/python),
  which allows you to work with the Apify API in an asynchronous way, using the standard `async`/`await` syntax.



  Some actions can't be performed by the API itself, such as indefinite waiting for an Actor run to finish
  (because of network timeouts). The client provides convenient `call()` and `wait_for_finish()` functions that do that.
  Key-value store records can be retrieved as objects, buffers or streams via the respective options, dataset items
  can be fetched as individual objects or serialized data and we plan to add better stream support and async iterators.


pkgId: e0c6028d786aab7802719d9fa3ac0651183dc3e27e6498ccaf6b268afba2a829
name: python-apify-help
arch: noarch
version: 2.1.0
epoch: 0
release: 1
summary: Development documents and examples for apify
url: https://docs.apify.com/sdk/python/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apify-2.1.0-1.src.rpm
location_href: Packages/python-apify-help-2.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The Apify SDK for Python is the official library to create [Apify Actors](https://docs.apify.com/platform/actors)
  in Python. It provides useful features like Actor lifecycle management, local storage emulation, and Actor
  event handling.

  If you just need to access the [Apify API](https://docs.apify.com/api/v2) from your Python applications,
  check out the [Apify Client for Python](https://docs.apify.com/api/client/python) instead.



  The Apify SDK for Python is available on PyPI as the `apify` package.
  For default installation, using Pip, run the following:

  ```bash
  pip install apify
  ```

  For users interested in integrating Apify with Scrapy, we provide a package extra called `scrapy`.
  To install Apify with the `scrapy` extra, use the following command:

  ```bash
  pip install apify[scrapy]
  ```



  For usage instructions, check the documentation on [Apify Docs](https://docs.apify.com/sdk/python/).



  Below are few examples demonstrating how to use the Apify SDK with some web scraping-related libraries.



  This example illustrates how to integrate the Apify SDK with [HTTPX](https://www.python-httpx.org/) and [BeautifulSoup](https://pypi.org/project/beautifulsoup4/) to scrape data from web pages.

  ```python
  from apify import Actor
  from bs4 import BeautifulSoup
  from httpx import AsyncClient


  async def main() -> None:
      async with Actor:
          
          actor_input = await Actor.get_input() or {}
          start_urls = actor_input.get('start_urls', [{'url': 'https://apify.com'}])

          
          request_queue = await Actor.open_request_queue()

          
          for start_url in start_urls:
              url = start_url.get('url')
              await request_queue.add_request(url)

          
          while request := await request_queue.fetch_next_request():
              Actor.log.info(f'Scraping {request.url} ...')

              
              async with AsyncClient() as client:
                  response = await client.get(request.url)

              
              soup = BeautifulSoup(response.content, 'html.parser')

              
              data = {
                  'url': actor_input['url'],
                  'title': soup.title.string,
                  'h1s': [h1.text for h1 in soup.find_all('h1')],
                  'h2s': [h2.text for h2 in soup.find_all('h2')],
                  'h3s': [h3.text for h3 in soup.find_all('h3')],
              }

              
              await Actor.push_data(data)
  ```



  This example demonstrates how to use the Apify SDK alongside `PlaywrightCrawler` from [Crawlee](https://crawlee.dev/python) to perform web scraping.

  ```python
  from apify import Actor, Request
  from crawlee.playwright_crawler import PlaywrightCrawler, PlaywrightCrawlingContext


  async def main() -> None:
      async with Actor:
          
          actor_input = await Actor.get_input() or {}
          start_urls = [url.get('url') for url in actor_input.get('start_urls', [{'url': 'https://apify.com'}])]

          
          if not start_urls:
              Actor.log.info('No start URLs specified in Actor input, exiting...')
              await Actor.exit()

          
          crawler = PlaywrightCrawler(
              
              max_requests_per_crawl=50,
              headless=True,
          )

          
          @crawler.router.default_handler
          async def request_handler(context: PlaywrightCrawlingContext) -> None:
              url = context.request.url
              Actor.log.info(f'Scraping {url}...')

              
              data = {
                  'url': context.request.url,
                  'title': await context.page.title(),
                  'h1s': [await h1.text_content() for h1 in await context.page.locator('h1').all()],
                  'h2s': [await h2.text_content() for h2 in await context.page.locator('h2').all()],
                  'h3s': [await h3.text_content() for h3 in await context.page.locator('h3').all()],
              }

              
              await context.push_data(data)

              
              await context.enqueue_links()

          
          await crawler.run(start_urls)
  ```



  Actors are serverless cloud programs that can do almost anything a human can do in a web browser.
  They can do anything from small tasks such as filling in forms or unsubscribing from online services,
  all the way up to scraping and processing vast numbers of web pages.

  They can be run either locally, or on the [Apify platform](https://docs.apify.com/platform/),
  where you can run them at scale, monitor them, schedule them, or publish and monetize them.

  If you're new to Apify, learn [what is Apify](https://docs.apify.com/platform/about)
  in the Apify platform documentation.



  To create and run Actors through Apify Console,
  see the [Console documentation](https://docs.apify.com/academy/getting-started/creating-actors#choose-your-template).

  To create and run Python Actors locally, check the documentation for
  [how to create and run Python Actors locally](https://docs.apify.com/sdk/python/docs/overview/running-locally).



  To see how you can use the Apify SDK with other popular libraries used for web scraping,
  check out our guides for using
  [Requests and HTTPX](https://docs.apify.com/sdk/python/docs/guides/requests-and-httpx),
  [Beautiful Soup](https://docs.apify.com/sdk/python/docs/guides/beautiful-soup),
  [Playwright](https://docs.apify.com/sdk/python/docs/guides/playwright),
  [Selenium](https://docs.apify.com/sdk/python/docs/guides/selenium),
  or [Scrapy](https://docs.apify.com/sdk/python/docs/guides/scrapy).



  To learn more about the features of the Apify SDK and how to use them,
  check out the Usage Concepts section in the sidebar,
  particularly the guides for the [Actor lifecycle](https://docs.apify.com/sdk/python/docs/concepts/actor-lifecycle),
  [working with storages](https://docs.apify.com/sdk/python/docs/concepts/storages),
  [handling Actor events](https://docs.apify.com/sdk/python/docs/concepts/actor-events)
  or [how to use proxies](https://docs.apify.com/sdk/python/docs/concepts/proxy-management).


pkgId: d1a5866858cb0fdab372497854c659666104163d8efe60e626576638f62bc603
name: python-apis-bibsonomy-help
arch: noarch
version: 0.13.1
epoch: 0
release: 1
summary: Development documents and examples for apis-bibsonomy
url: https://pypi.org/project/apis-bibsonomy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apis-bibsonomy-0.13.1-1.src.rpm
location_href: Packages/python-apis-bibsonomy-help-0.13.1-1.noarch.rpm
checksum_type: sha256
description:
  APIS Bibsonomy is a small addon to the APIS system. It allows to store references in Bibsonomy instances and use these references in APIS.
  It is very generic and should work with most Django installations/projects.



  - Install the package:

    `pip install apis-bibsonomy`

  - Add the package to your installed apps:

    ```
    INSTALLED_APPS = [
    ...
    'apis_bibsonomy'
    ]
    ```

  - And migrate your DB:

    `python manage.py migrate`


  Some functionality from APIS Bibsonomy uses `htmx`, so you should [include htmx
  into your web application](https://htmx.org/docs/#installing).





  APIS Bibsonomy needs an URL of the bibsonomy or zotero instance, a username, a API token and an (optional) collection to search in.

  You need to add a configuration section to your APIS settings:

  ```
  APIS_BIBSONOMY = [{
     'type': 'bibsomomy', #or zotero
     'url': 'http://url.at', #url of the bibsonomy instance or zotero.org
     'user': 'username', #for zotero use the user id number found in settings
     'API key': 'api_key',
     'group': 'group'
  }]
  ```

  If you want the plugin to add the reference buttons to certain fields you need to add these fields to the config:

  ```
  APIS_BIBSONOMY_FIELDS = ['name', 'first_name', 'profession']
  ```


  Restart your server and you are good to go.




  APIS Bibsonomy uses htmx. The delete buttons for references trigger deletion
  via the API delete route which give an empty response on success. HTMX needs to
  be [configured to swap the content even if the response is empty](https://github.com/bigskysoftware/htmx/issues/199):
  ```
  document.body.addEventListener('htmx:beforeSwap', function(event) {
    if (event.detail.xhr.status === 204) {
      // Swap content even when the response is empty.
      event.detail.shouldSwap = true;
    }
  });
  ```




  *not needed if you are using standard APIS templates*

  - Include the base template somewhere in the header of your template:

  `{% include 'apis_bibsonomy/apis_bibsonomy_include.html' %}`

  - Load the templatetag:

  `{% load bibsonomy_templatetags %}`

  - Include the form somewhere in your template (set hidden=True if you intend to use buttons):

  `{% bibsonomy_form content_type='person' hidden=True %}`

  - And finally add html tags as anker element for the reference forms to your template (dont forget to set "bibsonomy-anker" as class):

  `<button class="bibsonomy-anker" data-bibs-contenttype="person" data-bibs-object_pk={{instance.pk}} data-bibs-attribute="Attribute name (optional)">Ref</button>`

  - If you want to batch add reference forms to attribute fields in a whole form add a hidden anker element. You need to additionally add the names of the form fields you want to have reference forms for to `data-bibs-form-elements=""`

  `<button class="bibsonomy-anker-hidden" data-bibs-contenttype="person" data-bibs-object_pk={{instance.pk}} data-bibs-form-elements="first_name|name|gender|start_date_written|lat">Ref</button>`




  The *book* icon used for the reference link is the SVG from the [*Import Contacts* icon from the material symbols](https://fonts.google.com/icons?selected=Material+Symbols+Outlined:import_contacts:FILL@0;wght@400;GRAD@0;opsz@24&icon.query=book&icon.size=24&icon.color=%235f6368)


pkgId: a7574f6f500199e1069f6619690827692f6177891784a69de297cb200b39130f
name: python-apishare-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for apishare
url: https://github.com/yourusername/apishare
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apishare-0.1.2-1.src.rpm
location_href: Packages/python-apishare-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for API token management.



  ```bash
  pip install apishare
  ```



  ```python
  from apishare import APIShare


  api = APIShare(token="your-api-token")


  result = api.test()
  print(result)  # This will print your token
  ```



  - Simple API token management
  - Easy to use interface



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


pkgId: 92e3d1d316c5e6be0227d1c2590368c1d7bf15c57b05d59ea00fba4144b8e977
name: python-aplos-nca-saas-sdk-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for aplos-nca-saas-sdk
url: https://aplosanalytics.com/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aplos-nca-saas-sdk-0.0.6-1.src.rpm
location_href: Packages/python-aplos-nca-saas-sdk-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to the Aplos NCA SaaS SDK for automating your PK Analyis.  A secure set of API's to connect to our Cloud System and automate your PK analysis.

  This SDK works for our
  - Trial Accounts (Multi Tenancy)
  - Academic Accounts (Multi Tenancy)
  - Professional Accounts (Multi Tenancy)
  - Team Accounts (Single Tenancy)
  - Enterprise Accounts (Single Tenancy)


  If you can make HTTPS 🔐 request 🛜 - you can automation your PK Analysis Workflow Systems.


  > We'll keep this maintained as we use it for our customer demo as well as Integration Testings.
  > So keep coming back for new features.
  >
  > If you're not sure how to get started, kick off the Integration Test Suite, set some break points
  > and you'll see a wide range of example use cases.




  > In order to run the executions and connect to our system, you will need a valid account with an active subscription (reach out for a trial subscription if you are evaluating our solutions).
  >
  > You'll need your username (email address and a password), a Cognito Client Id
  > which allows the USER_PASSWORD_AUTH flow, and your API URL.
  >
  > Technically if you have your API Domain (from your account), you can use this to query for your Cognito Client Id
  >
  > Otherwise, the Client Id (aka Cognito Client Key) and API URL can be found in your user account.
  >
  > Your username is your email address and your password would have been provided to you during your
  > onboarding or with a "forgot password" request and reset.



  You can use the API to integrate the Aplos NCA SaaS Cloud Solution into your workflow.
  You can perform:
  - Logins
  - File Uploads
  - PK Analysis Executions
  - PK Analysis Results
  - File Downloads
  - PK Validations (run validations against our calculations engine)
  - Tenant & User Management (for Team & Enterprise Accounts)
  - and more...



  You can use the integration testing to test your environment. You can also use the Integration Testing modules
  to learn how to use the API.


  Full source code can also be found on [GitHub](https://github.com/AplosAnalytics/Aplos-NCA-SaaS-SDK)


  [The Docs](https://docs.aplosanalytics.com/)


  [Aplos Analytics](https://aplosanalytics.com/)


pkgId: eb55738356713a006ff4412a273ec5c472735c10bd3976a8cc1b8547bd5b8439
name: python-aplustools-help
arch: noarch
version: 1.4.8.5
epoch: 0
release: 1
summary: Development documents and examples for aplustools
url: https://pypi.org/project/aplustools/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aplustools-1.4.8.5-1.src.rpm
location_href: Packages/python-aplustools-help-1.4.8.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Active Development](https://img.shields.io/badge/Maintenance%20Level-Actively%20Developed-brightgreen.svg)](https://gist.github.com/cheerfulstoic/d107229326a01ff0f333a1d3476e068d)
  [![Build Status](https://github.com/Adalfarus/aplustools/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Adalfarus/aplustools/actions)
  [![License: GPL-3.0](https://img.shields.io/github/license/Adalfarus/aplustools)](https://github.com/Adalfarus/aplustools/blob/main/LICENSE)



  aplustools is a simple, user-friendly Python library for performing amazing tasks. It simplifies complex processes, allowing you to achieve more with less code. Developed with a focus on ease of use and efficiency, aplustools is the go-to solution for Python developers looking to enhance their projects.



  - Easy to use
  - Highly efficient
  - Supports multiple platforms
  - Regular updates and support
  - Comprehensive documentation



  You can install aplustools via pip:

  ```sh
  pip install aplustools --upgrade
  ```

  Or clone the repository and install manually:

  ```sh
  git clone https://github.com/Adalfarus/aplustools.git
  cd aplustools
  python -m build
  ```



  Here are a few quick examples of how to use aplustools:


  ```python
  from aplustools.web.search import Search, GoogleSearchCore


  searcher = Search(GoogleSearchCore(advanced=True))
  results = searcher.search("Cute puppies", num_results=10)


  print(results)

  from aplustools.web.utils import WebPage

  web_page = WebPage(results[0].get("url"))

  response = None
  if web_page.crawlable:  # Google search does this automatically at the moment
      response = web_page.page.content
  print(response)

  ```


  ```python
  from aplustools.web.request import UnifiedRequestHandler, UnifiedRequestHandlerAdvanced
  import os


  handler = UnifiedRequestHandler()


  handler.fetch('http://example.com', async_mode=False)

  handler.fetch('http://example.com', async_mode=True)


  adv_handler = UnifiedRequestHandlerAdvanced()  # It can also handle image content


  adv_handler.request('GET', 'http://example.com', async_mode=False)

  adv_handler.request('GET', 'http://example.com', async_mode=True)

  folder_path = "./test_data/images"
  os.makedirs(folder_path, exist_ok=True)


  image_content = adv_handler.request('GET', 'http://example.com/image.png', async_mode=False, return_type='binary')
  with open(os.path.join(folder_path, './image.png'), 'wb') as file:
      file.write(image_content)


  image_content_async = adv_handler.request('GET', 'http://example.com/image.png', async_mode=True, return_type='binary')
  with open(os.path.join(folder_path, './image_async.png'), 'wb') as file:
      file.write(image_content_async)

  ```


  ````python
  from aplustools.data.imagetools import ImageManager, OnlineImage
  import os

  os.makedirs("./test", exist_ok=True)
  manager = ImageManager("./test", use_async=True)
  image_index = manager.add_image(OnlineImage, "somewhere.com/image.jpg")

  manager.execute_func(image_index, "download_image")
  manager.execute_func(image_index, "convert_to_grayscale")
  manager.execute_func(image_index, "apply_filter")  # Default is blur
  manager.execute_func(image_index, "rotate_image", 12)
  manager.execute_func(image_index, "save_image_to_disk")  # Overwrites downloaded file

  ````


  ```python
  from aplustools.data.imagetools import OnlineImage, OfflineImage, ImageFilter, SVGCompatibleImage
  import os


  folder_path = "./images"
  os.makedirs(folder_path, exist_ok=True)
  test_url = "someImage.url"
  base64_image_str = ("data:image/jpeg;base64,...")


  online_image = OnlineImage(current_url=test_url, base_location=folder_path, one_time=True)
  download_result = online_image.download_image(folder_path, online_image.current_url, "downloaded_image", "jpg")
  if not download_result[0]:
      raise Exception("Failed to download image.")
  else:
      online_image.convert_to_grayscale()
      online_image.save_image_to_disk(os.path.join(folder_path, "image.png"))


  offline_image = OfflineImage(data=base64_image_str, base_location=folder_path)
  save_result = offline_image.base64(folder_path, "base64_image", "png")
  if not save_result:
      raise Exception("Failed to save base64 image.")


  offline_image.resize_image((100, 100))
  offline_image.rotate_image(45)
  offline_image.convert_to_grayscale()
  offline_image.apply_filter(ImageFilter.BLUR)
  offline_image.save_image_to_disk(os.path.join(folder_path, "transformed_image.png"))


  image_processor = SVGCompatibleImage("someSvg.svg", 300,
                                       (667, 800), magick_path=r".\ImageMagick",
                                       base_location='./')
  image_processor.save_image_to_disk()


  from aplustools.io.environment import absolute_path, remv, copy

  a_img_path = absolute_path(os.path.join(folder_path, "downloaded_image.jpg"))

  copy(a_img_path, str(folder_path) + "downloaded_image" + " - Copy.jpg")

  remv(a_img_path)  # Remove the original image
  remv(folder_path)  # Remove the base directory

  ```


  ```python
  from aplustools.data.faker import TestDataGenerator

  test_data = TestDataGenerator()
  print(test_data.generate_random_identity())

  print("\n", end="")
  print(test_data.generate_random_name())
  print(test_data.generate_random_email())
  print(test_data.generate_random_password())
  print(test_data.generate_random_phone_number())
  print(test_data.generate_random_address())
  print(test_data.generate_random_birth_date())

  ```


  ```python
  from aplustools.utils.dummy import Dummy3  # Dummy3 is for Python 3
  import math

  dummy = Dummy3()


  dummy.attr.func("", int3="")
  dummy["Hello"] = 1
  del dummy[1]
  reversed(dummy)
  if not "Dummy" in dummy:
      dummy.keys = ["1"]
  print(dummy.keys + dummy)
  var1 = +dummy
  var2 = -dummy
  var3 = ~dummy
  print(var1, var2, var3)

  hash(dummy)
  abs(dummy)
  round(dummy)
  complex(dummy)
  oct(dummy)
  repr(dummy)
  bytes(dummy)
  format(dummy, "DD")

  math.trunc(dummy)
  dummy << dummy
  dummy >> dummy
  dummy -= 1_000_000
  num = 1
  num *= dummy

  if dummy:
      print(True)
  else:
      print(False)

  for x in dummy:
      print(x)

  type(dummy)
  print(dummy, "->", int(dummy), list(dummy), tuple(dummy), float(dummy))

  ```


  ```python
  from aplustools.utils.hasher import hashed_latest, hashed_wrapper_latest, reducer, big_reducer, num_hasher

  inp = "Hello beautiful world, how are you today, lovely star?"
  inp2 = "Hello World, kitty"

  desired_length = 64

  hashed_inp = hashed_wrapper_latest(inp, desired_length, hash_func=hashed_latest)
  hashed_inp2 = hashed_wrapper_latest(inp2, desired_length, hash_func=hashed_latest)

  print(f"{inp} ({len(inp)}) -> {hashed_inp} ({len(hashed_inp)})\n{inp2} ({len(inp2)}) -> {hashed_inp2} ({len(hashed_inp2)})")

  num_hashed_inp = num_hasher(inp, desired_length)
  num_hashed_inp2 = num_hasher(inp2, desired_length)

  print(f"{inp} ({len(inp)}) -> {num_hashed_inp} ({len(num_hashed_inp)})\n{inp2} ({len(inp2)}) -> {num_hashed_inp2} ({len(num_hashed_inp2)})")

  acceptable_chars = range(100, 200)

  num_hashed_inp_uni = num_hasher(inp, desired_length, acceptable_chars)
  num_hashed_inp_uni_2 = num_hasher(inp2, desired_length, acceptable_chars)

  print(f"{inp} ({len(inp)}) -> {num_hashed_inp_uni} ({len(num_hashed_inp_uni)})\n{inp2} ({len(inp2)}) -> {num_hashed_inp_uni_2} ({len(num_hashed_inp_uni_2)})")

  ```


  ```python
  from aplustools.utils.genpass import SecurePasswordManager, GeneratePasswords

  manager = SecurePasswordManager()
  password = manager.generate_ratio_based_password_v2(length=26, letters_ratio=0.5, numbers_ratio=0.3,
                                                      punctuations_ratio=0.2, exclude_similar=True)
  manager.add_password("example.com", "json-the-greatest", password)
  manager.store_in_buffer("example.com", 0)  # Stores unencrypted password in a buffer
  print(manager.get_password("example.com"), "|", manager.use_from_buffer(0))  # for faster access.

  print(GeneratePasswords.generate_custom_sentence_based_password_v1(
      "Exploring the unknown -- discovering new horizons...", random_case=True, extra_char="_",
      char_position="keep" or 0, num_length=5, special_chars_length=2))




  from aplustools.utils.genpass import ControlCodeProtocol, SecureSocketServer, SecureSocketClient


  prot = ControlCodeProtocol()


  client = SecureSocketClient(prot)
  sock = client.get_socket()
  server = SecureSocketServer(sock, prot)


  client.start_and_exchange_keys()  # Client has to start first
  server.start_and_exchange_keys()


  client.add_control_code("shutdown")
  client.add_message("HELLO SERVER")
  client.sendall()  # The message is still received as it sends one chunk here




  server.shutdown_client()
  print("DONE1")



  from aplustools.utils.genpass import ControlCodeProtocol, ServerMessageHandler, ClientMessageHandler
  import threading

  prot = ControlCodeProtocol()


  encoder = ClientMessageHandler(prot)


  connection = encoder.get_socket()

  decoder = ServerMessageHandler(connection, prot)


  encoder.add_message("Hello Server")
  encoder.send_control_message("shutdown")


  encoder.start()
  threading.Thread(decoder.listen_for_messages()).start()  # Blocking
  encoder.flush()  # Blocking until connection is established

  ```


  ```python
  from aplustools.data.updaters import GithubUpdater, VersionNumber
  from aplustools.io.environment import get_temp
  from aplustools import set_dir_to_ex
  import sys
  import os

  set_dir_to_ex()

  __version__ = VersionNumber("0.0.1")


  updater = GithubUpdater("Adalfarus", "unicode-writer", "py")  # If you want to use exe
  latest_version = updater.get_latest_tag_version()             # you need to compile them
                                                                

  if __version__ >= latest_version:
      sys.exit()


  path, zip_path = os.path.join(os.getcwd(), "update"), os.path.join(get_temp(), f"apt-update_{latest_version}")

  os.makedirs(path, exist_ok=True)
  os.makedirs(zip_path, exist_ok=True)


  update_thread = updater.update(path, zip_path, latest_version, implementation="none",
                                 host="localhost", port=1264, non_blocking=True, wait_for_connection=True)
  update_thread.start()


  progress_bar = 1
  for i in updater.receive_update_status():
      print(f"{i}%", end=f" PB{progress_bar}\n")
      if i == 100:
          progress_bar += 1  # Switch to second progress bar, when the downloading is finished
  update_thread.join()

  ```


  ```python
  from aplustools.package.argumint import ArgStruct, ArguMint
  from typing import Literal
  import sys


  def sorry(*args, **kwargs):
      print("Not implemented yet, sorry!")


  def help_text():
      print("Build -> dir/file or help.")


  def build_file(path: Literal["./main.py", "./file.py"] = "./main.py", num: int = 0):
      """
      build_file
      :param path: The path to the file that should be built.
      :param num:
      :return None:
      """
      print(f"Building file {path} ..., {num}")


  from aplustools.package import timid

  timer = timid.TimidTimer()

  arg_struct = {'apt': {'build': {'file': {}, 'dir': {'main': {}, 'all': {}}}, 'help': {}}}


  builder = ArgStruct()
  builder.add_command("apt")
  builder.add_nested_command("apt", "build", "file")

  builder.add_nested_command("apt.build", "dir", {'main': {}, 'all': {}})




  builder.add_command("apt.help")


  print(builder.get_structure())  # Best to cache this for better times (by ~15 microseconds)

  parser = ArguMint(default_endpoint=sorry, arg_struct=arg_struct)
  parser.add_endpoint("apt.help", help_text)

  parser.add_endpoint("apt.build.file", build_file)

  sys.argv[0] = "apt"




  parser.parse_cli(sys, "native_light")
  print(timer.end())

  ```


  ```python
  from aplustools.data.compressor import FileContainerV3, BrotliChunkCompressor
  import os


  compressor = BrotliChunkCompressor()
  container = FileContainerV3(compressor, block_size=2048*2048)

  image_data = {}
  for file in os.listdir("./images"):
      if file.lower().endswith(".png"):
          with open(os.path.join("./images", file), "rb") as f:
              image_file_data = b''.join(f.readlines())
              image_data[file] = image_file_data

  for file_name, image in image_data.items():
      container.add_file(file_name, image)


  compressed_data = container.get_compressed_container()

  print("Compression done")

  with open("./files.bin", "wb") as f:
      f.write(compressed_data)

  print("Wrote bin")


  try:
      decompressed_images = []
      for i in range(len(image_data)):
          decompressed_image = container.extract_file(compressed_data, i)
          decompressed_images.append(decompressed_image)
  except Exception as e:
      print("Indexing not possible, error", e, "\n")
      decompressed_images = []
      for file_name in image_data.keys():
          decompressed_image = container.extract_file(compressed_data, file_name)
          decompressed_images.append(decompressed_image)
  compression_ratio = len(compressed_data) / sum(len(x) for x in image_data.values())

  print(f"Original size: {sum(len(x) for x in image_data.values())} bytes")
  print(f"Compressed size: {len(compressed_data)} bytes")
  print(f"Compression ratio: {compression_ratio:.2f}")

  for i, decompressed_image in enumerate(decompressed_images):
      with open(f"./decompressed_images/image{i}.png", "wb") as f:
          f.write(decompressed_image)

  ```


  ```python
  from aplustools.io import environment as env
  from aplustools.io import loggers


  env.set_working_dir_to_main_script_location()


  p_logger = loggers.PrintLogger("my_logs_file.log", show_time=True, capture_print=False,
                       overwrite_print=True, print_passthrough=False, print_log_to_stdout=True)



  logger = loggers.monitor_stdout(logger=p_logger) # Return sys.stdout, so you can make sure it worked


  p_logger.log("Hello, world!")


  print("Hello, beautiful world!")


  p_logger.close()

  ```
  (If you want to ensure that all dependencies are installed please run `upype import aplustools; aplustools.install_all_dependencies()`)
  (Correct shortform for aplustools is apt, so please use ```import aplustools as apt``` for consistency)

  There are multiple clis added through this package:


  ```bash
  C:\Users\user_>pype
  Enter Python expression: 1 + 2
  3

  C:\Users\user_>pype 1 // 3
  0
  ```

  ```bash
  C:\Users\user_>upype import aplustools; print(aplustools.__version__)
  1.4.4

  C:\Users\user_>upype
  Enter Python code (type 'end' on a new line to finish):
  ... class Test:
  ...     def hello_word(self):
  ...             print("Hello, you!")
  ... test = Test()
  ... test.hello_word()
  ... end
  Hello, you!
  ```
  These can also be used in e.g. batch files like this
  ```batch
  @echo off
  set /p id=Enter ID:
  upype from aplustools.utils.genpass import GeneratePasswords; print(GeneratePasswords.generate_custom_sentence_based_password_v1("""%id%""", random_case=True, extra_char="""_""", char_position=0, num_length=5, special_chars_length=2))
  pause

  ```


  Can currently run tests with ```apt tests run``` and show a basic help using ```apt help```.


  For more detailed usage and examples, check out our [documentation](https://github.com/adalfarus/aplustools/wiki).


  [PEP 8 -- Style Guide for Python Code](https://peps.python.org/pep-0008/#naming-conventions)

  For modules I use 'lowercase', classes are 'CapitalizedWords' and functions and methods are 'lower_case_with_underscores'.

  Dependencies (except for the standard libraries) are:
  - [`none`]
    - data.database
    - io.environment
    - io.loggers
    - data.faker
    - utils.dummy
    - utils.hasher
    - package.lazy_loader
    - package.timid
  - [`requests`]
    - data.github-updater-none
    - data.updaters
    - data.github-updater-cmd
  - data.github-updater-gui - [`requests`, `PySide6`]
  - data.imagetools - [`Pillow`, `aiohttp`, `requests`, `wand`]
  - data.advanced_imagetools - [`opencv-python`, `aiohttp`, `wand`, `pillow_heif`]
  - web.search, web.utils - [`requests`, `BeautifulSoup4`]
  - utils.genpass - [`cryptography`]
  - web.request - [`requests`, `aiohttp`]
  - utils.compressor - [`brotli`, `zstandard`, `py7zr`]
  - io.gui - [`PySide6`]

  Sub-Modules that may be removed in future updates due to being hard to support or simply unneeded.

  - database (maybe unneeded and hard to support if more dbs are added -> new_database is being developed)
  - loggers (maybe unneeded)



  We welcome contributions! Please see our [contributing guidelines](https://github.com/adalfarus/aplustools/blob/main/CONTRIBUTING.md) for more details on how you can contribute to aplustools.

  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
  3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to the branch (`git push origin feature/AmazingFeature`)
  5. Open a pull request



  aplustools is licensed under the GPL-3.0 License - see the [LICENSE](https://github.com/adalfarus/aplustools/blob/main/LICENSE) file for details.


pkgId: 2afc9a5016f7304b3423b1b1ea1fb6035ad9ffeb99cb12999929719dbf4245a9
name: python-apminsight-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for apminsight
url: https://site24x7.com
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apminsight-1.6.0-1.src.rpm
location_href: Packages/python-apminsight-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  Monitor and optimize the performance of your Python application with the Site24x7 APM Insight Python agent. The agent provides you with information on the response time, throughput, database operations, and errors of your application. Keep track of these metrics over time to identify where they can be improved for better performance.
  Make sure you have a Site24x7 account before you use an APM Insight agent to monitor metrics.
  Requirements: Python version 3.7.0 and above.
  Supported frameworks: Bottle, CherryPy, Django, Flask, and Pyramid.
  Supported databases and components: PyMySQL, Psycopg2, Pymemcache, Redis, SQLite, Cassandra, Jinja2, Genshi, and Mako.
  Supported HTTP libraries: http.client, httplib2, httpx, urllib, urllib3.
  **S247DataExporter**
      The S247DataExporter is an independent process dedicated for communicating application metrics and traces to the Site24x7 server.
  **Installation instructions for S247DataExporter:**
  * Run the following commands in your terminal
          wget -O "InstallDataExporter.sh" https://staticdownloads.site24x7.com/apminsight/S247DataExporter/linux/InstallDataExporter.sh
          sudo sh InstallDataExporter.sh install -lk <S247_LICENSE_KEY>
  * If you are using proxy, add the following snippet to the command 'sudo sh InstallDataExporter.sh install -lk <S247_LICENSE_KEY>'
          -pau <Proxy auth username> -pap <Proxy auth password> -psh <Proxy server host:Proxy server port>  -psph <Boolean value whether to use HTTPS protocol for proxy> -bp <Bollean value whether to use proxy or not>
    > *Note: By default, S247DataExporter uses 20021 as the AGENT STATUS PORT and 20022 as the AGENT DATA PORT.
  If you want to run the S247DataExporter in different ports, add the below configurations to the above mentioned command.
  | Option | Description  |
  | ------ | ------ |
  | '-asp <Agent Status Port>' | To configure the custom Exporter Status Port |
  | '-adp <Agent Data Port>' | To configure the custom Exporter Data Port |
  | '-sld <Directory path>' | To log the Exporter logs to a custom directory |
  | '-sll <Log level>' | To configure the Log level of Exporter logs |
  | '-sls <Exporter log size>' | To configure the Exporter Log file size |
  **Installation instructions for the S247 Python agent:**
  If you are using a virtual environment, activate the virtual environment and run the following command to install the S247 APMINSIGHT Python package into your virtual environment
          pip install apminsight
  **Integrate the Python agent to your application**
  * *Using the command line* \
     You can use the below command for adding extra configurations:
          $ apminsight-run -lk "license_key" <apm-options> <user application execute command>
  | apm-options | Description |
  | ------ | ------ |
  | -lk, --license_key | To add the site24x7 license key or device key |
  | -apmname, --apm_app_name | To add the APM application name |
  | -ald, --apm_log_dir | To add a custom log directory for storing APM logs |
  | -ad, --apm_debug | To enable debug mode |
  | -aeh, --apm_exp_host | To configure the S247DataExporter host |
  | -aesp, --apm_exp_status_port | To configure the S247DataExporter status port |
  | -aedp, --apm_exp_data_port | To configure the S247DataExporter data port |
  Examples:
   If you want to configure the application name, use the below command:
        apminsight-run --apm_app_name "monitorname" <user application execute command>
    If you want to configure the directory location, use the below command:
        apminsight-run --apm_app_name "monitorname" --apm_log_dir "logs location" <user application execute command>
  * *Using the code snippet*
    > Note: Update the configuration in the code snippet below and place it at the top of your application route file or application start file.
          from apminsight import initialize_agent
          initialize_agent({
              "appname" : "<Your application name>",
              "license_key" : "< your site24x7 license key>",
              '''change if  S247DataExporter is not running in the default ports(20021, 20022):'''
              "exporter_status_port" : "<S247DataExporter status port>",
              "exporter_data_port" : "<S247DataExporter data port>",
              '''If you are running S247DataExporter on a separate machine/server or as a Docker container:'''
              "exporter_host" : "<HostName/ContainerName where S247DataExporter is running>"
          })
    For example, for Django applications, add the code snippet at the top of the Django settings.py file. The name of your Django application will be automatically detected by your WSGI_APPLICATION in the application's settings.py.
    For other applications and frameworks, such as Flask, add the code snippet at the top of the application start file.
  * *Configure the agent using environment variables*
  | Configuration | Description |
  | ------ | ------ |
  | $ export S247_LICENSE_KEY=< license key > | To add your site2x7 License or Device key |
  | $ export APM_APP_NAME=<Your application name > | To add the APM application name |
  | $ export APM_LOGS_DIR=< logs storing path > | To configure the log directory |
  | $ export APM_EXPORTER_STATUS_PORT=< S247DataExporter status port >,
  $ export APM_EXPORTER_DATA_PORT=< S247DataExporter data port > | To change the S247DataExporter's default running ports (20021, 20022) |
  | $ export APM_EXPORTER_HOST=< HostName/ContainerName where S247DataExporter is running > | To change the host of the S247DataExporter to a different machine or server or as a Docker container |
  * Restart your WSGI application and Perform some transactions so that the agent can collect data.
  * Log in to your Site24x7 account.
  * Navigate to APM Insight and click your application to view application metrics.
  * You can view agent log files in the apminsightdata/logs directory, which will be present in the process-generated location.


pkgId: ba0cb5e5dbc718180d503b40682f1898ac54f66c04b5405da1dda244a593c6d5
name: python-apolo-cli-help
arch: noarch
version: 24.12.3
epoch: 0
release: 1
summary: Development documents and examples for apolo-cli
url: https://github.com/neuro-inc/platform-client-python
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apolo-cli-24.12.3-1.src.rpm
location_href: Packages/python-apolo-cli-help-24.12.3-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/neuro-cli/platform-client-python/branch/master/graph/badge.svg)](https://codecov.io/gh/neuro-cli/platform-client-python)



  Welcome to Apolo CLI tool for https://apolo.us/.
  Package ship command line tool called `apolo`. With it you can:
  * Execute and debug jobs
  * Manipulate Data
  * Make some fun



  For OSX users install coreutils to properly interpret shell commands:

  ```
  brew install coreutils
  ```

  Before you begin, it is recommended to have clean virtual environment installed:

  ```shell
  python -m venv .env
  source .env/bin/activate
  ```

  Development flow:

  * Install dependencies: `make setup`
  * Reformat code: `make format`
  * Lint: `make lint`
  * Run tests: `make test`
  * Run end-to-end tests: `make e2e`


pkgId: 237a8a0b647dc556115ce47af91b68afac292e57bc981740ffd7543c4b9a1489
name: python-apolo-flow-help
arch: noarch
version: 24.12.1
epoch: 0
release: 1
summary: Development documents and examples for apolo-flow
url: https://github.com/neuro-inc/neuro-flow
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apolo-flow-24.12.1-1.src.rpm
location_href: Packages/python-apolo-flow-help-24.12.1-1.noarch.rpm
checksum_type: sha256
description:
  `apolo-flow` is a tool that simplifies daily jobs on the Apolo platform.

  Apolo Flow provides users the ability to create YAML files that configure routine things, for example, starting a Jupiter Notebook on the platform, starting a training pipeline, opening a file browser for remote storage, etc.

  The tool builds required Docker images and starts all necessary Apolo jobs under the hood, while the user doesn't have to type all required `apolo` options and manually manage the pipeline scenarios.



  The tool is hosted on PyPI and can be installed by `pip` as a regular Python project:

  ```bash
  $ pip install apolo-flow
  ```

  Use the `--upgrade` option to upgrading Apolo Flow to the latest version:

  ```bash
  $ pip install --upgrade apolo-flow
  ```


pkgId: f4d0db1366c73597383f3e6da2253ba3c93d87bb714d8ad2cb3a2663298d3ca4
name: python-apolo-sdk-help
arch: noarch
version: 24.12.3
epoch: 0
release: 1
summary: Development documents and examples for apolo-sdk
url: https://github.com/neuro-inc/platform-client-python
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apolo-sdk-24.12.3-1.src.rpm
location_href: Packages/python-apolo-sdk-help-24.12.3-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/neuro-inc/platform-client-python/branch/master/graph/badge.svg)](https://codecov.io/gh/neuro-inc/platform-client-python)



  Welcome to Python Apolo-SDK for https://console.apolo.us/.



  https://apolo-sdk.readthedocs.io/en/latest/




  Install from PyPI:

  ```shell
  $ pip install apolo-sdk
  ```



  For OSX users install coreutils to properly interpret shell commands:

  ```
  brew install coreutils
  ```

  Before you begin, it is recommended to have clean virtual environment installed:

  ```shell
  $ python -m venv .env
  $ source .env/bin/activate
  ```

  Development flow:

  * Install dependencies: `make setup`
  * Reformat code: `make format`
  * Lint: `make lint`
  * Run tests: `make test`


pkgId: ab17913d5d5a78b496d1fde0ae6c387755ce4550efc0a625364ad8484d22af1b
name: python-apologies-help
arch: noarch
version: 0.1.51
epoch: 0
release: 1
summary: Development documents and examples for apologies
url: https://pypi.org/project/apologies/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apologies-0.1.51-1.src.rpm
location_href: Packages/python-apologies-help-0.1.51-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/apologies.svg)](https://pypi.org/project/apologies/)
  [![license](https://img.shields.io/pypi/l/apologies.svg)](https://github.com/pronovic/apologies/blob/master/LICENSE)
  [![wheel](https://img.shields.io/pypi/wheel/apologies.svg)](https://pypi.org/project/apologies/)
  [![python](https://img.shields.io/pypi/pyversions/apologies.svg)](https://pypi.org/project/apologies/)
  [![Test Suite](https://github.com/pronovic/apologies/workflows/Test%20Suite/badge.svg)](https://github.com/pronovic/apologies/actions?query=workflow%3A%22Test+Suite%22)
  [![docs](https://readthedocs.org/projects/apologies/badge/?version=stable&style=flat)](https://apologies.readthedocs.io/en/stable/)
  [![coverage](https://coveralls.io/repos/github/pronovic/apologies/badge.svg?branch=master)](https://coveralls.io/github/pronovic/apologies?branch=master)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)

  [Apologies](https://github.com/pronovic/apologies) is a Python library that implements a game similar to the [Sorry](https://en.wikipedia.org/wiki/Sorry!_(game)) board game.  On UNIX-like platforms, it includes a console demo that plays the game with automated players, intended for use by developers and not by end users.  See the [documentation](https://apologies.readthedocs.io/en/stable) for notes about the public interface.

  It was written as a learning exercise and technology demonstration effort, and
  serves as a complete example of how to manage a modern (circa 2020) Python
  project, including style checks, code formatting, integration with IntelliJ, CI
  builds at GitHub, and integration with PyPI and Read the Docs.


pkgId: dd3a055a0cd464ba808dae5b1ab6d5901e70a4f41ec21d444a913663af95051a
name: python-aporia-help
arch: noarch
version: 3.37.0
epoch: 0
release: 1
summary: Development documents and examples for aporia
url: https://pypi.org/project/aporia/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aporia-3.37.0-1.src.rpm
location_href: Packages/python-aporia-help-3.37.0-1.noarch.rpm
checksum_type: sha256
description:
  Aporia's Python SDK is a powerful tool designed to streamline ML monitoring and observability.

  Define your models, monitors, dashboards, segments, custom metrics, and other ML Observability resources *as code*, just like in Terraform or Pulumi. The SDK also enables you to query metrics from Aporia to integrate with other platforms.



   * **ML Monitoring as Code:** Make it easier to manage and track changes by managing your models, dashboards, segments, and other ML Observability resources as code.
   * **CI/CD Integration:** Integrate with your CI/CD pipeline to automatically monitor all your models with Aporia.
   * **Query Metrics:** Fetch metrics directly from Aporia's platform to inform decisions or to use in other applications.
   * **Data Source Integration:** You can define and integrate multiple types of data sources, like S3, Snowflake, Glue Data Catalog, Databricks, and others. This allows your models to leverage a wide range of data for training and inference.
   * **Pythonic Interface:** Use the familiar Python programming paradigm to interact with Aporia.




  You can install the Aporia SDK using pip:

  ```bash
  pip install aporia
  ```





  ```python
  import datetime
  import os

  from aporia import Aporia, MetricDataset, MetricParameters, TimeRange
  import aporia.as_code as aporia

  aporia_token = os.environ["APORIA_TOKEN"]
  aporia_account = os.environ["APORIA_ACCOUNT"]
  aporia_workspace = os.environ["APORIA_WORKSPACE"]

  stack = aporia.Stack(
      token=aporia_token,
      account=aporia_account,
      workspace=aporia_workspace,
  )



  stack.apply(yes=True, rollback=False, config_path="config.json")
  ```



  This example shows how you can use the Aporia SDK to query metrics from a model:

  ```python
  from datetime import datetime
  from aporia import (
      Aporia,
      MetricDataset,
      MetricParameters,
      TimeRange,
      DatasetType,
  )

  aporia_token = os.environ["APORIA_TOKEN"]
  aporia_account = os.environ["APORIA_ACCOUNT"]
  aporia_workspace = os.environ["APORIA_WORKSPACE"]

  aporia_client = Aporia(
      token=aporia_token,
      account_name=aporia_account,
      workspace_name=aporia_workspace,
  )

  last_week_dataset = MetricDataset(
      dataset_type=DatasetType.SERVING,
      time_range=TimeRange(
          start=datetime.now() - datetime.timedelta(days=7),
          end=datetime.now(),
      ),
  )

  metrics = aporia_client.query_metrics(
      model_id=model_id,
      metrics=[
          MetricParameters(
              dataset=MetricDataset(dataset_type=DatasetType.SERVING),
              name="count",
          ),
      ],
  )

  print(f"The model had {metrics[0]} predictions last week")
  ```

  Refer to the official Aporia documentation for detailed information on how to use the SDK.


  This package uses Poetry for dependency management. To install dependencies, use:

  ```bash
  poetry install
  ```


pkgId: 5956ae9b1ff3a12880b8df683b3bbac8dae09ff2d35e7ed7841b01efd74388df
name: python-app-server-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for app-server
url: https://github.com/viur-framework/viur-app_server
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-app-server-1.0.1-1.src.rpm
location_href: Packages/python-app-server-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  The App Server project allows to start a gunicorn server to deliver application logic. Which is wrapped by a [werkzeug](https://werkzeug.palletsprojects.com/) server to deliver staticfiles.
  Primarily the App Server is used as a lightweight alternative to the [dev_appserver](https://cloud.google.com/appengine/docs/standard/python3/testing-and-deploying-your-app?hl=de#local-dev-server) for the google appengine build with python.
  But all [gunicorn](https://gunicorn.org/) projects can be started with it.
  The static paths are stored in an app.yaml as handlers and are therefore compatible to google appengine projects.


  Take a look at the example folder. Here you can find a start.sh which starts the App Server on port 8080.



  The app server dependents on the following packages
  * [werkzeug](https://werkzeug.palletsprojects.com/)
  * [pyyaml](https://pyyaml.org/wiki/PyYAMLDocumentation)
  * [gunicorn](https://gunicorn.org/)


  use pip or pipenv to install this package
   ```sh
      pip install app-server
     ```



  Distributed under the MIT License. See `LICENSE` for more information.


pkgId: d564bc8c341d381d56af7e25efa431048bb4906c896f4f76a7095b4dbb38399c
name: python-appboot-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for appboot
url: https://github.com/taogeYT/appboot
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-appboot-0.2.8-1.src.rpm
location_href: Packages/python-appboot-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  English | [中文翻译](./README.zh-CN.md)

  [AppBoot](https://github.com/taogeYT/appboot) is a FastAPI project template designed to provide a Django-like structure and development experience.

  - Python 3.9+
  - FastAPI
  - SQLAlchemy 2.0+
  - Pydantic
  - Uvicorn


  ```shell

  mkdir mysite
  cd mysite

  python3 -m venv env
  source env/bin/activate  # On Windows use `env\\Scripts\\activate`

  pip install appboot aiosqlite

  appboot startproject mysite .  # Note the trailing '.' character

  python manage.py runserver
  ```

  ```shell
  python manage.py startapp polls
  ```

  Define a `Question` model in `polls/models.py`.
  ```python
  from datetime import datetime
  from sqlalchemy.orm import Mapped
  from appboot import models

  class Question(models.Model):
      question_text: Mapped[str]
      pub_date: Mapped[datetime]
  ```

  Define a `QuestionSchema` schema in `polls/schema.py`.
  ```python
  from appboot.schema import ModelSchema
  from polls.models import Question

  class QuestionSchema(ModelSchema):
      class Meta:
          model = Question
  ```

  Write the CRUD API in `polls/views.py`.
  ```python
  from fastapi import APIRouter, Depends
  from appboot.db import create_tables
  from appboot.params import QuerySchema, QueryDepends, PaginationResult
  from polls.models import Question
  from polls.schema import QuestionSchema

  router = APIRouter(dependencies=[Depends(create_tables)])

  @router.post('/questions/', response_model=QuestionSchema)
  async def create_question(question: QuestionSchema):
      return await question.create()

  @router.get('/questions/', response_model=PaginationResult[QuestionSchema])
  async def query_questions(query: QuerySchema = QueryDepends()):
      return await query.query_result(Question.objects.clone())

  @router.get('/questions/{question_id}', response_model=QuestionSchema)
  async def get_question(question_id: int):
      return await Question.objects.get(question_id)

  @router.put('/questions/{question_id}', response_model=QuestionSchema)
  async def update_question(question_id: int, question: QuestionSchema):
      instance = await Question.objects.get(question_id)
      return await question.update(instance)

  @router.delete('/questions/{question_id}', response_model=QuestionSchema)
  async def delete_question(question_id: int):
      instance = await Question.objects.get(question_id)
      return await instance.delete()
  ```

  Wire up the API URLs in `mysite/urls.py`.
  ```python
  from fastapi import APIRouter
  from polls.views import router

  root_router = APIRouter()
  root_router.include_router(router, prefix='/polls', tags=['polls'])
  ```

  ```shell
  python manage.py runserver
  ```
  We can now access our API directly through the browser at [http://127.0.0.1:8000/docs/](http://127.0.0.1:8000/docs/).
  ![API Documentation](https://github.com/taogeYT/oss/blob/main/resource/appboot/images/polls.png?raw=true)

  Create a `QuestionQuerySchema` for complex queries in `polls/schema.py`.
  ```python
  from typing import Optional
  from appboot.params import QuerySchema
  from appboot.filters import EqField, ContainsField

  class QuestionQuerySchema(QuerySchema):
      ids: Optional[list[int]] = EqField(None, alias='pk', columns='id')  # Query questions by ID list
      question_text: Optional[str] = ContainsField(None)  # Fuzzy query question_text
  ```
  Replace `QuerySchema` with `QuestionQuerySchema` in `polls/views.py`, refresh the docs in the browser, and you will see two new query parameters in the query questions API.
  ![Complex Query Parameters](https://github.com/taogeYT/oss/blob/main/resource/appboot/images/query.png?raw=true)

  Go to [Examples](./examples) for more examples.


pkgId: 4a911a04f6558673ee718d892ff5d8fcd180a25cfedb672ec54e14a93cb31356
name: python-appmesh
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Client SDK for App Mesh
url: https://github.com/laoshanxi/app-mesh
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-appmesh-1.4.0-1.src.rpm
location_href: Packages/python-appmesh-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Application management | 1. Manage independent applications with flexible process control (long/short running, periodic, cron schedule, custom timings, error handling) and comprehensive monitoring (start counts, return codes, error messages, health checks) for both native and Docker applications. <br> 2. Run applications on remote hosts using SDK/CLI with sync/async modes and fetch results to the client. <br> 3. Full control over application lifecycle (cgroup resource limitation, specific OS user for execution). <br> 4. Support interactive application start with specific input data via pipe and environment variables. <br> 5. Access all functionalities via [CLI](https://app-mesh.readthedocs.io/en/latest/CLI.html), [REST](https://app-mesh.readthedocs.io/en/latest/Development.html#rest-apis), [SDK](https://github.com/laoshanxi/app-mesh/tree/main/src/sdk) and [WebGUI](https://github.com/laoshanxi/app-mesh-ui) interface.<br>
  Security |  ⚡️ [JWT authentication](https://app-mesh.readthedocs.io/en/latest/JWT.html) for CLI and REST interface <br> ⚡️ [LDAP support](https://app-mesh.readthedocs.io/en/latest/LDAP.html) <br> ⚡️ [Role based permission control](https://app-mesh.readthedocs.io/en/latest/USER_ROLE.html) <br> ⚡️ [Multi-factor authentication](https://app-mesh.readthedocs.io/en/latest/MFA.html)<br> SSL support (ECDH and secure ciphers) for REST http connection  <br> Multi-tenant support
  Cloud native | Schedule cloud-level applications to run on multiple hosts with resource size requests. <br> ⚡️ [Prometheus Exporter (build-in)](https://app-mesh.readthedocs.io/en/latest/PROMETHEUS.html) <br> ⚡️ [Grafana SimpleJson datasource](https://app-mesh.readthedocs.io/en/latest/GrafanaDataSource.html) <br> ⚡️ [Grafana Loki](https://app-mesh.readthedocs.io/en/latest/Loki.html) <br>⚡️ [Dockerfile](https://github.com/laoshanxi/app-mesh/blob/main/Dockerfile)
  Micro service application | ⚡️ [Consul micro-service cluster management](https://app-mesh.readthedocs.io/en/latest/CONSUL.html)
  Extra Features | Collect host/app resource usage <br> Remote shell command execution <br> File upload/download interface <br> Hot-update support `systemctl reload appmesh` <br> Bash completion <br> Reverse proxy <br> [Web GUI](https://github.com/laoshanxi/app-mesh-ui)
  Platform support | X86_64 <br> ARM32 <br> ARM64
  SDK | [Python](https://app-mesh.readthedocs.io/en/latest/api/appmesh_client.html) <br> [Golang](https://github.com/laoshanxi/app-mesh/blob/main/src/sdk/go/appmesh_client.go) <br> [JavaScript](https://www.npmjs.com/package/appmesh) <br> [Java](https://github.com/laoshanxi/app-mesh/packages/2227502) <br> [Swagger OpenAPI Specification](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/laoshanxi/app-mesh/main/src/daemon/rest/openapi.yaml)

  Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Install.html) to learn how to install App Mesh via Docker Compose or natively and set up an App Mesh cluster.

  - [Read the Docs](https://app-mesh.readthedocs.io/)
  - [REST API](https://app-mesh.readthedocs.io/en/latest/Development.html#rest-apis)
  - [Command lines](https://app-mesh.readthedocs.io/en/latest/CLI.html)
  - [Security](https://app-mesh.readthedocs.io/en/latest/JWT.html)


  | Feature                  | App Mesh | [Supervisor](http://supervisord.org/) | [crontab](https://crontab.guru/) |
  | ------------------------ | -------- | ------------------------------------- | -------------------------------- |
  | Accuracy                 | Seconds  | Seconds                               | Minutes                          |
  | Language                 | C++11    | Python                                | C                                |
  | Web GUI                  | √        | √                                     |
  | Command lines            | √        | √                                     | √                                |
  | SDK                      | √        |                                       |
  | Cron schedule expression | √        |                                       | √                                |
  | Manage daemon process    |          |                                       | √                                |
  | Manage docker app        | √        |                                       |
  | Start check (avoid leak) | √        | √                                     |
  | Session login            |          |                                       |
  | Manage stdout/stderr     | √        | √                                     |
  | Health check             | √        |                                       |
  | Rich control options     | √        |                                       |
  | Authentication           | √        | √                                     |
  | Multi-tenant             | √        |                                       | √                                |

  | Feature           | App Mesh | Kubernetes |
  | ----------------- | -------- | ---------- |
  | Easy deploy       | √        |
  | More features     |          | √          |
  | Non-container app | √        |
  | Service expose    | √        | √          |
  | Scheduler         | √        | √          |
  | Definition file   | YAML     | YAML       |
  | GUI               | √        | √          |
  | Virtual Network   |          | √          |


pkgId: 5697c778dacb73dac737f5246e4b897aaf39b461d63cf93e9ccb4ed778c3490b
name: python-appstract-help
arch: noarch
version: 24.12.0
epoch: 0
release: 1
summary: Development documents and examples for appstract
url: https://pypi.org/project/appstract/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-appstract-24.12.0-1.src.rpm
location_href: Packages/python-appstract-help-24.12.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
  [![PyPI badge](http://img.shields.io/pypi/v/appstract.svg)](https://pypi.python.org/pypi/appstract)
  [![Anaconda-Server Badge](https://anaconda.org/scipp/appstract/badges/version.svg)](https://anaconda.org/scipp/appstract)
  [![License: BSD 3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](LICENSE)





  Python application construction helper.



  ```sh
  python -m pip install appstract
  ```

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


pkgId: 7e4cace9bb352a24ce709c0920b10f860fd40f4f31784599c1af2bed3b77cf01
name: python-appthreat-vulnerability-db-help
arch: noarch
version: 6.2.2
epoch: 0
release: 1
summary: Development documents and examples for appthreat-vulnerability-db
url: https://github.com/appthreat/vulnerability-db
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-appthreat-vulnerability-db-6.2.2-1.src.rpm
location_href: Packages/python-appthreat-vulnerability-db-help-6.2.2-1.noarch.rpm
checksum_type: sha256
description:
  This repo is a vulnerability database and package search for sources such as AppThreat vuln-list, OSV, NVD, and GitHub. Vulnerability data are downloaded from the sources and stored in a sqlite based storage with indexes to allow offline access and efficient searches.



  A good vulnerability database must have the following properties:

  - Accuracy
  - Easy to [download](#download-pre-built-database-recommended), [integrate](./INTEGRATION.md), and use
  - Performance

  Multiple upstream sources are used by vdb to improve accuracy and reduce false negatives. SQLite database containing data in CVE 5.1 schema format is precompiled and distributed as files via ghcr to simplify download. With automatic purl prefix generation even for git repos, searches on the database can be performed with purl, cpe, or even http git url string. Every row in the database uses an open specification such as CVE 5.0 or Package URL (purl and vers) thus preventing the possibility of vendor lock-in.



  - Linux [vuln-list](https://github.com/appthreat/vuln-list) (Forked from AquaSecurity)
  - OSV (1)
  - NVD
  - GitHub

  1 - We exclude Linux and oss-fuzz feeds by default. Set the environment variable `OSV_INCLUDE_FUZZ=true` to include them.
  2 - Malware feeds are included by default, thus increasing the db size slightly. Set the environment variable `OSV_EXCLUDE_MALWARE=true` to exclude them.



  - AlmaLinux
  - Debian
  - Alpine
  - Amazon Linux
  - Arch Linux
  - RHEL/CentOS
  - Rocky Linux
  - Ubuntu
  - OpenSUSE
  - Photon
  - Chainguard
  - Wolfi OS



  ```shell
  pip install appthreat-vulnerability-db>=6.2.0
  ```

  To install vdb with optional dependencies such as `oras` use the `[oras]` or `[all]` dependency group.

  ```shell
  pip install appthreat-vulnerability-db[all]
  ```

  **NOTE:** VDB v6 is a major rewrite to use SQLite database. Current users of depscan v5 must continue using version 5.8.x

  ```shell
  pip install appthreat-vulnerability-db==5.8.0
  ```



  This package is ideal as a library for managing vulnerabilities. This is used by [owasp-dep-scan](http://github.com/owasp-dep-scan/dep-scan), a free open-source dependency audit tool. However, there is a limited cli capability available with few features to test this tool directly.



  To download a pre-built SQLite database ([refreshed](https://github.com/AppThreat/vdb/actions) every 6 hours) containing all application vulnerabilities (~ 700MB). This step is recommended for all users.

  ```shell

  vdb --download-image
  ```

  You can execute this command daily or when a fresh database is required.

  To perform containers and OS scans, download the full image (~ 7.5GB) which includes all application and OS vulnerabilities.

  ```
  vdb --download-full-image
  ```



  Using [ORAS cli](https://oras.land/) might be slightly faster.

  ```
  export VDB_HOME=$HOME/vdb
  oras pull ghcr.io/appthreat/vdbxz:v6 -o $VDB_HOME
  tar -xvf *.tar.xz
  rm *.tar.xz
  ```

  Use any sqlite browser or cli tools to load and query the two databases.

  **data.index.vdb6** - index db with purl prefix and vers

  <img src="./docs/index-vdb6.png" alt="index" width="400">

  **data.vdb6** - Contains source data in CVE 5.1 format stored as a jsonb blob.

  <img src="./docs/vdb6.png" alt="database" width="400">



  Cache application vulnerabilities

  ```shell
  vdb --cache
  ```

  The typical size of this database is over 700 MB.

  Cache from just [OSV](https://osv.dev)

  ```shell
  vdb --cache --only-osv
  ```

  It is possible to customize the cache behavior by increasing the historic data period to cache by setting the following environment variables.

  - NVD_START_YEAR - Default: 2018. Supports up to 2002
  - GITHUB_PAGE_COUNT - Default: 2. Supports up to 20

  Cache application and OS vulnerabilities

  ```shell
  vdb --cache-os
  ```

  Note the size of the database with OS vulnerabilities is over 7.5 GB. It is possible to ignore/exlude specific OS distros using environment variables.

  Example to ignore almalinux and ubuntu data from getting included, set the below environment variables:

  ```shell
  export VDB_IGNORE_ALMALINUX=true
  export VDB_IGNORE_UBUNTU=true
  ```

  Refer to the variable `LINUX_DISTRO_VULN_LIST_PATHS` in [config.py](./vdb/lib/config.py) for the full list of distro strings supported.



  ```shell
  usage: vdb [-h] [--clean] [--cache] [--cache-os] [--only-osv] [--only-aqua] [--only-ghsa] [--search SEARCH] [--list-malware] [--bom BOM_FILE]

  AppThreat's vulnerability database and package search library with a built-in sqlite based storage.

  options:
    -h, --help       show this help message and exit
    --clean          Clear the vulnerability database cache from platform specific user_data_dir.
    --cache          Cache vulnerability information in platform specific user_data_dir.
    --cache-os       Cache OS vulnerability information in platform specific user_data_dir.
    --only-osv       Use only OSV as the source. Use with --cache.
    --only-aqua      Use only Aqua vuln-list as the source. Use with --cache.
    --only-ghsa      Use only recent ghsa as the source. Use with --cache.
    --search SEARCH  Search for the package or CVE ID in the database. Use purl, cpe, or git http url.
    --list-malware   List latest malwares with CVE ID beginning with MAL-.
    --bom BOM_FILE   Search for packages in the CycloneDX BOM file.
    --download-image      Downloaded pre-created vdb image to platform specific user_data_dir. Application vulnerabilities only.
    --download-full-image
                          Downloaded pre-created vdb image to platform specific user_data_dir. All vulnerabilities including OS.
    --print-vdb-metadata  Display metadata about the current vdb in user_data_dir.
  ```



  It is possible to perform a range of searches using the cli.

  ```shell
  vdb --search pkg:pypi/xml2dict@0.2.2


  vdb --search pkg:pypi/xml2dict


  vdb --search "pkg:swift/github.com/vapor/vapor@4.39.0"

  vdb --search "pkg:swift/vapor/vapor@4.89.0"


  vdb --search "cpe:2.3:a:npm:gitblame:*:*:*:*:*:*:*:*"


  vdb --search "npm:gitblame:0.0.1"


  vdb --search CVE-2024-25169


  vdb --search CVE-2024-%


  vdb --search "https://github.com/electron/electron"


  vdb --bom bom.json
  ```



  To list malware entries with the `MAL-` prefix, use the following command.

  ```shell
  vdb --list-malware
  ```



  Refer to [cli.py](./vdb/cli.py) for usage. Below is a sample code snippet.

  ```python
  from vdb.lib import config, db6 as db_lib, search
  from vdb.lib.cve_model import CVE


  results = search.search_by_any("purl or cpe or url", with_data=True)


  from vdb.lib.orasclient import download_image

  download_image(config.VDB_DATABASE_URL, config.DATA_DIR)


  if db_lib.needs_update():
      print("Database needs to be updated")
      download_image(...)
  ```



  MIT


pkgId: a1817182abbb9339972650bdd40eb14c4712831b681e21b277e6899941222846
name: python-apsbss-help
arch: noarch
version: 1.5.6
epoch: 0
release: 1
summary: Development documents and examples for apsbss
url: https://BCDA-APS.github.io/apsbss
rpm_license: (c) 2017-2022, UChicago Argonne, LLC (see LICENSE.txt file for details)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apsbss-1.5.6-1.src.rpm
location_href: Packages/python-apsbss-help-1.5.6-1.noarch.rpm
checksum_type: sha256
description:
  Read-only interface to information from APS Proposal and ESAF (experiment safety
  approval form) databases.

  home: https://bcda-aps.github.io/apsbss/

  [![Release](https://img.shields.io/github/release/BCDA-APS/apsbss.svg)](https://github.com/BCDA-APS/apsbss/releases)
  [![Tag](https://img.shields.io/github/tag/BCDA-APS/apsbss.svg)](https://github.com/BCDA-APS/apsbss/tags)
  [![Build Status](https://img.shields.io/github/workflow/status/BCDA-APS/apsbss/Unit%20Tests)](https://github.com/BCDA-APS/apsbss/actions?query=workflow%3A%22Unit+Tests%22+branch%3Amain)
  [![License](https://anaconda.org/aps-anl-tag/apsbss/badges/license.svg)](https://anaconda.org/aps-anl-tag/apsbss)

  [![PyPI](https://img.shields.io/pypi/v/apsbss.svg)](https://pypi.python.org/pypi/apsbss)
  [![Conda package](https://anaconda.org/aps-anl-tag/apsbss/badges/installer/conda.svg)](https://conda.anaconda.org/prjemian)
  [![Conda package version](https://anaconda.org/aps-anl-tag/apsbss/badges/version.svg)](https://anaconda.org/aps-anl-tag/apsbss)
  [![Conda package platform(s)](https://anaconda.org/aps-anl-tag/apsbss/badges/platforms.svg)](https://anaconda.org/aps-anl-tag/apsbss)
  [![Conda package release date](https://anaconda.org/aps-anl-tag/apsbss/badges/latest_release_date.svg)](https://anaconda.org/aps-anl-tag/apsbss)


pkgId: a23c617194771bba1ad430ee801b2a8dffcd3c724e0233d6f2155801bbe6b6c9
name: python-apsg-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for apsg
url: https://github.com/ondrolexa/apsg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apsg-1.3.0-1.src.rpm
location_href: Packages/python-apsg-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://ondrolexa.github.io/apsg/apsg_banner.svg" alt="APSG logo" width="300px"/>

  [![PyPI - Version](https://img.shields.io/pypi/v/apsg)](https://pypi.org/project/apsg)
  [![Conda](https://img.shields.io/conda/v/conda-forge/apsg)](https://anaconda.org/conda-forge/apsg)
  [![Documentation Status](https://readthedocs.org/projects/apsg/badge/?version=stable)](https://apsg.readthedocs.io/en/stable/?badge=stable)
  [![DOI](https://zenodo.org/badge/24879346.svg)](https://zenodo.org/badge/latestdoi/24879346)



  APSG is the package for structural geologists. It defines several new python classes to easily manage, analyze and visualize orientational structural geology data.

  > [!IMPORTANT]
  > APSG has been significantly refactored from version 1.0 and several changes are
  > breaking backward compatibility. The main APSG namespace provides often-used
  > classes in lowercase names as aliases to `PascalCase` convention used in
  > modules to provide a simplified interface for users. The `PascalCase` names of
  > classes use longer and plain English names instead acronyms for better readability.
  >
  > Check [documentation](https://apsg.readthedocs.org) for more details.



  You need Python 3.9 or later to run APSG. The package requires [NumPy](https://numpy.org/) and [SciPy](https://www.scipy.org/),
  [Matplotlib](https://matplotlib.org/), [SciPy](https://scipy.org/), [SQLAlchemy](https://www.sqlalchemy.org/)
  and [pandas](https://pandas.pydata.org/).



  Install the **latest stable** version of APSG from PyPI:
  ```bash
  pip install apsg
  ```

  or install **master** with:
  ```bash
  pip install git+https://github.com/ondrolexa/apsg.git
  ```

  Alternatively, you can cloce the repository and do a local install (recommended for dev):
  ```bash
  git clone https://github.com/ondrolexa/apsg.git
  cd apsg
  pip install -e ."
  ```



  To upgrade an existing version of APSG from PyPI, execute:
  ```bash
  pip install apsg --upgrade --no-deps
  ```



  Latest Debian-based systems does not allow to install non-debian packages system-wide.
  However, installing all requirements allows to force install APSG system-wide without troubles.

  Install requirements using apt:
  ```bash
  sudo apt install python3-numpy python3-matplotlib python3-scipy python3-sqlalchemy python3-pandas
  ```

  and then install apsg using pip:
  ```bash
  pip install --break-system-packages apsg
  ```



  The APSG package is also available on `conda-forge` channel. Installing `apsg`
  from the `conda-forge` channel can be achieved by adding `conda-forge` to your
  channels:

  ```bash
  conda config --add channels conda-forge
  ```

  Once the `conda-forge` channel has been enabled, `apsg` can be installed with:

  ```bash
  conda install apsg
  ```

  It is possible to list all of the versions of `apsg` available on your platform with:

  ```bash
  conda search apsg --channel conda-forge
  ```



  | Name | Downloads | Version | Platforms |
  | --- | --- | --- | --- |
  | [![Conda Recipe](https://img.shields.io/badge/recipe-apsg-green.svg)](https://anaconda.org/conda-forge/apsg) | [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/apsg.svg)](https://anaconda.org/conda-forge/apsg) | [![Conda Version](https://img.shields.io/conda/vn/conda-forge/apsg.svg)](https://anaconda.org/conda-forge/apsg) | [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/apsg.svg)](https://anaconda.org/conda-forge/apsg) |



  Explore all the features of APSG. You can find detailed documentation [here](https://apsg.readthedocs.org).



  Most discussion happens on [Github](https://github.com/ondrolexa/apsg). Feel free to open [an issue](https://github.com/ondrolexa/apsg/issues/new) or comment on any open issue or pull request. Check ``CONTRIBUTING.md`` for more details.



  APSG is an open-source project, available for you for free. It took a lot of time and resources to build this software. If you find this software useful and want to support its future development please consider donating me.

  [![Donate via PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=QTYZWVUNDUAH8&item_name=APSG+development+donation&currency_code=EUR&source=url)



  APSG is free software: you can redistribute it and/or modify it under the terms of the MIT License. A copy of this license is provided in ``LICENSE`` file.


pkgId: d073458ee868b85b940ed4562e3fb5e1e07afbccdc1483a1c9e4d9e7f609fe40
name: python-apyefa-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for apyefa
url: https://github.com/alex-jung/apyefa
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apyefa-0.0.3-1.src.rpm
location_href: Packages/python-apyefa-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/alex-jung/apyefa/actions/workflows/python-package.yml/badge.svg)](https://github.com/alex-jung/apyefa/actions/workflows/python-package.yml)
  [![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  **apyefa** is a python package used to asynchronously fetch public transit routing data via EFA  interfaces like [efa.vgn](https://efa.vgn.de/vgnExt_oeffi/"). It can request itineraries for Bus/Trams/Subways etc. connections and return data in a human and machine readable format.

  You only need to install the **apyefa** package, for example using pip:
  ``` bash
  pip install apyefa
  ```


  Currently the package supports only endpoints using [RapidJSON](https://rapidjson.org/) format. To check whether the endpoint supports this format, please call:
  ``` bash
  To describe(!)
  ```


  Create and activate virtual environment. Then install dependencies required by `apefa` package.
  ``` bash
  python3 -m venv .venv
  source .venv/bin/activate
  pip install .
  ```


  |Function name                                       |Implementation    |Documentation     |
  |----------------------------------------------------|------------------|------------------|
  |[info()](#info)                                     |:white_check_mark:|:white_check_mark:|
  |[locations_by_name()](#locations_by_name)           |:white_check_mark:|:white_check_mark:|
  |[location_by_coord()](#locations_by_coord)          |:white_check_mark:|:white_check_mark:|
  |[trip()](#trip)                                     |:x:               |:x:               |
  |[departures_by_location()](#departures_by_location) |:white_check_mark:|:white_check_mark:|
  |[lines_by_name()](#lines_by_name)                   |:white_check_mark:|:white_check_mark:|
  |[lines_by_location()](#lines_by_location)           |:white_check_mark:|:white_check_mark:|
  |[locations_by_line()](#locations_by_line) |:x:               |:x:               |
  |[coords()](#coords)                                 |:x:               |:x:               |
  |[geo_object()](#geo_object)                         |:x:               |:x:               |
  |[trip_stop_time()](#trip_stop_time)                 |:x:               |:x:               |
  |[stop_seq_coord()](#stop_seq_coord)                 |:x:               |:x:               |
  |[map_route()](#map_route)                           |:x:               |:x:               |
  |[add_info()](#add_info)                             |:x:               |:x:               |
  |[stop_list()](#stop_list)                           |:x:               |:x:               |
  |[line_list()](#line_list)                           |:x:               |:x:               |


  Provides end API system information.


  None


  |Type|Description|
  |----|-----------|
  |[SystemInfo](#systeminfo)|System information object|


  ``` python
  from apyefa import EfaClient, SystemInfo
  from pprint import pprint

  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      info: SystemInfo = await client.info()

      pprint(info)

      
      
      
      
      
      
      
  ```


  Find localities by name or unique id.


  |Name     |Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |name     |str                 |required|Name or id ID of locality to search for|
  |filters  |list[[LocationFilter](#locationfilter)]|optional|The localition search may be limited by certain types of objects using this parameter. Default value is `[]`|
  |limit    |int                 |optional|Max size of returned list. Default value is `30`|


  |Type|Description|
  |----|-----------|
  |list[[Location](#location)]|List of locations found py provided name sorted by match quality|



  1. Search for all localities contain name `Plärrer`
  ``` python
  from apyefa import EfaClient, Location, LocationFilter

  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      locations: list[Location] = await client.locations_by_name("Plärrer")

      print(f"Found {len(locations)} location(s)")
      print(location[0].id)
      print(location[0].name)
      print(location[0].loc_type)
      
      
      
      
      
  ```
  2. Search for POIs and Addresses with name `Plärrer`
  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      locations: list[Location] = await client.locations_by_name("Plärrer", filters=[LocationFilter.ADDRESSES, LocationFilter.POIS])

      print(f"Found {len(locations)} location(s)")
      print(location[0].id)
      print(location[0].name)
      print(location[0].loc_type)

      
      
      
      
      
  ```
  3. Search by `stop id`
  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      locations: list[Location] = await client.locations_by_name("de:09564:704")

      print(f"Found {len(locations)} location(s)")
      print(location[0].id)
      print(location[0].name)
      print(location[0].loc_type)
      
      
      
      
      
  ```


  Find localities by coordinates.

  > :x: Currently test endpoint does not sent any answers for this request


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |coord_x  |float               |required|X-coordinate|
  |coord_y  |float               |required|Y-coordinate|
  |format   |[CoordFormat](#coordformat)|optional|Coordinates format used for request|
  |limit    |int                 |optional|Max size of returned list. Default value is `10`|


  |Type|Description|
  |----|-----------|
  |list[[Location](#location)]|List of locations found py provided name sorted by match quality|




  Find all departures for a specific location


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |stop     |[Location](#location) \| str |required|Location for which the departures are being sought|
  |limit    |int                 |optional|Max size of returned list. Default value is `40`|
  |date     |str                 |optional|Date/time for which the departures are sought in format "YYYYMMDD hh:mm", "YYYYMMDD" or "mm:hh". Default value is `empty`|


  |Type|Description|
  |----|-----------|
  |list[[Departure](#departure)]|List of departures sorted by departure time|


  ``` python
  from apyefa import EfaClient, Departure

  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      departures: list[Departure] = await client.departures_by_location("de:09564:704", limit=3, date="22:13")

      print(f"Found {len(departures)} departure(s)")
      print(location[0].line_name)
      print(location[0].route)
      print(location[0].transport)
      print(location[0].planned_time)
      
      
      
      
      
      
  ```


  Find lines by name.


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |name  |str               |required|Name of the line to search. e.g. `U1` or `67`|


  |Type|Description|
  |----|-----------|
  |list[[Line](#line)]|List of lines found for provided name|

  > NOTE: The attribute `origin` of returned `line` objects is None


  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      lines: list[Line] = await client.lines_by_name("U1")

      print(f"Found {len(lines)} line(s)")
      print(f"id         : {lines[0].id}")
      print(f"name       : {lines[0].name}")
      print(f"description: {lines[0].description}")
      print(f"product    : {lines[0].product}")

      
      
      
      
      
      
  ```


  Find lines pass provided location.


  |Arguments|Type                |Required|Description|
  |---------|--------------------|--------|-----------|
  |location |str \| [Location](#location) |required|The location passed by searched line(s)|


  |Type|Description|
  |----|-----------|
  |list[[Line](#line)]|List of lines found for provided location|

  > The attribute `origin` of returned `line` objects is None


  ``` python
  async with EfaClient("https://efa.vgn.de/vgnExt_oeffi/") as client:
      lines: list[Line] = await client.lines_by_location("de:09564:704")

      print(f"Found {len(lines)} line(s)")
      print(f"id         : {lines[0].id}")
      print(f"name       : {lines[0].name}")
      print(f"description: {lines[0].description}")
      print(f"product    : {lines[0].product}")

      
      
      
      
      
      
  ```












  |Attribute   |Type|Description  |
  |------------|----|------------------------ |
  |version     |str |API internal information|
  |app_version |str |API internal information |
  |data_format |str |API internal information |
  |data_build  |str |API internal information |
  |valid_from  |date|Start validity date      |
  |valid_to    |date|End validity date        |


  |Attribute        |Type               |Description  |
  |-----------------|-------------------|-------------|
  |name             |str                |Name of location e.g. `Nürnberg, Nordostbahnhof`|
  |loc_type         |[LocationType](#locationtype)|Type of location e.g. `STOP` or `POI`|
  |id               |str                |Location unique id|
  |coord            |list[int]          |Location coordinates|
  |transports       |list[[TransportType](#transporttype)]|Transport type(s) this location pass|
  |parent           |[Location](#location) \| None|Parent location|
  |stops            |list[[Location](#location)]|Location with type `STOP` assigned to this location|
  |properties       |dict               |API internal information|


  |Attribute      |Type|Description              |
  |---------------|----|------------------------|
  |location       |[Location](#location) |Location of departure|
  |line_name      |str |Line name e.g. `U3`|
  |route          |str |The complete route name from origin to destination stops e.g. `Nordwestring - Hauptbahnhof - Plärrer - Großreuth bei Schweinau`|
  |origin         |[Location](#location)|Origin location|
  |destination    |[Location](#location)|Destination location|
  |transport      |[TransportType](#transporttype)|Transport type e.g. `Bus` or `Subway`|
  |planned_time   |datetime|Planned departure time|
  |estimated_time |datetime \| None|Estimated departure time(will be provided by endpoits supporting real time mode)|
  |infos          |list[dict] \| None|List of ICS messages|


  |Attribute   |Type|Description              |
  |------------|----|------------------------ |
  |id          |str |Line id                  |
  |name        |str |Line name                |
  |description |str |Route name               |
  |product     |[TransportType](#transporttype) |Type of transportation. Bus, Subway etc.|
  |destination |[Location](#location)|Line destination location|
  |origin      |[Location](#location) \| None|Line start location|
  |properties  |dict|Additional properties    |



  ```python
  class TransportType(IntEnum):
      RAIL        = 0
      SUBURBAN    = 1
      SUBWAY      = 2
      CITY_RAIL   = 3
      TRAM        = 4
      BUS         = 5
      RBUS        = 6
      EXPRESS_BUS = 7
      CABLE_TRAM  = 8
      FERRY       = 9
      AST         = 10  # Anruf-Sammel-Taxi
  ```


  ```python
  class CoordFormat(StrEnum):
      WGS84 = "WGS84 [dd.ddddd]"
  ```


  ```python
  class LocationFilter(IntEnum):
      NO_FILTER     = 0
      LOCATIONS     = 1
      STOPS         = 2
      STREETS       = 4
      ADDRESSES     = 8
      INTERSACTIONS = 16
      POIS          = 32
      POST_CODES    = 64
  ```


  ```python
  class LocationType(StrEnum):
      STOP     = "stop"
      POI      = "poi"
      ADDRESS  = "address"
      STREET   = "street"
      LOCALITY = "locality"
      SUBURB   = "suburb"
      PLATFORM = "platform"
      UNKNOWN  = "unknown"
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Alex Jung  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: 9e5bef7958ffbf0b497c5da9e676222c08caeb50b7e0234c3fd891e71b0a3448
name: python-archaea-simulation-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for archaea-simulation
url: https://github.com/archaeans/archaea-simulation
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-archaea-simulation-1.3.0-1.src.rpm
location_href: Packages/python-archaea-simulation-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Wrapper definitions for simulation tools.

  Motivation of creating this library is started with master thesis, departments of Computational
  Science and Engineering and Architecture at Istanbul Technical University.
  Aim of thesis is to create scenarios for different environmental
  solvers like EnergyPlus and OpenFOAM to run them parallely on Linux environment.
  Preparation of these scenario files done by geometric [Archaea](https://github.com/archaeans/archaea) library.




  - OpenFOAM: OpenFOAM requires stl geometries to run it's solvers
  behind the scenes. (Pre-Alpha)
  - EnergyPlus: EnergyPlus requires idf schema to run simulations. It happens via LadybugTools. (MVP)
  - UWG: Urban weather generator is a solver to calculate effects on urban microclimate.
  It creates new .epw file for EnergyPlus simulations.

  Main idea behind this work is to be experimental and didactic.


pkgId: a2c95707833e6f00da6dfa00f757090ad46bc1c1540767f04c3be7d3a87289b5
name: python-archeo-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for archeo
url: https://pypi.org/project/archeo/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-archeo-1.1.0-1.src.rpm
location_href: Packages/python-archeo-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![github](https://img.shields.io/badge/GitHub-archeo-blue.svg)](https://github.com/wyhwong/archeo)
  [![PyPI version](https://badge.fury.io/py/archeo.svg)](https://pypi.org/project/archeo/)
  [![DOI](https://zenodo.org/badge/626377469.svg)](https://doi.org/10.5281/zenodo.14306853)
  [![Downloads](https://img.shields.io/pepy/dt/archeo)](https://github.com/wyhwong/archeo)
  [![Python version](https://img.shields.io/pypi/pyversions/archeo)](https://pypi.org/project/archeo/)
  [![license](https://img.shields.io/badge/license-MIT-orange.svg)](https://github.com/wyhwong/archeo/blob/main/LICENSE)
  [![CI](https://github.com/wyhwong/archeo/actions/workflows/main.yml/badge.svg)](https://github.com/wyhwong/archeo/actions/workflows/main.yml/)



  The following example demonstrates how to use the package to visualize the prior and posterior distributions of a single event.

  ```python
  import archeo



  mass_posterior = [68.0, 71.4, ..., 91.4]
  spin_posterior = [0.31, 0.54, ..., 0.64]


  prior = archeo.Prior.from_config("precessing")

  posterior = prior.to_posterior(mass_posterior, spin_posterior)


  archeo.visualize_prior_distribution(prior, output_dir="./")
  archeo.visualize_posterior_estimation({"GW190521": posterior}, output_dir="./")
  ```



  Check out the preset priors in [precessing.py](https://github.com/wyhwong/archeo/blob/main/src/archeo/preset/precessing.py) and [aligned_spin.py](https://github.com/wyhwong/archeo/blob/main/src/archeo/preset/aligned_spin.py). From that, one should be able to create their own prior by following the same structure.


  The code is maintained by [Henry Wong](https://github.com/wyhwong) under [Juan Calderon Bustillo](https://git.ligo.org/juan.calderonbustillo)'s supervision. You can find the [list of contributors](https://github.com/wyhwong/archeo/graphs/contributors) here. Please report bugs by raising an issue on our [GitHub](https://github.com/wyhwong/archeo) repository.


pkgId: be151350cb3a4f67f64032c8415de09c4bf7365220c3bf3c2f601aab16a57386
name: python-architect-py-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for architect-py
url: https://pypi.org/project/architect-py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-architect-py-2.0.0-1.src.rpm
location_href: Packages/python-architect-py-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ```python
  import asyncio
  from architect_py.async_client import AsyncClient


  async def main():
      c = AsyncClient(
          host="<your installation domain>",
          api_key="<api key>",
          api_secret="<api secret>"
      )
      print(await c.execute("query { me { userId email } }"))
      s = c.subscribe_trades("BTC Crypto/USD*COINBASE/DIRECT")
      async for trade in s:
          print(trade)


  asyncio.run(main())
  ```



  Clone this repository to run examples in the `examples` directory.  This package
  uses poetry for dependency management.  To enter a poetry virtual environment, make
  sure you have [poetry](https://python-poetry.org/docs/) installed and run the
  following from the repository root.

  ```bash
  poetry shell
  poetry install --sync

  export ARCHITECT_HOST="<your installation domain>"
  export ARCHITECT_API_KEY="<api key>"
  export ARCHITECT_API_SECRET="<api secret>"

  python -m examples.trades
  ```

  You can exit the poetry shell by running `exit`.  Environment variables set
  within the shell are not persisted.



  Python type conversions for scalars should be added to the codegen toml files, if needed.

  Important files:
  - `schema.graphql`: autogenerated from `architect-gql schema`
  - `queries.graphql`: add any new queries/mutations
  - `generate_protocol.py`: autogenerates the `architect_py/protocol/client_protocol.py`
  - `architect_py/protocol/client_protocol.py`: autogenerated from `generate_protocol.py`, contains the class that the sync client inherits from
  - `architect_py/async_client.py`: inherits from the ariadne generated base client
  - `architect_py/client.py`: contains the sync client, delegates functions calls to a composed AsyncClient in the innards, inherits from the client_protocl to give the correct type hinting from Pylance
  - `tests` and `examples`: self-explanatory

  On any update, please run `update.sh`

  In addition, any new function should have a test included in test.py

  To run tests:
  `export $(cat pytest.env | xargs)`
  `pytest tests/*`




  1. Uses ariadne-codegen to generate the async client
  2. Autogenerates the protocol that the sync client inherits from
  3. Runs the tests


pkgId: 371d032f197902e7f92c53fab75ac43d5a9d9e7897da570d39c29cd0032e5b05
name: python-arduino-hid-emulator-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for arduino-hid-emulator
url: https://github.com/mvandrew/arduino-hid-emulator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arduino-hid-emulator-0.1.0-1.src.rpm
location_href: Packages/python-arduino-hid-emulator-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **РџСЂРёРјРµС‡Р°РЅРёРµ**: РЈР±РµРґРёС‚РµСЃСЊ, С‡С‚Рѕ СЃРєРµС‚С‡ РґР»СЏ Arduino Р·Р°РіСЂСѓР¶РµРЅ Рё СѓСЃС‚СЂРѕР№СЃС‚РІРѕ РїРѕРґРґРµСЂР¶РёРІР°РµС‚ HID.


pkgId: f25073f2ec01ad6d3e241e1495a84502e79bd61b8eb103fed1f2412ba4866818
name: python-arg-services-help
arch: noarch
version: 1.7.2
epoch: 0
release: 1
summary: Development documents and examples for arg-services
url: http://recap.uni-trier.de
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arg-services-1.7.2-1.src.rpm
location_href: Packages/python-arg-services-help-1.7.2-1.noarch.rpm
checksum_type: sha256
description:
  This project contains Protobuf definitions for building complex argumentation machines.
  The idea is to facilitate a microservice-oriented architecture where individual parts can be swapped out easily.
  Along with the Protobuf files, the project also contains code for generating libraries for multiple programming languages that are released as packages in their respective registries:

  - [Python](https://pypi.org/project/arg-services/)
  - [TypeScript](https://www.npmjs.com/package/arg-services)

  Documentation can be found at the [Buf Schema Registry](https://buf.build/recap/arg-services).



  `rm -rf ./src && nix run .#buf-generate`


pkgId: d1ff5fe72c6968fbbdc1add9beb25ed775d9b096cf351860471404690a206cc7
name: python-argo-workflows-help
arch: noarch
version: 6.6.2
epoch: 0
release: 1
summary: Development documents and examples for argo-workflows
url: https://pypi.org/project/argo-workflows/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-argo-workflows-6.6.2-1.src.rpm
location_href: Packages/python-argo-workflows-help-6.6.2-1.noarch.rpm
checksum_type: sha256
description:
      Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes. For more information, please see https://argo-workflows.readthedocs.io/en/latest/  # noqa: E501


pkgId: 712e9ae1f980644b45fb570f576b51d0b792783a69809848cc4f3ff7a6377277
name: python-argon2-solver-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for argon2-solver
url: https://github.com/Klez2003/argon2-solver
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-argon2-solver-1.0.2-1.src.rpm
location_href: Packages/python-argon2-solver-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
      ```sh
      pip3 install .
      ```

      Run the script using:
      ```sh
      argon2-solver "memory_cost:time_cost:salt:difficulty"
      ```


pkgId: 0b0592a0f755ed8f58d263507b62fe5c349aaf933f6f9758487ac3c38a697d1d
name: python-argshell-help
arch: noarch
version: 1.6.5
epoch: 0
release: 1
summary: Development documents and examples for argshell
url: https://github.com/matt-manes/argshell
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-argshell-1.6.5-1.src.rpm
location_href: Packages/python-argshell-help-1.6.5-1.noarch.rpm
checksum_type: sha256
description:
  Rather than being limited to input strings, you can use `argparse` style parsers for shell commands.
  Create a function that instantiates an `ArgShellParser` instance, adds arguments, and then returns the `ArgShellParser` object.
  Then you can can decorate `do_*` functions using `with_parser()` to pass a `Namespace` object instead of a string.
  ![](assets/myshell_with_parser.svg)
  In terminal:
  ![](assets/add_help.svg)


pkgId: 9eb12ad4def29ae3c8777af5f3126519ebb1b6948b133d69e0b11ec2102b0726
name: python-argus-api-help
arch: noarch
version: 3.19.0
epoch: 0
release: 1
summary: Development documents and examples for argus-api
url: https://mnemonic.io
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-argus-api-3.19.0-1.src.rpm
location_href: Packages/python-argus-api-help-3.19.0-1.noarch.rpm
checksum_type: sha256
description:
  `argus-api` is the python API client library for [mnemonic](https://www.mnemonic.io/)'s Argus API.

  Documentation for this library can be found at: [argus-api documentation](https://argus-api.docs.mnemonic.no)



  In order to report issues or request features, please contact Mnemonic's development
  team: [opensource@mnemonic.no](mailto:opensource@mnemonic.no)


pkgId: 52fd54205b628262584bbccd5adae63edb95f814218b2a5807d15cb52aed262b
name: python-argus-server-help
arch: noarch
version: 1.30.0
epoch: 0
release: 1
summary: Development documents and examples for argus-server
url: https://github.com/Uninett/Argus
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-argus-server-1.30.0-1.src.rpm
location_href: Packages/python-argus-server-help-1.30.0-1.noarch.rpm
checksum_type: sha256
description:
  [![test badge](https://github.com/Uninett/Argus/actions/workflows/python.yml/badge.svg)](https://github.com/Uninett/Argus/actions)
  [![codecov badge](https://codecov.io/gh/Uninett/Argus/branch/master/graph/badge.svg)](https://codecov.io/gh/Uninett/Argus)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![docs badge](https://readthedocs.org/projects/argus-server/badge/?version=latest&style=flat)](http://argus-server.rtfd.io/en/latest/)

  Argus is a platform for aggregating incidents across network management systems, and
  sending notifications to users. Users create notification profiles that define which
  incidents they subscribe to. See [Argus docs](http://argus-server.rtfd.io/en/latest/) for more details.

  This repository hosts the backend built with Django. There is also a
  [REACT SPA frontend](https://github.com/Uninett/Argus-frontend).


  See also the the [Python client library](https://github.com/Uninett/pyargus).



  There are several ways to install Argus.





  * Python 3.8+
  * Django 4.2 or 5.0
  * pip



  * **Redis**
    is recommended if you are going to run the frontend.
    Redis backs the websockets, in order to push realtime updates to the frontend.
  * [Argus-frontend](https://github.com/Uninett/Argus-frontend/)
  * PostgreSQL
  * Docker and Docker Compose to run Argus in Docker



  Dataporten authentication is supported by Argus and can be used to log into
  Argus-frontend.
  Refer to the [Dataporten](https://argus-server.rtfd.io/en/latest/authentication.html#dataporten) section of the documentation to learn
  about Dataporten registration, and how to set it up with Argus.



  You need to have the frontend dependencies installed.

  Either of

  ```
  pip install argus-server[htmx]
  ```

  or

  ```
  pip install -r requirements/htmx.txt
  ```

  will do it.



  You can also install Argus with `pip` via PyPI. The package name is `argus-server`:
  ```console
  $ pip install argus-server
  ```

  If you are using the PyPI package in production, please note: The file
  `requirements.txt` contains the pinned versions of dependencies that the
  release was tested on. The file `constraints.txt` is for controlling versions
  of sub-dependencies so as to not poison the pyproject.toml.

  To update the dependency lock-files, use `tox`:

  ```console
  $ pip install "tox>=4"
  $ tox run -e upgrade-deps -- -U
  ```

  To upgrade a single dependency, replace the `-U` flag with `-P PACKAGENAME`.

  To install from the lock-file use pip:

  ```console
  $ pip install -c constraints.txt --upgrade -r requirements.txt
  ```

  Now change and adapt [Argus' settings](#settings-in-argus) according to your needs.

  Run the initial Argus setup, and make note of the admin password that is generated:

  ```console
  $ python manage.py initial_setup
  ******************************************************************************

    Created Argus superuser "admin" with password "2S0qJbjVEew0GunL".

     Please change the password via the admin interface.

  ******************************************************************************
  ```

  Then run the Argus API server:

  ```console
  $ python manage.py runserver
  ```



  Download the source code first.
  ```console
  $ git clone https://github.com/Uninett/Argus.git
  $ cd Argus
  ```

  Running Argus with Docker Compose is as simple as
  ```console
  $ docker compose up
  ```

  Run the initial Argus setup, and make note of the admin password that is generated:

  ```console
  $ docker compose exec api django-admin initial_setup
  ******************************************************************************

    Created Argus superuser "admin" with password "ns6bfoKquW12koIP".

     Please change the password via the admin interface.

  ******************************************************************************
  ```


  You will find Argus running at http://localhost:8000/.



  Site-specific settings can either be set using environment variables, using a
  `settings.py` file, or a combination of both.

  For more information on both methods and a list of the settings, consult the
  documentation section on
  [site-specific settings](http://argus-server.rtfd.io/en/latest/site-specific-settings.html).






  You can use Docker Compose to conveniently setup a complete dev environment for Argus,
  including PostgreSQL. Instructions
  [are provided above](#setup-argus-using-docker-compose).

  To do a manual install instead, follow these steps.

  Download the source code first.
  ```console
  $ git clone https://github.com/Uninett/Argus.git
  $ cd Argus
  ```

  We recommend using virtualenv or virtaulenvwrapper to create
  a place to stash Argus' dependencies.

  Create and activate a Python virtual environment.
  ```console
  $ python -m venv venv
  $ source venv/bin/activate
  ```

  Install Argus' requirements into the virtual env.
  ```console
  $ pip install -r requirements-django42.txt
  $ pip install -r requirements/dev.txt
  ```



  Copy the `cmd.sh-template` to `cmd.sh` and make it executable
  ```console
  $ cp cmd.sh-template cmd.sh
  $ chmod u+x cmd.sh
  ```
  Now set the environment variables in the file using an editor.

  Required settings in `cmd.sh` are

  - `DATABASE_URL`,
  - `DJANGO_SETTINGS_MODULE` and
  - `SECRET_KEY`.

  The `DATAPORTEN` variables are optional. Refer to the dataporten section of
  [setting site-specific settings](http://argus-server.rtfd.io/en/latest/site-specific-settings.html) for details.

  `DJANGO_SETTINGS_MODULE` can be set to `argus.site.settings.dev`.

  If you need more complex settings than environment variables and ``cmd.sh`` can provide,
  we recommend having a `localsettings.py` in the same directory as `manage.py` with any
  overrides.

  Refer to the [development notes](http://argus-server.rtfd.io/en/latest/development.html) for further details and
  useful hints on managing Argus in development mode.



  See https://argus-server.erfd.io/en/latest/reference/react-frontend.html



  See http://argus-server.rtfd.io/en/latest/reference/htmx-frontend.html



  Afterwards, run the initial Argus setup and start the server.
  ```console
  $ python manage.py initial_setup
  $ python manage.py runserver
  ```

  You will find Argus running at http://localhost:8000/.



  Argus uses ruff as a source code formatter. Ruff will automatically install
  with the [dev requirements](requirements/dev.txt).

  A pre-commit hook will format new code automatically before committing.
  To enable this pre-commit hook, run

  ```console
  $ pre-commit install
  ```




  Given that Argus is installed and configured as described above,
  this command is the most basic option to run the tests.
  ```console
  $ python manage.py test
  ```

  If you have installed `tox`, the following command will
  test Argus code against several Django versions, several Python versions, and
  automatically compute code coverage.
  ```console
  $ tox
  ```
  An [HTML coverage report](htmlcov/index.html) will be generated.
  Refer to the [tox.ini](tox.ini) file for further options.



  To be able to automatically produce the changelog for a release one file for each
  pull request (also called news fragment) needs to be added to the folder
  `changelog.d/`.

  The name of the file consists of three parts separated by a period:
  1. The identifier: either the issue number (in case the pull request fixes that issue)
  or the pull request number. If we don't want to add a link to the resulting changelog
  entry then a `+` followed by a unique short description.
  2. The type of the change: we use `security`, `removed`, `deprecated`, `added`,
  `changed` and `fixed`.
  3. The file suffix, e.g. `.md`, towncrier does not care which suffix a fragment has.

  So an example for a file name related to an issue/pull request would be `214.added.md`
  or for a file without corresponding issue `+fixed-pagination-bug.fixed.md`.

  This file can either be created manually with a file name as specified above and the
  changelog text as content or one can use towncrier to create such a file as following:

  ```console
  $ towncrier create -c "Changelog content" 214.added.md
  ```

  When opening a pull request there will be a check to make sure that a news fragment is
  added and it will fail if it is missing.


  To add all content from the `changelog.d/` folder to the changelog file simply run
  ```console
  $ towncrier build --version {version}
  ```
  This will also delete all files in `changelog.d/`.

  To preview what the addition to the changelog file would look like add the flag
  `--draft`. This will not delete any files or change `CHANGELOG.md`. It will only output
  the preview in the terminal.

  A few other helpful flags:
  - `date DATE` - set the date of the release, default is today
  - `keep` - do not delete the files in `changelog.d/`

  More information about [towncrier](https://towncrier.readthedocs.io).


pkgId: 5657fa5214f36442d43587312e8f9c25edc9a13ca67b4b626698bc58b44dd41c
name: python-ariadne-help
arch: noarch
version: 0.24.0
epoch: 0
release: 1
summary: Development documents and examples for ariadne
url: https://ariadnegraphql.org/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ariadne-0.24.0-1.src.rpm
location_href: Packages/python-ariadne-help-0.24.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Ariadne](https://ariadnegraphql.org/img/logo-horizontal-sm.png)](https://ariadnegraphql.org)

  [![Documentation](https://img.shields.io/badge/docs-ariadnegraphql.org-brightgreen.svg)](https://ariadnegraphql.org)
  [![Codecov](https://codecov.io/gh/mirumee/ariadne/branch/master/graph/badge.svg)](https://codecov.io/gh/mirumee/ariadne)

  - - - - -



  Ariadne is a Python library for implementing [GraphQL](http://graphql.github.io/) servers.

  - **Schema-first:** Ariadne enables Python developers to use schema-first approach to the API implementation. This is the leading approach used by the GraphQL community and supported by dozens of frontend and backend developer tools, examples, and learning resources. Ariadne makes all of this immediately available to you and other members of your team.
  - **Simple:** Ariadne offers small, consistent and easy to memorize API that lets developers focus on business problems, not the boilerplate.
  - **Open:** Ariadne was designed to be modular and open for customization. If you are missing or unhappy with something, extend or easily swap with your own.

  Documentation is available [here](https://ariadnegraphql.org).




  - Simple, quick to learn and easy to memorize API.
  - Compatibility with GraphQL.js version 15.5.1.
  - Queries, mutations and input types.
  - Asynchronous resolvers and query execution.
  - Subscriptions.
  - Custom scalars, enums and schema directives.
  - Unions and interfaces.
  - File uploads.
  - Defining schema using SDL strings.
  - Loading schema from `.graphql`, `.gql`, and `.graphqls` files.
  - WSGI middleware for implementing GraphQL in existing sites.
  - Apollo Tracing and [OpenTracing](http://opentracing.io) extensions for API monitoring.
  - Opt-in automatic resolvers mapping between `camelCase` and `snake_case`, and a `@convert_kwargs_to_snake_case` function decorator for converting `camelCase` kwargs to `snake_case`.
  - Built-in simple synchronous dev server for quick GraphQL experimentation and GraphQL Playground.
  - Support for [Apollo GraphQL extension for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=apollographql.vscode-apollo).
  - GraphQL syntax validation via `gql()` helper function. Also provides colorization if Apollo GraphQL extension is installed.
  - No global state or object registry, support for multiple GraphQL APIs in same codebase with explicit type reuse.
  - Support for `Apollo Federation`.




  Ariadne can be installed with pip:

  ```console
  pip install ariadne
  ```

  Ariadne requires Python 3.7 or higher.




  The following example creates an API defining `Person` type and single query field `people` returning a list of two persons. It also starts a local dev server with [GraphQL Playground](https://github.com/prisma/graphql-playground) available on the `http://127.0.0.1:8000` address.

  Start by installing [uvicorn](http://www.uvicorn.org/), an ASGI server we will use to serve the API:

  ```console
  pip install uvicorn
  ```

  Then create an `example.py` file for your example application:

  ```python
  from ariadne import ObjectType, QueryType, gql, make_executable_schema
  from ariadne.asgi import GraphQL



  type_defs = gql("""
      type Query {
          people: [Person!]!
      }

      type Person {
          firstName: String
          lastName: String
          age: Int
          fullName: String
      }
  """)


  query = QueryType()


  @query.field("people")
  def resolve_people(*_):
      return [
          {"firstName": "John", "lastName": "Doe", "age": 21},
          {"firstName": "Bob", "lastName": "Boberson", "age": 24},
      ]



  person = ObjectType("Person")

  @person.field("fullName")
  def resolve_person_fullname(person, *_):
      return "%s %s" % (person["firstName"], person["lastName"])


  schema = make_executable_schema(type_defs, query, person)


  app = GraphQL(schema, debug=True)
  ```

  Finally run the server:

  ```console
  uvicorn example:app
  ```

  For more guides and examples, please see the [documentation](https://ariadnegraphql.org).




  We are welcoming contributions to Ariadne! If you've found a bug or issue, feel free to use [GitHub issues](https://github.com/mirumee/ariadne/issues). If you have any questions or feedback, don't hesitate to catch us on [GitHub discussions](https://github.com/mirumee/ariadne/discussions/).

  For guidance and instructions, please see [CONTRIBUTING.md](CONTRIBUTING.md).

  Website and the docs have their own GitHub repository: [mirumee/ariadne-website](https://github.com/mirumee/ariadne-website)

  Also make sure you follow [@AriadneGraphQL](https://twitter.com/AriadneGraphQL) on Twitter for latest updates, news and random musings!

  **Crafted with ❤️ by [Mirumee Software](http://mirumee.com)**
  hello@mirumee.com

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


pkgId: c6a538adb1d61100f27e0316b51a305c801ee7a3907d7e1bd55b686c2a3c7ee6
name: python-arize-help
arch: noarch
version: 7.29.4
epoch: 0
release: 1
summary: Development documents and examples for arize
url: https://arize.com
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arize-7.29.4-1.src.rpm
location_href: Packages/python-arize-help-7.29.4-1.noarch.rpm
checksum_type: sha256
description:
  A helper package to interact with Arize AI APIs.
  Arize is an end-to-end ML & LLM observability and monitoring platform. The platform is designed to help AI & ML engineers and data science practitioners surface and fix issues with ML models in production faster with:
  - LLM tracing
  - Automated ML monitoring and model monitoring
  - Workflows to troubleshoot model performance
  - Real-time visualizations for model performance monitoring, data quality monitoring, and drift monitoring
  - Model prediction cohort analysis
  - Pre-deployment model validation


pkgId: 29c756f9a25a1bfa8fa61e5d60ca76b647d5d7d713be90c7ea10d28f19b5e667
name: python-arize-otel-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for arize-otel
url: https://pypi.org/project/arize-otel/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arize-otel-0.7.1-1.src.rpm
location_href: Packages/python-arize-otel-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  - [Overview](#overview)
  - [Installation](#installation)
  - [Quickstart](#quickstart)
    - [Send traces to Arize](#send-traces-to-arize)
    - [Send traces to Custom Endpoint](#send-traces-to-custom-endpoint)
    - [Specify exporter type](#specify-exporter-type)
    - [Turn off batch processing of spans](#turn-off-batch-processing-of-spans)
    - [Debug](#debug)
  - [Using Environment Variables](#using-environment-variables)
  - [Using OTel Primitives](#using-otel-primitives)
    - [Specifying the `endpoint` directly](#specifying-the-endpoint-directly)
    - [Configuring resources](#configuring-resources)
    - [Using a BatchSpanProcessor](#using-a-batchspanprocessor)
    - [Specifying a custom GRPC endpoint](#specifying-a-custom-grpc-endpoint)
  - [Questions?](#questions)
  - [Copyright, Patent, and License](#copyright-patent-and-license)

  The `arize-otel` package provides a lightweight wrapper around OpenTelemetry primitives with Arize-aware defaults and options. It is meant to be a very lightweight convenience package to help set up OpenTelemetry for tracing LLM applications and send the traces to [Arize](https://arize.com/).

  Install `arize-otel` using `pip`
  ```bash
  pip install arize-otel
  ```

  The `arize.otel` module provides a high-level `register` function to configure OpenTelemetry tracing by returning a `TracerProvider`. The register function can also configure headers and whether or not to process spans one by one or by batch.
  The following examples showcase how to use `register` to setup Opentelemetry in order to send traces to a collector. However, this is **NOT** the same as [instrumenting](https://docs.arize.com/phoenix/tracing/concepts-tracing/how-does-tracing-work) your application. For instance, you can use any of our [OpenInference AutoInstrumentators](https://github.com/Arize-ai/openinference). Assuming we use the OpenAI AutoInstrumentation, we need to run `instrument()` _after_ using `register`:
  ```python
  from arize.otel import register

  tracer_provider = register(
      
  )

  from openinference.instrumentation.openai import OpenAIInstrumentor
  OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)
  ```
  The above code snippet will yield a fully setup and instrumented application. It is worth noting that this is completely **optional**. The usage of this package is for convenience only, you can set up OpenTelemetry and send traces to Arize without installing this or any other package from Arize.
  In the following sections we have examples on how to use the `register` function:

  To send traces to Arize you need to authenticate via the Space ID and API Key. You can find them in the Space Settings page in the Arize platform. In addition, you'll need to specify the project name, a unique name to identify your project in the Arize platform.
  ```python
  from arize.otel import register
  register(
      space_id = "your-arize-space-id",
      api_key = "your-arize-api-key",
      project_name = "your-model-id",
  )
  ```
  If you are located in the European Union, you'll need to specify the corresponding `Endpoint` (the default endpoint is `Endpoint.ARIZE`):
  ```python
  from arize.otel import register, Endpoint
  register(
      endpoint=Endpoint.ARIZE_EUROPE,
      space_id = "your-arize-space-id",
      api_key = "your-arize-api-key",
      project_name = "your-model-id",
  )
  ```
  If you would like to configure your tracing using environment variables instead of passing arguments, read [Using Environment Variables](#using-environment-variables).

  Sending traces to a collector on a custom endpoint is simple, you just need to provide the endpoint as a string. In addition, it is worth noting that the default is to use a `GRPCSpanExporter`. If you'd like to use a `HTTPSpanExporter` instead, specify the transport as shown below:
  ```python
  from arize.otel import register
  register(
      endpoint = "https://my-custom-endpoint"
      
  )
  ```

  If you're using endpoints from the `Endpoint` enum, you do not need to do this, since we know what exporter to use. However, if you're using a custom endpoint, it is worth noting that the default is to use a `GRPCSpanExporter`. If you'd like to use a `HTTPSpanExporter` instead, specify the transport as shown below:
  ```python
  from arize.otel import register, Transport
  register(
      endpoint = "https://my-custom-endpoint"
      transport = Transport.HTTP,
      
  )
  ```

  We default to using [BatchSpanProcessor](https://opentelemetry.io/docs/languages/js/instrumentation/#picking-the-right-span-processor) from OpenTelemetry because it is non-blocking in case telemetry goes down. In contrast, "SimpleSpanProcessor processes spans as they are created." This can be helpful in development. You can use `SimpleSpanProcessor` with the option `use_batch_processor=False`.
  ```python
  from arize.otel import register
  register(
      
      batch=False
  )
  ```

  As you're setting up your tracing, it is helpful to print to console the spans created. You can achieve this by setting `log_to_console=True`.
  ```python
  from arize.otel import register
  register(
      
      log_to_console=True
  )
  ```

  The register function will read from environment variables if the arguments are not passed:
  ```python
  from arize.otel import register
  register(
      space_id = ... # Will be read from ARIZE_SPACE_ID env var
      api_key = ... # Will be read from ARIZE_API_KEY env var
      project_name = ... # Will be read from ARIZE_PROJECT_NAME env var
      endpoint = ... # Will be read from ARIZE_COLLECTOR_ENDPOINT env var, defaults to Endpoint.Arize
  )
  ```
  In the event of conflict, if an environment variable is set but a different argument is passed, the argument passed will take precedence and the environment variable will be ignored.

  For more granular tracing configuration, these wrappers can be used as drop-in replacements for
  OTel primitives:
  ```python
  from opentelemetry import trace as trace_api
  from arize.otel import HTTPSpanExporter, TracerProvider, SimpleSpanProcessor
  tracer_provider = TracerProvider()
  span_exporter = HTTPSpanExporter(endpoint=...)
  span_processor = SimpleSpanProcessor(span_exporter=span_exporter)
  tracer_provider.add_span_processor(span_processor)
  trace_api.set_tracer_provider(tracer_provider)
  ```
  Wrappers have Arize-aware defaults to greatly simplify the OTel configuration process. A special
  `endpoint` keyword argument can be passed to either a `TracerProvider`, `SimpleSpanProcessor` or
  `BatchSpanProcessor` in order to automatically infer which `SpanExporter` to use to simplify setup.

  ```python
  from opentelemetry import trace as trace_api
  from arize.otel import TracerProvider
  tracer_provider = TracerProvider(endpoint="https://your-desired-endpoint.com")
  trace_api.set_tracer_provider(tracer_provider)
  ```

  ```python

  from opentelemetry import trace as trace_api
  from arize.otel import Resource, PROJECT_NAME, TracerProvider
  tracer_provider = TracerProvider(resource=Resource({PROJECT_NAME: "my-project"}))
  trace_api.set_tracer_provider(tracer_provider)
  ```

  ```python

  from opentelemetry import trace as trace_api
  from arize.otel import TracerProvider, BatchSpanProcessor
  tracer_provider = TracerProvider()
  batch_processor = BatchSpanProcessor()
  tracer_provider.add_span_processor(batch_processor)
  ```

  ```python
  from opentelemetry import trace as trace_api
  from arize.otel import TracerProvider, BatchSpanProcessor, GRPCSpanExporter
  tracer_provider = TracerProvider()
  batch_processor = BatchSpanProcessor(
      span_exporter=GRPCSpanExporter(endpoint="https://your-desired-endpoint.com")
  )
  tracer_provider.add_span_processor(batch_processor)
  ```

  Find us in our [Slack Community](https://join.slack.com/t/arize-ai/shared_invite/zt-1px8dcmlf-fmThhDFD_V_48oU7ALan4Q) or email support@arize.com

  Copyright 2024 Arize AI, Inc. All Rights Reserved.
  This software is licensed under the terms of the 3-Clause BSD License. See [LICENSE](https://github.com/Arize-ai/arize-otel-python/blob/main/LICENSE).


pkgId: 5690f4f09eeba3209698e0f501d979a596b733ca41fad30c42edf5ca328746bc
name: python-arize-phoenix-help
arch: noarch
version: 7.2.0
epoch: 0
release: 1
summary: Development documents and examples for arize-phoenix
url: https://pypi.org/project/arize-phoenix/
rpm_license: Elastic-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arize-phoenix-7.2.0-1.src.rpm
location_href: Packages/python-arize-phoenix-help-7.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a target="_blank" href="https://phoenix.arize.com" style="background:none">
          <img alt="phoenix banner" src="https://github.com/Arize-ai/phoenix-assets/blob/main/images/socal/github-large-banner-phoenix.jpg?raw=true" width="auto" height="auto"></img>
      </a>
      <br/>
      <br/>
      <a href="https://docs.arize.com/phoenix/">
          <img src="https://img.shields.io/static/v1?message=Docs&logo=data:image/png;base64,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&labelColor=grey&color=blue&logoColor=white&label=%20"/>
      </a>
      <a target="_blank" href="https://arize-ai.slack.com/join/shared_invite/zt-11t1vbu4x-xkBIHmOREQnYnYDH1GDfCg?__hstc=259489365.a667dfafcfa0169c8aee4178d115dc81.1733501603539.1733501603539.1733501603539.1&__hssc=259489365.1.1733501603539&__hsfp=3822854628&submissionGuid=381a0676-8f38-437b-96f2-fc10875658df#/shared-invite/email">
          <img src="https://img.shields.io/static/v1?message=Community&logo=slack&labelColor=grey&color=blue&logoColor=white&label=%20"/>
      </a>
      <a target="_blank" href="https://twitter.com/ArizePhoenix">
          <img src="https://img.shields.io/badge/-ArizePhoenix-blue.svg?color=blue&labelColor=gray&logo=x">
      </a>
      <a target="_blank" href="https://pypi.org/project/arize-phoenix/">
          <img src="https://img.shields.io/pypi/v/arize-phoenix?color=blue">
      </a>
      <a target="_blank" href="https://anaconda.org/conda-forge/arize-phoenix">
          <img src="https://img.shields.io/conda/vn/conda-forge/arize-phoenix.svg?color=blue">
      </a>
      <a target="_blank" href="https://pypi.org/project/arize-phoenix/">
          <img src="https://img.shields.io/pypi/pyversions/arize-phoenix">
      </a>
      <a target="_blank" href="https://hub.docker.com/r/arizephoenix/phoenix/tags">
          <img src="https://img.shields.io/docker/v/arizephoenix/phoenix?sort=semver&logo=docker&label=image&color=blue">
      </a>
  </p>

  Phoenix is an open-source AI observability platform designed for experimentation, evaluation, and troubleshooting. It provides:

  - [**_Tracing_**](https://docs.arize.com/phoenix/tracing/llm-traces) - Trace your LLM application's runtime using OpenTelemetry-based instrumentation.
  - [**_Evaluation_**](https://docs.arize.com/phoenix/evaluation/llm-evals) - Leverage LLMs to benchmark your application's performance using response and retrieval evals.
  - [**_Datasets_**](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets) - Create versioned datasets of examples for experimentation, evaluation, and fine-tuning.
  - [**_Experiments_**](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets#experiments) - Track and evaluate changes to prompts, LLMs, and retrieval.

  Phoenix is vendor and language agnostic with out-of-the-box support for popular frameworks (🦙[LlamaIndex](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex), 🦜⛓[LangChain](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain), [Haystack](https://docs.arize.com/phoenix/tracing/integrations-tracing/haystack), 🧩[DSPy](https://docs.arize.com/phoenix/tracing/integrations-tracing/dspy)) and LLM providers ([OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai), [Bedrock](https://docs.arize.com/phoenix/tracing/integrations-tracing/bedrock), [MistralAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/mistralai), [VertexAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/vertexai), [LiteLLM](https://docs.arize.com/phoenix/tracing/integrations-tracing/litellm), and more). For details on auto-instrumentation, check out the [OpenInference](https://github.com/Arize-ai/openinference) project.

  Phoenix runs practically anywhere, including your Jupyter notebook, local machine, containerized deployment, or in the cloud.

  <img alt="phoenix_overview.gif" width="100%" src="https://github.com/Arize-ai/phoenix-assets/blob/main/gifs/phoenix_overview.gif?raw=true">



  Install Phoenix via `pip` or `conda`

  ```shell
  pip install arize-phoenix
  ```

  Phoenix container images are available via [Docker Hub](https://hub.docker.com/r/arizephoenix/phoenix) and can be deployed using Docker or Kubernetes.



  | Key Features                                                                                                     | Availability   |
  | ---------------------------------------------------------------------------------------------------------------- | -------------- |
  | [Tracing](https://docs.arize.com/phoenix/tracing/concepts-tracing/what-are-traces)                               | ✅             |
  | [Evaluation](https://docs.arize.com/phoenix/evaluation/llm-evals)                                                | ✅             |
  | [Retrieval (RAG) Analysis](https://docs.arize.com/phoenix/tracing/use-cases-tracing/rag-evaluation)              | ✅             |
  | [Datasets](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets)                            | ✅             |
  | [Fine-Tuning Export](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-datasets/exporting-datasets) | ✅             |
  | [Annotations](https://docs.arize.com/phoenix/tracing/concepts-tracing/how-to-annotate-traces)                    | ✅             |
  | [Human Feedback](https://docs.arize.com/phoenix/tracing/how-to-tracing/capture-feedback)                         | ✅             |
  | [Experiments](https://docs.arize.com/phoenix/datasets-and-experiments/how-to-experiments/run-experiments)        | ✅             |
  | [Embeddings Analysis](https://docs.arize.com/phoenix/inferences/phoenix-inferences)                              | ✅             |
  | [Data Export](https://docs.arize.com/phoenix/tracing/how-to-tracing/extract-data-from-spans)                     | ✅             |
  | REST API                                                                                                         | ✅             |
  | GraphQL API                                                                                                      | ✅             |
  | Data Retention                                                                                                   | Customizable   |
  | [Authentication](https://docs.arize.com/phoenix/deployment/authentication)                                       | ✅             |
  | [Social Login](https://docs.arize.com/phoenix/deployment/authentication#configuring-oauth2-identity-providers)   | ✅             |
  | [RBAC](https://docs.arize.com/phoenix/deployment/authentication#permissions)                                     | ✅             |
  | Projects                                                                                                         | ✅             |
  | [Self-Hosting](https://docs.arize.com/phoenix/deployment)                                                        | ✅             |
  | Jupyter Notebooks                                                                                                | ✅             |
  | [Prompt Playground](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts)                          | ✅             |
  | [Sessions](https://docs.arize.com/phoenix/tracing/how-to-tracing/setup-sessions)                                 | ✅             |
  | Prompt Management                                                                                                | Coming soon ⏱️ |



  Phoenix is built on top of OpenTelemetry and is vendor, language, and framework agnostic.

  **Python**
  | Integration | Package | Version Badge |
  |------------------|-----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
  | [OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai) | `openinference-instrumentation-openai` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-openai.svg)](https://pypi.python.org/pypi/openinference-instrumentation-openai) |
  | [LlamaIndex](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex) | `openinference-instrumentation-llama-index` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-llama-index.svg)](https://pypi.python.org/pypi/openinference-instrumentation-llama-index) |
  | [DSPy](https://docs.arize.com/phoenix/tracing/integrations-tracing/dspy) | `openinference-instrumentation-dspy` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-dspy.svg)](https://pypi.python.org/pypi/openinference-instrumentation-dspy) |
  | [AWS Bedrock](https://docs.arize.com/phoenix/tracing/integrations-tracing/bedrock) | `openinference-instrumentation-bedrock` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-bedrock.svg)](https://pypi.python.org/pypi/openinference-instrumentation-bedrock) |
  | [LangChain](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain) | `openinference-instrumentation-langchain` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-langchain.svg)](https://pypi.python.org/pypi/openinference-instrumentation-langchain) |
  | [MistralAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/mistralai) | `openinference-instrumentation-mistralai` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-mistralai.svg)](https://pypi.python.org/pypi/openinference-instrumentation-mistralai) |
  | [Guardrails](https://docs.arize.com/phoenix/tracing/integrations-tracing/guardrails) | `openinference-instrumentation-guardrails` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-guardrails.svg)](https://pypi.python.org/pypi/openinference-instrumentation-guardrails) |
  | [VertexAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/vertexai) | `openinference-instrumentation-vertexai` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-vertexai.svg)](https://pypi.python.org/pypi/openinference-instrumentation-vertexai) |
  | [CrewAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/crewai) | `openinference-instrumentation-crewai` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-crewai.svg)](https://pypi.python.org/pypi/openinference-instrumentation-crewai) |
  | [Haystack](https://docs.arize.com/phoenix/tracing/integrations-tracing/haystack) | `openinference-instrumentation-haystack` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-haystack.svg)](https://pypi.python.org/pypi/openinference-instrumentation-haystack) |
  | [LiteLLM](https://docs.arize.com/phoenix/tracing/integrations-tracing/litellm) | `openinference-instrumentation-litellm` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-litellm.svg)](https://pypi.python.org/pypi/openinference-instrumentation-litellm) |
  | [Groq](https://docs.arize.com/phoenix/tracing/integrations-tracing/groq) | `openinference-instrumentation-groq` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-groq.svg)](https://pypi.python.org/pypi/openinference-instrumentation-groq) |
  | [Instructor](https://docs.arize.com/phoenix/tracing/integrations-tracing/instructor) | `openinference-instrumentation-instructor` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-instructor.svg)](https://pypi.python.org/pypi/openinference-instrumentation-instructor) |
  | [Anthropic](https://docs.arize.com/phoenix/tracing/integrations-tracing/anthropic) | `openinference-instrumentation-anthropic` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-anthropic.svg)](https://pypi.python.org/pypi/openinference-instrumentation-anthropic) |



  | Integration                                                                                | Package                                            | Version Badge                                                                                                                                                                       |
  | ------------------------------------------------------------------------------------------ | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | [OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai-node-sdk)      | `@arizeai/openinference-instrumentation-openai`    | [![NPM Version](https://img.shields.io/npm/v/@arizeai/openinference-instrumentation-openai.svg)](https://www.npmjs.com/package/@arizeai/openinference-instrumentation-openai)       |
  | [LangChain.js](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain.js)   | `@arizeai/openinference-instrumentation-langchain` | [![NPM Version](https://img.shields.io/npm/v/@arizeai/openinference-instrumentation-langchain.svg)](https://www.npmjs.com/package/@arizeai/openinference-instrumentation-langchain) |
  | [Vercel AI SDK](https://docs.arize.com/phoenix/tracing/integrations-tracing/vercel-ai-sdk) | `@arizeai/openinference-vercel`                    | [![NPM Version](https://img.shields.io/npm/v/@arizeai/openinference-vercel)](https://www.npmjs.com/package/@arizeai/openinference-vercel)                                           |

  For details about tracing integrations and example applications, see the [OpenInference](https://github.com/Arize-ai/openinference) project.



  Join our community to connect with thousands of AI builders.

  - 🌍 Join our [Slack community](https://arize-ai.slack.com/join/shared_invite/zt-11t1vbu4x-xkBIHmOREQnYnYDH1GDfCg?__hstc=259489365.a667dfafcfa0169c8aee4178d115dc81.1733501603539.1733501603539.1733501603539.1&__hssc=259489365.1.1733501603539&__hsfp=3822854628&submissionGuid=381a0676-8f38-437b-96f2-fc10875658df#/shared-invite/email).
  - 📚 Read our [documentation](https://docs.arize.com/phoenix).
  - 💡 Ask questions and provide feedback in the _#phoenix-support_ channel.
  - 🌟 Leave a star on our [GitHub](https://github.com/Arize-ai/phoenix).
  - 🐞 Report bugs with [GitHub Issues](https://github.com/Arize-ai/phoenix/issues).
  - 𝕏 Follow us on [𝕏](https://twitter.com/ArizePhoenix).
  - 🗺️ Check out our [roadmap](https://github.com/orgs/Arize-ai/projects/45) to see where we're heading next.



  See the [migration guide](./MIGRATION.md) for a list of breaking changes.



  Copyright 2024 Arize AI, Inc. All Rights Reserved.

  Portions of this code are patent protected by one or more U.S. Patents. See [IP_NOTICE](https://github.com/Arize-ai/phoenix/blob/main/IP_NOTICE).

  This software is licensed under the terms of the Elastic License 2.0 (ELv2). See [LICENSE](https://github.com/Arize-ai/phoenix/blob/main/LICENSE).


pkgId: 7971db5d744e9efbac4218956ff12de2d149cde7f12208d9392a3b862c20ad81
name: python-arm-pyart-debuginfo
arch: aarch64
version: 1.19.4
epoch: 0
release: 1
summary: Debug information for package python-arm-pyart
url: https://github.com/ARM-DOE/pyart
rpm_license: BSD
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-arm-pyart-1.19.4-1.src.rpm
location_href: Packages/python-arm-pyart-debuginfo-1.19.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-arm-pyart.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 590fcc2304b93df4768d92474e9480cd323cf6727993635eb759919805907262
name: python-arm-pyart-debugsource
arch: aarch64
version: 1.19.4
epoch: 0
release: 1
summary: Debug sources for package python-arm-pyart
url: https://github.com/ARM-DOE/pyart
rpm_license: BSD
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-arm-pyart-1.19.4-1.src.rpm
location_href: Packages/python-arm-pyart-debugsource-1.19.4-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-arm-pyart.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 39a102d36d666f54a81409d83fe9e1c8b5b35a9e218ae6d372881e02c84b627c
name: python-arm-pyart-help
arch: aarch64
version: 1.19.4
epoch: 0
release: 1
summary: Development documents and examples for arm-pyart
url: https://github.com/ARM-DOE/pyart
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arm-pyart-1.19.4-1.src.rpm
location_href: Packages/python-arm-pyart-help-1.19.4-1.aarch64.rpm
checksum_type: sha256
description:
  a growing collection of weather radar algorithms and utilities build on top of
  the Scientific Python stack and distributed under the 3-Clause BSD license.
  Py-ART is used by the Atmospheric Radiation Measurement (ARM) Climate Research
  Facility for working with data from a number of precipitation and cloud radars,
  but has been designed so that it can be used by others in the radar and
  atmospheric communities to examine, processes, and analyse data from many types
  of weather radars.


pkgId: e425f043f5548b372f1c6c40c3bfdd4da59be0536f7dd897731adac878bb5aad
name: python-artifactory-cleanup-help
arch: noarch
version: 1.0.13
epoch: 0
release: 1
summary: Development documents and examples for artifactory-cleanup
url: https://github.com/devopshq/artifactory-cleanup
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-artifactory-cleanup-1.0.13-1.src.rpm
location_href: Packages/python-artifactory-cleanup-help-1.0.13-1.noarch.rpm
checksum_type: sha256
description:
  `artifactory-cleanup` is an extended and flexible cleanup tool for JFrog Artifactory.

  The tool has simple YAML-defined cleanup configuration and can be extended with your own rules on Python.
  Everything must be as a code, even cleanup policies!



  <!-- toc -->

  - [Artifactory cleanup](#artifactory-cleanup)
  - [Tables of Contents](#tables-of-contents)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Notes](#notes)
    - [Commands](#commands)
  - [Rules](#rules)
    - [Common](#common)
    - [Delete](#delete)
    - [Keep](#keep)
    - [Docker](#docker)
    - [Filters](#filters)
    - [Create your own rule](#create-your-own-rule)
  - [How to](#how-to)
    - [How to connect self-signed certificates for docker?](#how-to-connect-self-signed-certificates-for-docker)
    - [How to clean up Conan repository?](#how-to-clean-up-conan-repository)
    - [How to keep latest N docker images?](#how-to-keep-latest-n-docker-images)
  - [Release](#release)

  <!-- tocstop -->



  As simple as one command!

  ```bash

  docker pull devopshq/artifactory-cleanup
  docker run --rm devopshq/artifactory-cleanup artifactory-cleanup --help


  python3 -mpip install artifactory-cleanup
  artifactory-cleanup --help
  ```



  Suppose you want to remove **all artifacts older than N days** from **reponame** repository.
  You should take the following steps:

  1. Install `artifactory-cleanup` (see above)
  2. Create a configuration file `artifactory-cleanup.yaml`. variables.

  ```yaml

  artifactory-cleanup:
    server: https://repo.example.com/artifactory
    
    user: $ARTIFACTORY_USERNAME
    password: $ARTIFACTORY_PASSWORD

    policies:
      - name: Remove all files from repo-name-here older than 7 days
        rules:
          - rule: Repo
            name: "reponame"
          - rule: DeleteOlderThan
            days: 7
  ```

  3. Run the command **TO SHOW** (not remove) artifacts that will be deleted. By default `artifactory-cleanup` uses "dry
     mode".

  ```bash

  export ARTIFACTORY_USERNAME=usernamehere
  export ARTIFACTORY_PASSWORD=password


  docker run --rm -v "$(pwd)":/app -e ARTIFACTORY_USERNAME -e ARTIFACTORY_PASSWORD devopshq/artifactory-cleanup artifactory-cleanup


  artifactory-cleanup
  ```

  4. Verify that right artifacts will be removed and add `--destroy` flag **TO REMOVE** artifacts:

  ```bash

  docker run --rm -v "$(pwd)":/app -e ARTIFACTORY_USERNAME -e ARTIFACTORY_PASSWORD devopshq/artifactory-cleanup artifactory-cleanup --destroy


  artifactory-cleanup --destroy
  ```

  Looking for more examples? Check [examples](./examples) folder!



  - **Always** specify version of `artifactory-cleanup` when using it in the production. `1.0.0` is just an example, find the latest version in pypi: https://pypi.org/project/artifactory-cleanup/

  ```bash

  docker pull devopshq/artifactory-cleanup:1.0.0
  docker run --rm devopshq/artifactory-cleanup:1.0.0 artifactory-cleanup --version


  python3 -mpip install artifactory-cleanup==1.0.0
  artifactory-cleanup --help
  ```

  - Use CI servers or cron-like utilities to run `artifactory-cleanup` every day (or every hour). TeamCity and GitHub have
    built-in support and show additional logs format
  - Do not save credentials in the configuration file, use environment variables.
  - Use `--ignore-not-found` flag to ignore errors when the repository is not found. It's useful when you have a
    configuration for multiple repositories and some of them are not found.
  - Use `--worker-count=<WORKER_NUM>` to increase the number of workers. By default, it's 1. It's useful when you have a lot of
    artifacts and you want to speed up the process.



  ```bash


  artifactory-cleanup


  artifactory-cleanup --policy-name policytestname



  artifactory-cleanup --destroy


  export ARTIFACTORY_CLEANUP_DESTROY=True
  artifactory-cleanup


  artifactory-cleanup --config artifactory-cleanup.yaml


  export ARTIFACTORY_CLEANUP_CONFIG_FILE=artifactory-cleanup.yaml
  artifactory-cleanup --config artifactory-cleanup.yaml


  artifactory-cleanup --days-in-future=10


  artifactory-cleanup --load-rules=myrule.py
  docker run -v "$(pwd)":/app devopshq/artifactory-cleanup artifactory-cleanup --load-rules=myrule.py


  artifactory-cleanup --output=myfile.txt


  artifactory-cleanup --output=myfile.txt --output-format=json


  artifactory-cleanup --output=myfile.json --output-format json --output-artifacts
  ```





  - `Repo` - Apply the rule to one repository. If no name is specified, it is taken from the rule name (in `CleanupPolicy`
    definition)

  ```yaml
  - rule: Repo
    name: reponame
  ```

  ```yaml


  policies:
    - name: reponame
      rules:
        - rule: Repo
  ```

  - `RepoList` - Apply the policy to list of repositories.

  ```yaml
  - rule: RepoList
    repos:
      - repo1
      - repo2
      - repo3
  ```

  - `RepoByMask` - Apply rule to repositories matching by mask

  ```yaml
  - rule: RepoByMask
    mask: "*.banned"
  ```

  - `PropertyEq`- Delete repository artifacts only with a specific property value (property_key is the name of the
    parameter, property_value is the value)

  ```yaml
  - rule: PropertyEq
    property_key: key-name
    property_value: 1
  ```

  - `PropertyNeq`- Delete repository artifacts only if the value != specified. If there is no value, delete it anyway.
    Allows you to specify the deletion flag `do_not_delete = 1`

  ```yaml
  - rule: PropertyNeq
    property_key: key-name
    property_value: 1
  ```



  - `DeleteOlderThan` - deletes artifacts that are older than N days

  ```yaml
  - rule: DeleteOlderThan
    days: 1
  ```

  - `DeleteWithoutDownloads`  - deletes artifacts that have never been downloaded (DownloadCount=0). Better to use
    with `DeleteOlderThan` rule

  ```yaml
  - rule: DeleteWithoutDownloads
  ```

  - `DeleteOlderThanNDaysWithoutDownloads` - deletes artifacts that are older than N days and have not been
    downloaded

  ```yaml
  - rule: DeleteOlderThanNDaysWithoutDownloads
    days: 1
  ```

  - `DeleteNotUsedSince` - delete artifacts that were downloaded, but for a long time. N days passed. Or not
    downloaded at all from the moment of creation and it's been N days

  ```yaml
  - rule: DeleteNotUsedSince
    days: 1
  ```

  - `DeleteEmptyFolders` - Clean up empty folders in given repository list

  ```yaml
  - rule: DeleteEmptyFolders
  ```

  - `DeleteByRegexpName` - delete artifacts whose name matches the specified regexp

  ```yaml
  - rule: DeleteByRegexpName
    regex_pattern: "\d"
  ```



  - `KeepLatestNFiles` - Leaves the last (by creation time) files in the amount of N pieces. WITHOUT accounting
    subfolders

  ```yaml
  - rule: KeepLatestNFiles
    count: 1
  ```

  - `KeepLatestNFilesInFolder` - Leaves the last (by creation time) files in the number of N pieces in each
    folder

  ```yaml
  - rule: KeepLatestNFilesInFolder
    count: 1
  ```

  - `KeepLatestVersionNFilesInFolder` - Leaves the latest N (by version) files in each
    folder. The definition of the version is using regexp. By default it parses [semver](https://semver.org/) using the regex - `([\d]+\.[\d]+\.[\d]+)")`

  ```yaml
  - rule: KeepLatestVersionNFilesInFolder
    count: 1
    custom_regexp: "[^\\d][\\._]((\\d+\\.)+\\d+)"
  ```

  - `KeepLatestNupkgNVersions` - Leaves N nupkg (adds `*.nupkg` filter) in release feature builds

  ```yaml
  - rule: KeepLatestNupkgNVersions
    count: 1
  ```



  - `DeleteDockerImagesOlderThan` - Delete docker images that are older than N days

  ```yaml
  - rule: DeleteDockerImagesOlderThan
    days: 1
  ```

  - `DeleteDockerImagesOlderThanNDaysWithoutDownloads` - Deletes docker images that are older than N days and have
    not been downloaded

  ```yaml
  - rule: DeleteDockerImagesOlderThanNDaysWithoutDownloads
    days: 1
  ```

  - `DeleteDockerImagesNotUsed` - Removes Docker image not downloaded since N days

  ```yaml
  - rule: DeleteDockerImagesNotUsed
    days: 1
  ```

  - `IncludeDockerImages` - Apply to docker images with the specified names and tags

  ```yaml
  - rule: IncludeDockerImages
    masks: "*singlemask*"
  - rule: IncludeDockerImages
    masks:
      - "*production*"
      - "*release*"
  ```

  - `ExcludeDockerImages` - Exclude Docker images by name and tags.

  ```yaml
  - rule: ExcludeDockerImages
    masks:
      - "*production*"
      - "*release*"
  ```

  - `KeepLatestNVersionImagesByProperty(count=N, custom_regexp='some-regexp', number_of_digits_in_version=X)` - Leaves N
    Docker images with the same major. `(^\d+\.\d+\.\d+$)` is the default regexp how to determine version which matches semver `1.1.1`. If you
    need to add minor then set `number_of_digits_in_version` to 2 or if patch then set to 3 (by default we match major, which 1). Semver tags
    prefixed with `v` are supported by updating the regexp to include (an optional) `v` in the expression (e.g., `(^v?\d+\.\d+\.\d+$)`).

  ```yaml
  - rule: KeepLatestNVersionImagesByProperty
    count: 1
    custom_regexp: "[^\\d][\\._]((\\d+\\.)+\\d+)"
  ```

  - `KeepLatestNDockerImages(count=N)` - Leaves N
    most recently updated Docker image digests. This ensures all tags matching the same digest is kept.

  ```yaml
  - rule: KeepLatestNDockerImages
    count: 1
  ```

  - `DeleteDockerImageIfNotContainedInProperties(docker_repo='docker-local', properties_prefix='my-prop', image_prefix=None, full_docker_repo_name=None)`
    \- Remove Docker image, if it is not found in the properties of the artifact repository.

  - `DeleteDockerImageIfNotContainedInPropertiesValue(docker_repo='docker-local', properties_prefix='my-prop', image_prefix=None, full_docker_repo_name=None)`
    \- Remove Docker image, if it is not found in the properties of the artifact repository.



  - `IncludePath` - Apply to artifacts by path / mask.

  ```yaml
  - rule: IncludePath
    masks: "*production*"
  - rule: IncludePath
    masks:
     - "*production*"
     - "*develop*"
  ```

  - `IncludeFilename` - Apply to artifacts by name/mask

  ```yaml
  - rule: IncludeFilename
    masks:
     - "*production*"
     - "*develop*"
  ```

  - `ExcludePath` - Exclude artifacts by path/mask

  ```yaml
  - rule: ExcludePath
    masks:
     - "*production*"
     - "*develop*"
  ```

  - `ExcludeFilename` - Exclude artifacts by name/mask

  ```yaml
  - rule: ExcludeFilename
    masks:
      - "*.tag.gz"
      - "*.zip"
  ```



  If you want to create your own rule, you can do it!

  The basic flow how the tool calls Rules:

  1. `Rule.check(*args, **kwargs)` - verify that the Rule configured right. Call other services to get more information.
  2. `Rule.aql_add_filter(filters)` - add Artifactory Query Language expressions
  3. `Rule.aql_add_text(aql)` - add text to the result aql query
  4. `artifactory-cleanup` calls Artifactory with AQL and pass the result to the next step
  5. `Rule.filter(artifacts)` - filter out artifacts. The method returns **artifacts that will be removed!**.
      - To keep artifacts use `artifacts.keep(artifact)` method

  Create `myrule.py` file at the same folder as `artifactory-cleanup.yaml`:

  ```python

  from typing import List

  from artifactory_cleanup import register
  from artifactory_cleanup.rules import Rule, ArtifactsList


  class MySimpleRule(Rule):
      """
      This doc string is used as rule title

      For more methods look at Rule source code
      """

      def __init__(self, my_param: str, value: int):
          self.my_param = my_param
          self.value = value

      def aql_add_filter(self, filters: List) -> List:
          print(f"Today is {self.today}")
          print(self.my_param)
          print(self.value)
          return filters

      def filter(self, artifacts: ArtifactsList) -> ArtifactsList:
          """I'm here just to print the list"""
          print(self.my_param)
          print(self.value)
          
          
          
          
          return artifacts



  register(MySimpleRule)
  ```

  Use `rule: MySimpleRule` in configuration:

  ```yaml

  - rule: MySimpleRule
    my_param: "Hello, world!"
    value: 42
  ```

  Specify `--load-rules` to the command:

  ```bash

  docker run -v "$(pwd)":/app devopshq/artifactory-cleanup artifactory-cleanup --load-rules=myrule.py


  artifactory-cleanup --load-rules=myrule.py
  ```





  In case you have set up your Artifactory self-signed certificates, place all certificates of the chain of trust into
  the `certificates` folder and add additional argument to the command:

  ```bash
  docker run -v "$(pwd)":/app -v "$(pwd)/certificates":/mnt/self-signed-certs/ devopshq/artifactory-cleanup artifactory-cleanup
  ```



  We can handle conan's metadata by creating two policies:

  1. First one removes files but keep all metadata.
  2. Second one look at folders and if it contains only medata files - removes it (because there's no associated with
     metadata files)

  The idea came from https://github.com/devopshq/artifactory-cleanup/issues/47

  ```yaml

  artifactory-cleanup:
    server: https://repo.example.com/artifactory
    user: $ARTIFACTORY_USERNAME
    password: $ARTIFACTORY_PASSWORD

    policies:
      - name: Conan - delete files older than 60 days
        rules:
          - rule: Repo
            name: "conan-testing"
          - rule: DeleteNotUsedSince
            days: 60
          - rule: ExcludeFilename
            masks:
              - ".timestamp"
              - "index.json"
      - name: Conan - delete empty folders (to fix the index)
        rules:
          - rule: Repo
            name: "conan-testing"
          - rule: DeleteEmptyFolders
          - rule: ExcludeFilename
            masks:
              - ".timestamp"
              - "index.json"
  ```



  We can combine docker rules with usual "files" rules!

  The idea came from https://github.com/devopshq/artifactory-cleanup/issues/61

  ```yaml

  artifactory-cleanup:
    server: https://repo.example.com/artifactory
    user: $ARTIFACTORY_USERNAME
    password: $ARTIFACTORY_PASSWORD

    policies:
      - name: Remove docker images, but keep last 3
        rules:
          
          - rule: Repo
            name: docker-demo
          
          - rule: DeleteDockerImagesOlderThan
            days: 30
          
          - rule: ExcludeDockerImages
            masks:
              - "*:latest"
              - "*:release*"
          
          - rule: ExcludePath
            masks: "*base-tools*"
          
          - rule: KeepLatestNFilesInFolder
            count: 3
  ```



  In order to provide a new release of `artifactory-cleanup`, there are two steps involved.

  1. Bump the version in the [setup.py](setup.py)
  2. Bump the version in the [__init__.py](./artifactory_cleanup/__init__.py)
  3. Create a Git release tag (in format `1.0.1`) by creating a release on GitHub


pkgId: 950a6ea3acdd5f3f1d2ebe4c4132e3e2db0d24f265d7011a42126dc795748e36
name: python-artless-core-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for artless-core
url: https://git.peterbro.su/peter/py3-artless-core
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-artless-core-0.2.2-1.src.rpm
location_href: Packages/python-artless-core-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI Version](https://img.shields.io/pypi/v/artless-core)
  ![Development Status](https://img.shields.io/badge/status-3%20--%20Alpha-orange)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/artless-core)
  [![Downloads](https://static.pepy.tech/badge/artless-core)](https://pepy.tech/project/artless-core)
  ![PyPI - License](https://img.shields.io/pypi/l/artless-core)

  The artless and minimalistic web library for creating small applications or APIs.



  An extremely minimalistic framework was needed to create the same minimalistic applications. Those "micro" frameworks like `Flask`, `Pyramid`, `CherryPie`, etc - turned out to be not micro at all). Even a single-module `Bottle` turned out to be a "monster" of 4 thousand LOC and supporting compatibility with version 2.7.

  Therefore, it was decided to sketch out our own simple, minimally necessary implementation of the WSGI library for creating small/simple web app.



  1. Artless, fast and small (less then 400 LOC) single-file module.
  2. No third party dependencies (standart library only).
  3. Support only modern versions of Python (>=3.10).
  4. Mostly pure functions without side effects.
  5. Interfaces with type annotations.
  6. Comprehensive documentation with examples of use.
  7. Full test coverage.



  * No `Async/ASGI` support.
  * No `WebSocket` support.
  * No `Cookies` support.
  * No `multipart/form-data` support.
  * No built-in protections, such as: `CSRF`, `XSS`, `clickjacking` and other.



  ``` shellsession
  $ pip install artless-core
  ```



  ``` python
  from http import HTTPStatus
  from os import getenv

  from artless import App, Request, Response, ResponseFactory


  def get_template(username: str) -> str:
      return f"""
      <!DOCTYPE html>
      <html lang="en">
        <head>
          <meta charset="utf-8">
          <title>Say hello</title>
        </head>
        <body>
          <h1>Hello, {username}!</h1>
        </body>
      </html>
      """


  def say_hello(request: Request, username: str) -> Response:
      available_formats = {
          "json": ResponseFactory.json({"hello": username}),
          "plain": ResponseFactory.plain(f"Hello, {username}!"),
          "html": ResponseFactory.html(get_template(username)),
      }

      format = request.query.get("format", ["plain"])[0]

      if format not in available_formats:
          return ResponseFactory.create(status=HTTPStatus.BAD_REQUEST)

      return available_formats[format]


  def create_application() -> App:
      app = App()
      app.set_routes([("GET", r"^/hello/(?P<username>\w+)$", say_hello)])
      return app


  application = create_application()

  if __name__ == "__main__":
      from wsgiref.simple_server import make_server

      host = getenv("HOST", "127.0.0.1")
      port = int(getenv("PORT", 8000))

      with make_server(host, port, application) as httpd:
          print(f"Started WSGI server on {host}:{port}")
          httpd.serve_forever()
  ```

  Run it:

  ``` shellsession
  $ python3 app.py
  Started WSGI server on 127.0.0.1:8000
  ```

  Check it:

  ``` shellsession
  $ curl http://127.0.0.1:8000/hello/Peter
  Hello, Peter!

  $ curl http://127.0.0.1:8000/hello/Peter?format=html
  <!DOCTYPE html>
  <html lang="en">
    <head>
      <meta charset="utf-8">
      <title>Say hello</title>
    </head>
    <body>
      <h1>Hello, Peter!</h1>
    </body>
  </html>

  $ curl http://127.0.0.1:8000/hello/Peter?format=json
  {"hello": "Peter"}
  ```

  Need more? See [documentation](https://pages.peterbro.su/py3-artless-core/) and [examples](https://git.peterbro.su/peter/py3-artless-core/src/branch/master/examples).



  - [ ] Add Async/ASGI support.
  - [ ] Add plugin support.
  - [ ] Add cookies support.
  - [ ] Add `multipart/form-data` support.
  - [ ] Add test client.
  - [ ] Add benchmarks.
  - [ ] Add more examples.
  - [x] Add Sphinx doc.



  * [artless-template](https://pypi.org/project/artless-template/) - the artless and small template library for server-side rendering.


pkgId: 22beb569636b47f49f504d072227823447e38b22d0de98c1302e4f51e6ed9309
name: python-artless-template-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for artless-template
url: https://git.peterbro.su/peter/py3-artless-template
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-artless-template-0.5.1-1.src.rpm
location_href: Packages/python-artless-template-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI Version](https://img.shields.io/pypi/v/artless-template)
  ![Development Status](https://img.shields.io/badge/status-3%20--%20Alpha-orange)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/artless-template)
  [![Downloads](https://static.pepy.tech/badge/artless-template)](https://pepy.tech/project/artless-template)
  ![PyPI - License](https://img.shields.io/pypi/l/artless-template)

  The artless and small template library for server-side rendering.

  Artless-template allows to generate HTML, using template files or/and natively Python objects. The library encourages approaches like HTMX and No-JS.

  **Main principles**:
  1. Artless, fast and small (less than 200 LOC) single-file module.
  2. No third party dependencies (standart library only).
  3. Support only modern versions of Python (>=3.10).
  4. Mostly pure functions without side effects.
  5. Interfaces with type annotations.
  6. Comprehensive documentation with examples of use.
  7. Full test coverage.

  **Table of Contents**:
  * [Install](#install)
  * [Usage](#usage)
    * [Template and tags usage](#usage-tags)
    * [Template and components usage](#usage-components)
    * [Asynchronous functions](#async)
  * [Performance](#performance)
  * [Rodmap](#roadmap)
  * [Related projects](#related)

  <a id="install"></a>


  ``` shellsession
  $ pip install artless-template
  ```

  <a id="usage"></a>


  Basically, you can create any tag with any name, attributes, text and child tags:

  ``` python
  from artless_template import Tag as t

  div = t("div")
  print(div)
  <div></div>

  div = t("div", {"class": "some-class"}, "Some text")
  print(div)
  <div class="some-class">Some text</div>

  div = t("div", {"class": "some-class"}, "Div text", [t("span", "Span 1 text"), t("span", "Span 2 text")])
  print(div)
  <div class="some-class"><span>Span 1 text</span><span>Span 2 text</span>Div text</div>

  button = t("button", {"onclick": "function() {alert('hello');}"}, "Say Hello")
  print(button)
  <button onclick="function() {alert('hello');}">Say Hello</button>
  ```

  <a id="usage-tags"></a>


  Create `templates/index.html` with contents:

  ``` html
  <!DOCTYPE html>
  <html lang="en">
    <head>
      <meta charset="utf-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1" />
      <title>@title</title>
    </head>
    <body>
      <main>
          <section>
              <h1>@header</h1>
              <table>
                  <thead>
                      <tr>
                          <th>Name</th>
                          <th>Email</th>
                          <th>Admin</th>
                      </tr>
                  </thead>
                  @users
              </table>
          </section>
      </main>
    </body>
  </html>
  ```

  ``` python
  from typing import final
  from pathlib import Path
  from random import randint
  from dataclasses import dataclass
  from artless_template import read_template, Tag as t

  TEMPLATES_DIR: Path = Path(__file__).resolve().parent / "templates"

  @final
  @dataclass(frozen=True, slots=True, kw_only=True)
  class UserModel:
      name: str
      email: str
      is_admin: bool


  users = [
      UserModel(
          name=f"User_{_}", email=f"user_{_}@gmail.com", is_admin=bool(randint(0, 1))
      )
      for _ in range(10_000)
  ]


  users_markup = t(
      "tbody",
      children=[
          t(
              "tr",
              [
                  t("td", user.name),
                  t("td", user.email),
                  t("td", "+" if user.is_admin else "-"),
              ],
          )
          for user in users
      ],
  )

  context = {
      "title": "Artless-template example",
      "header": "Users list",
      "users": users_markup,
  }

  template = read_template(TEMPLATES_DIR / "index.html").render(**context)
  ```

  <a id="usage-components"></a>


  ``` html
  <!DOCTYPE html>
  <html lang="en">
    ...
    <body>
      <main>
        @main
      </main>
    </body>
  </html>
  ```

  ``` python
  from artless_template import read_template, Component, Tag as t

  ...

  class UsersTableComponent:
      def __init__(self, count: int):
          self.users = [
              UserModel(
                  name=f"User_{_}", email=f"user_{_}@gmail.com", is_admin=bool(randint(0, 1))
              )
              for _ in range(count)
          ]

      def view(self):
          return t(
              "table",
              [
                  t(
                      "thead",
                      [
                          t(
                              "tr",
                              [
                                  t("th", "Name"),
                                  t("th", "Email"),
                                  t("th", "Admin"),
                              ]
                          )
                      ]
                  ),
                  t(
                      "tbody",
                      [
                          t(
                              "tr",
                              [
                                  t("td", user.name),
                                  t("td", user.email),
                                  t("td", "+" if user.is_admin else "-"),
                              ],
                          )
                          for user in self.users
                      ]
                  )
              ]
          )

  template = read_template(TEMPLATES_DIR / "index.html").render(main=UsersTableComponent(100500))
  ```

  <a id="async"></a>


  The library provides async version of io-bound function - `read_template`. An asynchronous function has `a` prefix and called `aread_template`.

  ``` python
  from artless_template import aread_template

  template = await aread_template("some_template.html")
  ...
  ```

  Read detailed reference **[documentation](https://pages.peterbro.su/py3-artless-template/reference.html)**.

  <a id="performance"></a>


  Performance comparison of the most popular template engines and artless-template library.
  The benchmark render a HTML document with table of 10 thousand user models.

  Run benchmark:

  ``` shellsession
  $ python -m bemchmarks
  ```

  Sorted results on i5 laptop (smaller is better):

  ``` python
  {
      'mako': 0.0541565099847503,
      'jinja': 0.26099945200257935,
      'artless': 0.99770416400861,
      'dtl': 1.07213215198135,
      'fasthtml': 11.734292993991403
  }
  ```

  1. [Mako](https://www.makotemplates.org/) (0.05415 sec.)
  2. [Jinja2](https://jinja.palletsprojects.com/en/3.1.x/) (0.26099 sec.)
  3. **Artless-template (0.99770 sec.)**
  4. [Django templates](https://docs.djangoproject.com/en/5.0/ref/templates/) (1.07213 sec.)
  5. [FastHTML](https://github.com/AnswerDotAI/fasthtml/) (11.73429 sec.)

  The performance of `artless-template` is better than the `Django template engine`, and much better than FastHTML, but worse than `Jinja2` and `Mako`.

  <a id="roadmap"></a>


  - [x] Simplify the Tag constructor.
  - [x] Write detailed documentation with Sphinx.
  - [x] Create async version of `read_template()` - `aread_template()`.
  - [ ] Cythonize CPU/RAM-bound of code.

  <a id="related"></a>


  * [artless-core](https://pypi.org/project/artless-core/) - the artless and minimalistic web library for creating small applications or APIs.


pkgId: 52e6a0f57948bf17f56733ef0ed31942654bd950e59d825f08e8e6e1095e6196
name: python-arxivsummary-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for arxivsummary
url: https://pypi.org/project/arxivsummary/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-arxivsummary-0.1-1.src.rpm
location_href: Packages/python-arxivsummary-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  See CONTRIBUTING.md for build instructions, or install from PyPI with:

  ```
  python -m pip install arxivsummary
  ```

  Use `arxivsummary -h` for help.

  For an example report, see https://github.com/gramster/arxivsummary/blob/main/example.md



  This project uses `flit`. First install `flit`:

  ```
  python -m pip install flit
  ```

  Then to build:

  ```
  flit build
  ```

  To install locally:

  ```
  flit install
  ```

  To publish to PyPI:

  ```
  flit publish
  ```



  0.1 Initial release


pkgId: 1ac4555074de46983816363baf40929a805ac40a9810dba100fbf852ec1bf114
name: python-aryaxai-help
arch: noarch
version: 0.0.87
epoch: 0
release: 1
summary: Development documents and examples for aryaxai
url: https://xai.arya.ai/docs/introduction
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aryaxai-0.0.87-1.src.rpm
location_href: Packages/python-aryaxai-help-0.0.87-1.noarch.rpm
checksum_type: sha256
description:
  AryaXAI is a full-stack ML Observability platform that integrates with your MLOPs platform to Explain, Monitor, Audit and Improve your ML models.

  AryaXAI has multiple components to address the complex observability required for mission-critical ‘AI’.

  1. **ML Explainability:** AryaXAI offers diverse explainability options like- Bactrace(Specialized for deep learning models), SHAPE, Decision View, Observations (New way to correlate expert functioning vs model functioning) and Similar Cases (reference as explanations).
  2. **ML Monitoring:** Monitor your models for drifts, performance & bias. The tool offers diverse options for drift (data/model) like - PSI, KL Divergence, Chi-square test,
  3. **Synthetic ‘AI’:** Deploy advanced synthetic ‘AI’ techniques like GPT-2 & GANs on your tabular data to generate high-quality synthetic datasets. Test the quality and privacy of these data sets using our Anonymity tests, column tests etc.
  4. **ML Risk policies:** Define advanced risk policies on your models.
  5. **AutoML:** AryaXAI also provides fully low-code and no-code options to build ML models on your data. For advanced users, it also provides more options to fine-tune it.

  AryaXAI also acts as a common workflow and provides insights acceptable by all stakeholders - Data Science, IT, Risk, Operations and compliance teams, making the rollout and maintenance of AI/ML models seamless and clutter-free.


  Get started with AryaXAI with a few easy steps:

  1. Sign up and log in to your new AryaXAI account.
  2. After logging in, generate an Access Token for your user account.
  3. Set the environment variable **XAI_ACCESS_TOKEN** with the generated value.

  Once you've completed these steps, you're all set! Now, you can easily log in and start using the AryaXAI SDK:

  1. Log in by importing the "xai" object instance from the "arya_xai" package.
  2. Call the "login" method. This method automatically takes the access token value from the "XAI_ACCESS_TOKEN" environment variable and stores the JWT in the object instance. This means that all your future SDK operations will be authorized automatically, making it simple and hassle-free!


  ```
  from aryaxai import xai as aryaxai




  aryaxai.login()


  Enter your Arya XAI Access Token: ··········
  Authenticated successfully.
  ```


  In this section, you can review the examples of implementation of AryaXAI-SDK.

  1. [Full features overview of AryaXAI](https://colab.research.google.com/drive/1Dy5eL-FJVnFV0K5yOfGGVoAmiS_Icaz3?usp=sharing)
  2. Using AryaXAI in Loan Underwriting (Coming Soon)


  At AryaXAI, we're passionate about open source and value community contributions! Explore our contribution guide for insights into the development workflow and AryaXAI library internals. For bug reports or feature requests, head to GitHub Issues or reach out to us at [support@aryaxai.com](support@aryaxai.com).


pkgId: 244392ee4b26ebc31a367ba6bd81a0e83c92707b7ff99f7a6cb2b9075b2f88bc
name: python-aserehe-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for aserehe
description: A Semantic Release Helper CLI written in Python.
url: https://pypi.org/project/aserehe/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-aserehe-0.1.0-1.src.rpm
location_href: Packages/python-aserehe-help-0.1.0-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c)️ 2023 Jan Lukány  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: 907bdea5f89df1283cf942488e0166cde94197df4c97026e2a448ca9cda3f4d0
name: python-asf-tools-help
arch: noarch
version: 0.8.1
epoch: 0
release: 1
summary: Development documents and examples for asf-tools
url: https://github.com/ASFHyP3/asf-tools
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-asf-tools-0.8.1-1.src.rpm
location_href: Packages/python-asf-tools-help-0.8.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI license](https://img.shields.io/pypi/l/asf_tools.svg)](https://pypi.python.org/pypi/asf_tools/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/asf_tools.svg)](https://pypi.python.org/pypi/asf_tools/)
  [![PyPI version](https://img.shields.io/pypi/v/asf_tools.svg)](https://pypi.python.org/pypi/asf_tools/)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/asf_tools)](https://anaconda.org/conda-forge/asf_tools)
  [![Conda platforms](https://img.shields.io/conda/pn/conda-forge/asf_tools)](https://anaconda.org/conda-forge/asf_tools)

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

  `asf_tools` is a Python package for working with Synthetic Aperture Radar (SAR) data.
  It was designed for working with datasets generated by
  [HyP3](https://hyp3-docs.asf.alaska.edu/), but several of the tools have the
  potential to be used with a variety of rasters, including non-SAR datasets.




  In order to easily manage dependencies, we recommend using dedicated project
  environments via [Anaconda/Miniconda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html).
  It is also possible to use [Python virtual environments](https://docs.python.org/3/tutorial/venv.html),
  but installation of non-python dependencies (e.g., `gdal`) can be challenging.

  `asf_tools` can be installed into a conda environment with:

  ```
  conda install -c conda-forge asf_tools
  ```

  or into a virtual environment with:

  ```
  python -m pip install asf_tools
  ```



  We also publish a [Docker](https://docs.docker.com/get-started/) image for `asf_tools`, with all the dependencies
  pre-installed, to the GitHub Container Registry:
  <https://github.com/ASFHyP3/asf-tools/pkgs/container/asf-tools>.

  You can pull an image with the latest released version of `asf_tools`  with the command:
  ```
  docker pull ghcr.io/asfhyp3/asf-tools:latest
  ```

  Or, the development version with:
  ```
  docker pull ghcr.io/asfhyp3/asf-tools:test
  ```

  And then run the container with:
  ```
  docker run --rm -it ghcr.io/asfhyp3/asf-tools:latest
  ```
  which will drop you into a `bash` shell inside the container with an active `asf-tools` conda environment.

  To move data between your local (host) machine and the container, you can mount a
  [volume](https://docs.docker.com/storage/volumes/) with:
  ```
  docker run --rm -it -v /path/to/data:/home/conda/data ghcr.io/asfhyp3/asf-tools:latest
  ```





  The `make_composite` tool allows you to create a local-resolution-weighted composite
  from a set of Sentinel-1 RTC products ([D. Small, 2012](https://doi.org/10.1109/IGARSS.2012.6350465)).
  It is intended to be used with RTC products generated by [ASF HyP3](https://hyp3-docs.asf.alaska.edu/using/vertex).

  You will need to request RTC products using the `Include Scattering Area` option,
  then download and unzip them into an empty directory.

  To generate a composite of the co-polarization images, navigate to the directory
  containing the unzipped RTC products and run:
  ```
  make_composite VV-composite */*VV.tif
  ```

  To generate a composite of the cross-polarization images, navigate to the directory
  containing the unzipped RTC products and run:
  ```
  make_composite VH-composite */*VH.tif
  ```


  Because the imagery has been radiometrically terrain corrected (RTC), geometric and
  radiometric distortions have been removed from the files to be composited. One the
  strong points of LRW composites is that you combine both ascending and descending
  datatakes into a single product. In this manner no layover or shadow masks are
  required - what is shadowed on an ascending pass is visible in a descending pass
  and vice-versa. Thus, not only is it possible to combine ascending and descending,
  but it is highly encouraged. Using many datatakes from both the ascending and
  descending satellite passes will make the best composites possible.


  In an LRW composite, each satellite pass contributes to creating the output pixels.
  The amount of this contribution is scaled by the inverse of the scattering area used
  during terrain correction (thus the need for requesting the area map option of HyP3 RTC).
  The inverse of the surface scattering area, also referred to as local resolution,
  is multiplied by each pixel's backscatter value. The results of all of the images
  covering any single pixel are then summed. This total is then divided by the sum
  of the weights used to get the output average backscatter.



  >[!WARNING]
  > The HydroSAR codes (`flood_map`, `water_map` and `hand` modules) are being
  > moved to the [HydroSAR project repository](https://github.com/fjmeyer/hydrosar)
  > and will be provided in a new pip/conda installable package `hydrosar`.
  >
  > The `asf_tools.hydrosar` subpackage will be removed in a future release.

  The `water_map` tool allows you to create a surface water extent map from a Sentinel-1
  dual-pol (VV+VH) RTC product. It is intended to be used with RTC products generated by
  [ASF HyP3](https://hyp3-docs.asf.alaska.edu/using/vertex).

  Additionally, a HAND (height above nearest drainage) GeoTIFF that is pixel aligned to
  the RTC images is required, and preferably derived from the same DEM used to correct
  the RTC images -- the quality of the HAND used is directly tied to the quality of the
  output water extent map.

  To make a water extent map, run:
  ```
  water_map [OUT_RASTER] [VV_RASTER] [VH_RASTER] [HAND_RASTER]
  ```

  For more information and to see the options available, see:
  ```
  water_map --help
  ```

  For details on the algorithm see the `asf_tools.water_map.make_water_map` docstring.
  <!-- FIXME: Link to API reference on our docs page! -->



  >[!WARNING]
  > The HydroSAR codes (`flood_map`, `water_map` and `hand` modules) are being
  > moved to the [HydroSAR project repository](https://github.com/fjmeyer/hydrosar)
  > and will be provided in a new pip/conda installable package `hydrosar`.
  >
  > The `asf_tools.hydrosar` subpackage will be removed in a future release.

  The `flood_map` tool allows you to create an estimated flood depth map from the surface
  water extent map created by the `water_map` tool.

  Additionally, a HAND (height above nearest drainage) GeoTIFF that is pixel aligned to
  the surface water extent map is required. An ideal candidate is the HAND image created
  by the `water_map` tool.

  To make a flood depth map, run:
  ```
  flood_map [OUT_RASTER] [SURFACE_WATER_MAP] [HAND_RASTER]
  ```

  For more information and to see the options available, see:
  ```
  flood_map --help
  ```

  For details on the algorithm see the `asf_tools.flood_map.make_flood_map` docstring.



  The `asf_tools.watermasking` sub-package allows you to create a watermasking dataset
  over an arbitrary ROI using OpenStreetMap and ESA WorldCover data.
  Note, this program requires `osmium-tool`. See the [watermasking subpackage readme](https://github.com/ASFHyP3/asf-tools/blob/main/src/asf_tools/watermasking/README.md)
  for more information on setup and usage.


pkgId: edfb70dc22d7f9ab4621f97c83ccb240e1317721291838e97c445d24aec8b6b1
name: python-asgi_aiogram-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for asgi_aiogram
url: https://pypi.org/project/asgi_aiogram/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-asgi_aiogram-0.3.1-1.src.rpm
location_href: Packages/python-asgi_aiogram-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  __base usage__
  ```python
  from aiogram import Dispatcher, Bot
  from asgi_aiogram import ASGIAiogram
  from asgi_aiogram.strategy import SingleStrategy
  from asgi_aiogram.strategy import HttpStrategy
  from asgi_aiogram.http_responses import JsonResponse
  from asgi_aiogram.http_request import Request

  dp = Dispatcher()

  @dp.startup()
  async def startup(dispatcher: Dispatcher, bot: Bot):
      await bot.close()
      await bot.set_webhook(
          url='https://example.com/bot',
          allowed_updates=dispatcher.resolve_used_update_types()
      )

  async def get(request: Request):
      return JsonResponse(body={"status": "ok"})

  bot = Bot(token="<token>")
  app = ASGIAiogram(
          SingleStrategy(path="/bot", bot=bot, dispatcher=dp),
          HttpStrategy(path="/health", method="GET", handler=get),
  )
  ```

  ```commandline
  uvicorn main:app
  ```


pkgId: 19ba4ee4b73da63ad6ca73bb752c08c725b8770ce62e063c4a681f21867edd19
name: python-asgi_ws-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for asgi_ws
url: https://pypi.org/project/asgi_ws/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-asgi_ws-0.1.2-1.src.rpm
location_href: Packages/python-asgi_ws-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  In this post, I will show you how to create a WebSocket server in Python that uses JWT tokens for authentication. The server is designed to be independent of the main process, making it easy to integrate into existing applications. The client-side JavaScript will handle reconnections incrementally.

  The WebSocket server will be created using FastApi, the web framework built on top of Starlette. This is the entrypoint.

  ```python
  import logging

  from fastapi import FastAPI

  from asgi_ws import setup_app

  logging.basicConfig(
      format='s [s] s',
      level='INFO',
      datefmt='%d/%m/%Y %X')

  logger = logging.getLogger(__name__)
  SECRET_KEY = "your_secret_key"

  app = FastAPI()

  app = setup_app(
      app=app,
      base_path='/ws',
      jwt_secret_key=SECRET_KEY,
  )
  ```

  The `setup_app` function is defined in the `lib.websockets` module. This function will set up the WebSocket server and the necessary routes.

  ```python
  def setup_app(app, jwt_secret_key: str, base_path='/ws', jwt_algorithm: str = "HS256"):
      ws_router = get_ws_router(
          jwt_secret_key=jwt_secret_key,
          jwt_algorithm=jwt_algorithm,
          base_path=base_path
      )
      current_dir = Path(__file__).parent
      static_dir = current_dir / "static/js"

      app.mount("/js", StaticFiles(directory=static_dir), name="js")
      app.include_router(ws_router)

      return app
  ```

  The `get_ws_router` function is defined in the same module. This function will create the WebSocket router and the necessary routes.

  ```python
  def get_ws_router(jwt_secret_key: str, base_path='ws', jwt_algorithm: str = "HS256"):
      ws_router = APIRouter()

      current_dir = Path(__file__).parent
      static_dir = current_dir / "static/js"
      ws_router.mount(f"{base_path}/js", StaticFiles(directory=static_dir), name="js")

      manager = ConnectionManager(jwt_secret_key=jwt_secret_key, jwt_algorithm=jwt_algorithm)

      @ws_router.post(f"{base_path}/emmit")
      async def emmit_endpoint(request: Request):
          payload = await request.json()
          await manager.broadcast(payload["channel"], payload["payload"])
          return True

      @ws_router.websocket(f"{base_path}/")
      async def websocket_endpoint(websocket: WebSocket):
          token = websocket.query_params.get("token")
          if not token:
              await websocket.close(code=1008)
              raise HTTPException(status_code=401, detail="Token required")

          await manager.connect(websocket, token)
          try:
              while True:
                  message: Message = await websocket.receive()
                  if message["type"] == "websocket.disconnect":
                      manager.disconnect(websocket)
                      break
          except WebSocketDisconnect:
              manager.disconnect(websocket)

      return ws_router
  ```

  Websockets are bidirectional communication channels that allow real-time data transfer between clients and servers, but I prefer to avoid the communication from the client to the server. When a client wants to send a message to the server, it will send an HTTP POST request to the `/emit` endpoint (via the main process). The server will then broadcast the message to all connected clients. The client will only receive messages from the server. Because of that we need a main wsgi process using FastApi or another web framework to handle the HTTP requests.

  This an example with FastApi:

  ```html
  <!DOCTYPE html>
  <html>
  <head>
      <title>Chat</title>
  </head>
  <body>
  <h1>WebSocket Chat</h1>

  <input type="text" id="messageText" autocomplete="off"/>
  <button onclick="sendMessage()">Send</button>

  <ul id='messages'>
  </ul>
  <script src="//localhost:8000/js/websockets.js"></script>
  <script>
      async function sendMessage() {
          const channel = 'chat';
          const url = `/emit/${channel}`;
          const input = document.getElementById("messageText");
          const message = input.value;
          input.value = '';
          const body = JSON.stringify({channel: 'chat1', payload: message});
          const headers = {'Content-Type': 'application/json'};

          try {
              const response = await fetch(url, {method: 'POST', headers: headers, body: body});
          } catch (error) {
              console.error('Error:', error);
          }
      }

      (async function () {
          const getToken = async () => {
              const response = await fetch('/token');
              const {token} = await response.json();
              return token;
          };

          const messageCallback = (event) => {
              const messages = document.getElementById('messages');
              const message = document.createElement('li');
              message.textContent = event.data;
              messages.appendChild(message);
          };

          const wsManager = new WebSocketManager('ws://localhost:8000/ws/', getToken, messageCallback);
          await wsManager.connect();
      })();

  </script>
  </body>
  </html>
  ```


pkgId: 75254aada3e723cce84b72fced3574ef16315ffa3439c6c6b5d8ed98f931ce6f
name: python-ash-dal-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for ash-dal
url: https://pypi.org/project/ash-dal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ash-dal-0.3.0-1.src.rpm
location_href: Packages/python-ash-dal-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  The library provides a standardized way to connect to DB, and Base DAO class implementation





  ```shell
  pip install ash-dal



  poetry add ash-dal
  ```


  In order to install Ash DAL directly from GitHub repository, run:
  ```shell
  pip install git+https://github.com/meetash/ash-dal.git@main



  poetry add git+https://github.com/meetash/ash-dal.git@main
  ```


  There are two options: sync or async database connection.

  ```python
  from ash_dal import Database, URL
  from ash_dal.utils import prepare_ssl_context
  from models import User


  ssl_context = prepare_ssl_context(
      ssl_root_dir='/tmp/certs',
      client_cert_path='client-cert.pem',
      client_key_path='client-key.pem',
      server_ca_path='server-ca.pem'
  )

  db_url = URL.create(
      drivername="mysql+pymysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3306,
      database="my_db",
  )

  read_replica_db_url = URL.create(
      drivername="mysql+pymysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3307,
      database="my_db",
  )


  DATABASE = Database(
  	db_url=db_url,
  	read_replica_url=read_replica_db_url,
  	ssl_context=ssl_context,
      read_replica_ssl_context=ssl_context
  )


  def get_users(db: Database):
  	with db.session as session:
  		users = session.scalars(User)
  	return users

  ```

  ```python
  from ash_dal import AsyncDatabase, URL
  from ash_dal.utils import prepare_ssl_context
  from models import User


  ssl_context = prepare_ssl_context(
      ssl_root_dir='/tmp/certs',
      client_cert_path='client-cert.pem',
      client_key_path='client-key.pem',
      server_ca_path='server-ca.pem'
  )

  db_url = URL.create(
      drivername="mysql+aiomysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3306,
      database="my_db",
  )

  read_replica_db_url = URL.create(
      drivername="mysql+aiomysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3307,
      database="my_db",
  )


  DATABASE = AsyncDatabase(
  	db_url=db_url,
  	read_replica_url=read_replica_db_url,
  	ssl_context=ssl_context,
      read_replica_ssl_context=ssl_context
  )

  async def async_get_users(db: AsyncDatabase):
  	async with db.session as session:
  		users = await session.scalars(User)
  	return users

  ```


  Like you can use sync/async Database classes, there are also two variations of DAO Base class



  ```python

  from dataclasses import dataclass

  from sqlalchemy import String
  from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
  from ash_dal import BaseDAO, Database, URL


  class Base(DeclarativeBase):
      pass


  class ExampleORMModel(Base):
      __tablename__ = "example_table"

      id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
      first_name: Mapped[str] = mapped_column(String(64))
      last_name: Mapped[str] = mapped_column(String(64))
      age: Mapped[int]


  @dataclass()
  class ExampleEntity:
      id: int
      first_name: str
      last_name: str
      age: int


  class ExampleDAO(BaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel


  if __name__ == '__main__':
      db = Database(
          db_url=URL.create(
              drivername="mysql+pymysql",
              username="my_db_user",
              password="S3cret",
              host="127.0.0.1",
              port=3306,
              database="my_db",
          )
      )
      dao = ExampleDAO(database=db)

      entity = dao.get_by_pk(pk='some-primary-key')
  ```



  ```python

  from dataclasses import dataclass

  from sqlalchemy import String
  from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
  from ash_dal import AsyncBaseDAO, AsyncDatabase, URL
  import asyncio


  class Base(DeclarativeBase):
      pass


  class ExampleORMModel(Base):
      __tablename__ = "example_table"

      id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
      first_name: Mapped[str] = mapped_column(String(64))
      last_name: Mapped[str] = mapped_column(String(64))
      age: Mapped[int]


  @dataclass()
  class ExampleEntity:
      id: int
      first_name: str
      last_name: str
      age: int


  class ExampleDAO(AsyncBaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel


  if __name__ == '__main__':
      db = AsyncDatabase(
          db_url=URL.create(
              drivername="mysql+aiomysql",
              username="my_db_user",
              password="S3cret",
              host="127.0.0.1",
              port=3306,
              database="my_db",
          )
      )
      dao = ExampleDAO(database=db)
      entity = asyncio.run(dao.get_by_pk(pk='some-primary-key'))
  ```


  The main goal of BaseDAO class is to provide CRUD methods that could be useful while building a basic CRUD API.
  `BaseDAO` class provides the following default methods:

  - `BaseDAO.get_by_pk(pk)` - Using this method you can fetch an entity by its primary key.
      ```python
      entity = dao.get_by_pk(pk='AWABCD1234')
      ```
  - `BaseDAO.all` - Using this method you can fetch all entities from the database. It's might be useful for fetching
      data from small tables where you don't actually need pagination (configs etc)
      ```python
      entities = dao.get_all()
      ```
  - `BaseDAO.get_page(page_index, [page_size])` - Fetch a page with entities by page index. If the index is out of range,
      an empty page will be returned. If `page_size` is not passed - the default page size (20) will be applied.
      ```python
      page = dao.get_page(page_index=2, page_size=10)
      for entity in page:
          
          ...
      ```
  - `BaseDAO.paginate([specification, page_size])` - An iterator that returns pages with entities. A specification
      can be applied to fetch filtered data.
      ```python
      for page in dao.paginate(specification={'status': 'notified'}, page_size=15):
          
          ...
      ```
  - `BaseDAO.filter(specification)` - Fetch entities from database by specification. It's might be useful for fetching
      filtered data from small tables where you don't actually need pagination (configs etc)
      ```python
      entities = dao.filter(specification={'labId': 2})
      ```

  - `BaseDAO.create(data)` - Create an entity in database based on passed data. Returns back an entity
      ```python
      data = {'foo': 'bar'}
      entity = dao.create(data=data)
      ```
  - `BaseDAO.bulk_create(data)` - Create multiple entities within one query. Unlike the previous method
      this one doesn't return anything.
      ```python
      data = [{'foo': 'bar'}, {'foo': 'beer'}]
      dao.bulk_create(data=data)
      ```
  - `BaseDAO.update(specification, update_data)` - Patch entity(ies) by specification.
      ```python
      update_data = {'foo': 'bar'}
      is_updated = dao.update(specification={'foo': 'beer'}, update_data=update_data)
      ```
  - `BaseDAO.delete(specification)` - Remove entity(ies) by specification.
      ```python
      is_removed = dao.delete(specification={'id': 'some-id'},)
      ```



  By default the BaseDAO class uses the simplest pagination strategy that is based on SQL offset & limit mechanisms.
  The library provides one more strategy out of the box that is called deferred join pagination.
  You can learn more about it [here](https://planetscale.com/learn/courses/mysql-for-developers/examples/deferred-joins).

  If you want to change the pagination strategy for you DAO class, you can do it by re-defining
  the `__paginator_factory__` field inside your DAO class:
  ```python
  from ash_dal import BaseDAO, DeferredJoinPaginator
  from ash_dal.utils import DeferredJoinPaginatorFactory, AsyncDeferredJoinPaginator

  class ExampleEntity:
      ...

  class ExampleORMModel:
      id: int
      ...

  class ExampleDAO(BaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel
      __paginator_factory__ = DeferredJoinPaginatorFactory(
          paginator_class=DeferredJoinPaginator,
          pk_field=ExampleORMModel.id,
      )



  class ExampleAsyncDAO(BaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel
      __paginator_factory__ = DeferredJoinPaginatorFactory(
          paginator_class=AsyncDeferredJoinPaginator,
          pk_field=ExampleORMModel.id,
      )
  ```

  You can also define your own pagination strategy. Be aware that your paginator class should implement IPaginator or
  IAsyncPaginator interfaces:

  ```python
  from ash_dal.utils.paginator.interface import IPaginator, IAsyncPaginator
  from ash_dal import PaginatorPage
  import typing as t

  class ExampleORM:
      ...

  class MyPaginator(IPaginator[ExampleORM]):
      def get_page(self, page_index: int) -> PaginatorPage[ExampleORM]:
          
          ...

      def paginate(self) -> t.Iterator[PaginatorPage[ExampleORM]]:
          
          ...
      @property
      def size(self) -> int:
          
          return 10



  class MyAsyncPaginator(IAsyncPaginator[ExampleORM]):
      async def get_page(self, page_index: int) -> PaginatorPage[ExampleORM]:
          
          ...

      async def paginate(self) -> t.AsyncIterator[PaginatorPage[ExampleORM]]:
          
          ...
      @property
      async def size(self) -> int:
          
          return 10
  ```


pkgId: afdfe80c336448444c9c414127687061ae789e73f4c21a9623f15d4037576d6a
name: python-asimov-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for asimov
url: https://git.ligo.org/asimov/asimov
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-asimov-0.6.1-1.src.rpm
location_href: Packages/python-asimov-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Asimov is a workflow management and automation platform for scientific analyses.

  [Documentation](https://asimov.docs.ligo.org/asimov) · [Releases](https://git.ligo.org/asimov/asimov/-/releases) · [Issue Tracker](https://git.ligo.org/asimov/asimov/-/issues)


  [![coverage report](https://git.ligo.org/asimov/asimov/badges/master/coverage.svg)](https://git.ligo.org/asimov/asimov/-/commits/master)
  [![conda-forge version](https://anaconda.org/conda-forge/asimov/badges/version.svg)](https://anaconda.org/conda-forge/asimov/)
  ![pypi](https://img.shields.io/pypi/v/asimov.svg)
  ![tests](https://git.ligo.org/asimov/asimov/badges/master/pipeline.svg)

  Asimov was developed to manage and automate the parameter estimation analyses used by the LIGO, Virgo, and KAGRA collaborations to analyse gravitational wave signals, but it aims to provide tools which can be used for other workflows.

  Asimov has been used to organise and run the major catalogue analyses from the third observing run, O3, but it's designed to be flexible enough to allow new pipelines and analyses to be added to the framework.





  Asimov is able to interact with high throughput job management tools, and can submit jobs to clusters, monitor them for problems, and initiate post-processing tasks.



  Asimov provides an API layer which allows a single configuration to be deployed to numerous different analysis pipelines.
  Current gravitational wave pipelines which are supported are ``lalinference``, ``bayeswave``, ``RIFT``, and ``bilby``.



  Asimov records all ongoing, completed, and scheduled analyses, allowing jobs, configurations, and results to be found easily.



  Asimov can provide both machine-readible and human-friendly reports of all jobs it is monitoring, while collating relevant log files and outputs.



  Your results are important, and Asimov provides special tools to help manage the outputs of analyses as well as ensuring their veracity.



  Asimov makes setting-up and running parameter estimation jobs easier.
  It can generate configuration files for several parameter estimation pipelines, and handle submitting these to a cluster.
  Whether you're setting-up a preliminary analysis for a single gravitational wave event, or analysing hundreds of events for a catalog, Asimov can help.



  Asimov is written in Python, and is available on ``pypi``.
  It can be installed by running
  ```
  $ pip install asimov
  ```
  It is also available on conda, and can be installed by running
  ```
  $ conda install -c conda-forge asimov
  ```

  Asimov also requires that you have `git` installed on your machine, and that you've set it up by running:
  ```
  $ git config --global user.email "you@example.com"
  $ git config --global user.name "Your Name"
  ```




  Asimov supports a variety of different ways of running, but the simplest way, running a workflow on a local machine, can be set up with a single command.

  We start by setting up a project, which is a directory which keeps all of the analyses and the required metadata together.
  A project can include just a single event or a whole selection of events, for example if you're producing a catalogue.
  First create a directory to store your project:
  ```
  $ mkdir my-new-project
  $ cd my-new-project
  ```
  and then get asimov to set things up
  ```
  $ asimov init "Test project"
  ```
  where you can replace `"Test project"` with the name you want to give your project.
  A project will be set-up in your current working directory.

  In order to start setting up analyses we next need to download some default settings.

  An analysis is a pipeline run, and asimov supports `bayeswave`, `bilby` in the default installation.

  We'll download the default configurations for jobs which are going to be run on the LIGO data grid.
  We do this using the `asimov apply` command, which pulls-in data from a file either locally or online.

  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/defaults/production-pe.yaml
  ```

  and the load default priors the same way:
  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/defaults/production-pe-priors.yaml
  ```

  Now you can add an existing event, by downloading the event data settings using the `asimov apply` function, for example, to add GW150914 to the project you can run

  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/events/gwtc-2-1/GW150914_095045.yaml
  ```

  This downloads the settings which were used for analysing GW150914 for the GWTC-2.1 catalogue paper, and stores them in the ledger file in the project (`.asimov/ledger.yml`).

  Many analyses can be run on a single event (these are called "productions" in asimov parlence).
  We can add some pre-configured analyses by downloading some analysis configuration settings.

  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/analyses/production-default.yaml -e GW150914_095045
  ```
  Note that if you omit the `-e` argument asimov will ask which event the analyses should be applied to.


  You can now build and submit your jobs to the cluster.
  First use `asimov manage build` to create the configuration files for each analysis:
  ```
  $ asimov manage build
  ```
  These will be added to the git repositories in the `checkouts` directory inside the project directory.
  You then submit the jobs to the cluster by running
  ```
  $ asimov manage submit
  ```

  It will normally take a long time for a parameter estimation job to finish, but you can get asimov to check up on it by running
  ```
  $ asimov monitor
  ```
  If the job is finished `asimov` will start post-processing using `PESummary`, and if it's fallen over it will attempt to fix the problem and resubmit it to the cluster.
  If the post-processing has finished it will move the results to a read-only directory.

  You can also set the asimov monitor to automatically check the status of the job every 15 minutes by running
  ```
  $ asimov start
  ```
  which will automatically start any post-processing, and start any jobs once their dependencies are met.
  You can stop this automatic monitoring process any time by running
  ```
  $ asimov stop
  ```

  For a full description of the workflow management process see the documentation.




  Great! We're always looking for help with developing asimov!
  Please take a look at our [contributors' guide](CONTRIBUTING.rst) to get started!






  While Asimov already supports a large number of pre-existing pipelines, and provides a straightforward interface for adding new pipelines, we also intend to support pipelines constructed using [gravitic](https://github.com/transientlunatic/gravitic), allowing experimental tools to be used without constructing an entire new pipeline, while also allowing asimov to manage the training of machine learning algorithms.




  Asimov will allow an existing workflow to be duplicated, in a similar way to a ``git clone``, and then extended, with new jobs gaining access to the completed jobs in the workflow.
  It will also allow entire workflows to be re-run, providing a straightforward way to replicate results, or make minor modifications.




  Asimov is made by the LIGO, Virgo, and KAGRA collaborations.
  The primary maintainer of the project is Daniel Williams.
  Its development is supported by the Science and Technology Facilities Council.


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

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

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



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



  ```sh

  pip install asktable
  ```



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

  ```python
  from asktable import Asktable

  client = Asktable()

  datasource = client.datasources.create(
      engine="mysql",
  )
  print(datasource.id)
  ```

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



  Simply import `AsyncAsktable` instead of `Asktable` and use `await` with each API call:

  ```python
  import asyncio
  from asktable import AsyncAsktable

  client = AsyncAsktable()


  async def main() -> None:
      datasource = await client.datasources.create(
          engine="mysql",
      )
      print(datasource.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 Asktable 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 asktable import Asktable

  client = Asktable()

  all_datasources = []

  for datasource in client.datasources.list():
      
      all_datasources.append(datasource)
  print(all_datasources)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from asktable import AsyncAsktable

  client = AsyncAsktable()


  async def main() -> None:
      all_datasources = []
      
      async for datasource in client.datasources.list():
          all_datasources.append(datasource)
      print(all_datasources)


  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.datasources.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.items)}")


  ```

  Or just work directly with the returned data:

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

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


  ```



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

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

  All errors inherit from `asktable.APIError`.

  ```python
  import asktable
  from asktable import Asktable

  client = Asktable()

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


  client = Asktable(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).datasources.create(
      engine="mysql",
  )
  ```



  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 asktable import Asktable


  client = Asktable(
      
      timeout=20.0,
  )


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


  client.with_options(timeout=5.0).datasources.create(
      engine="mysql",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

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

  ```shell
  $ export ASKTABLE_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 asktable import Asktable

  client = Asktable()
  response = client.datasources.with_raw_response.create(
      engine="mysql",
  )
  print(response.headers.get('X-My-Header'))

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

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

  The async client returns an [`AsyncAPIResponse`](https://github.com/DataMini/asktable-python/tree/main/src/asktable/_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.datasources.with_streaming_response.create(
      engine="mysql",
  ) 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 asktable import Asktable, DefaultHttpxClient

  client = Asktable(
      
      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/DataMini/asktable-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 asktable
  print(asktable.__version__)
  ```



  Python 3.8 or higher.



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


pkgId: ff23c7f2f1192bbb86a08195393c5e0c65481b101e03721d9cdb2249cb2a9b9e
name: python-asposeslidescloud-help
arch: noarch
version: 24.12.0
epoch: 0
release: 1
summary: Development documents and examples for asposeslidescloud
url: https://pypi.org/project/asposeslidescloud/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-asposeslidescloud-24.12.0-1.src.rpm
location_href: Packages/python-asposeslidescloud-help-24.12.0-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/api-v3.0-lightgrey) ![PyPI](https://img.shields.io/pypi/v/asposeslidescloud) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/asposeslidescloud) ![PyPI - Implementation](https://img.shields.io/pypi/implementation/asposeslidescloud) ![PyPI - Wheel](https://img.shields.io/pypi/wheel/asposeslidescloud) [![GitHub license](https://img.shields.io/github/license/aspose-slides-cloud/aspose-slides-cloud-python)](https://github.com/aspose-slides-cloud/aspose-slides-cloud-python/blob/master/LICENSE)


  This repository contains Aspose.Slides Cloud SDK for Python source code. This SDK allows you to [process & manipulate PPT, PPTX, ODP, OTP](https://products.aspose.cloud/slides/python) using Aspose.slides Cloud REST APIs in your Python applications.

  You may want to check out Aspose free [Powerpoint to PDF](https://products.aspose.app/slides/conversion), [Powerpoint to Word](https://products.aspose.app/slides/conversion/ppt-to-word), [Powerpoint to JPG](https://products.aspose.app/slides/conversion/ppt-to-jpg), [Powerpoint to PNG](https://products.aspose.app/slides/conversion/ppt-to-png), [PDF to Powerpoint](https://products.aspose.app/slides/import/pdf-to-powerpoint), [JPG to Powerpoint](https://products.aspose.app/slides/import/jpg-to-ppt), and [PNG to Powerpoint](https://products.aspose.app/slides/import/png-to-ppt) converters because they are live implementations of popular conversion processes.



  - Fetch presentation images in any of the supported file formats.
  - Copy the layout side or clone the master slide from the source presentation.
  - Process slides shapes, slides notes, placeholders, colors & font theme info.
  - Programmatically create a presentation from HTML & export it to various formats.
  - Merge multiple presentations or split the single presentation into multiple ones.
  - Extract and replace text from a specific slide or an entire presentation.



  **Microsoft PowerPoint:** PPT, PPTX, PPS, PPSX, PPTM, PPSM, POTX, POTM
  **OpenOffice:** ODP, OTP, FODP
  **Other**: PDF, PDF/A



  **Fixed Layout:** XPS
  **Images:** JPEG, PNG, BMP, TIFF, GIF, SVG
  **Web:** HTML/HTML5
  **Other:** MPEG4, SWF (export whole presentations)



  * Added **CompressImage** method. **DeletePictureCroppedAreas** method is deprecated and will be removed after 25.2 release.
  * The **Paragraphs** property of **Shape** class is now a list of **Paragraph** objects instead of ResourceURIs.
  * Added **TileScaleX**, **TileScaleY**, **TileOffsetX**, **TileOffsetY**, **TileAlignment** and **TileFlip** properties to **PictureFill** class.
  * Added **DrawingGuides** property to **CommonSlideViewProperty** class.
  * Added **DeleteEmbeddedBinaryObjects** boolean property to **ExportOptions** class.
  * Added **IncludeOleData** boolean property to **PdfExportOptions** class.
  * Added **GridSpacing** property to **ViewProperties** class.



  * Added **Upload** and **Download** methods to async API. They are identical to **UploadFile** and **DownloadFile** methods of the regular API, but file size is not restricted for them.



  * Added **StartSplit** and **StartUploadAndSplit** methods to async API.
  * Added **ReplacePresentationRegex** and **ReplacePresentationRegexOnline** methods.
  * Added **HighlightPresentationText** and **HighlightPresentationRegex** methods.
  * Added **OperationError** class; changed **Operation**.**Error** property type from string to **OperationError**.
  * Removed **wholeWordsOnly** parameter from **ReplaceShapeRegex** method.



  * Added **TemplatesPath** property to **Html5ExportOptions** class. It enables using custom templates in conversion to Html5 format.
  * Added **GetHtml5Templates** method to retrieve the list of default Html5 templates.
  * Added **Xml** to the list of available export formats.
  * Added **wholeWordsOnly** parameter to **ReplacePresentationText** and  **ReplacePresentationTextOnline** methods.
  * Added **GradientStyle** property to **ExportOptions** class.
  * Added **ResterizeUnsupportedFontStyles** property to **PdfExportOptions** class.
  * Added **Zip64Mode** property to **PptxExportOptions** class.
  * Added **Transparency** property to **Table** and **TableCell** class.
  * Removed obsolete **DownloadPortionsAsMathML**, **SavePortionsAsMathML** methods. Use **DownloadMathPortion** and **SaveMathPortion** methods to convert portions to math formats.



  * Added **HideInk** and **InterpretMaskOpAsOpacity** properties to **PdfExportOptions** class.
  * Removed **Enqueued** from the list of allowed values for **Operation.Status** property.



  * Added **options** parameter to **ImportFromPdf** method. You can specify **options.DetectTables** property to control import behavior.
  * Added **Title** property to **Axis** class for charts.
  * Added **X**, **Y**, **Width**, **Height**, **Overlay**, **FillFormat**, **EffectFormat** and **LineFormat** properties to **ChartTitle** class.
  * Added **HasTitle** property to **Chart** class; removed **HasTitle** property from **ChartTitle** class.



  * Added **DownloadMathPortion** and **SaveMathPortion** methods to convert math portions to math markup formats (MathML or LaTeX). See [documentation](https://docs.aspose.cloud/slides/export-a-math-formula/) for more info. **DownloadPortionAsMathML** and **SavePortionAsMathML** methods are deprecated and will be removed after 24.6.
  * Added **Marker** property to **DataPoint** class.



  * Added Markdown (**Md**) to the list of allowed export formats.
  * Added **DeletePictureCroppedAreas** method to delete cropped areas of pictures.
  * Added **SlidesLayoutOptions** property to **PdfExportOptions**, **HtmlExportOptions**, **TiffExportOptions** and **ImageExportOptions** classes. You can use it to specify handout or notes/comments layouting options.
  * Added **AnimateTextType** enum property to **Effect** class.
  * Added **NotesCommentsLayouting** property to **Html5ExportOptions** class.
  * Added **BwConversionMode** property to **TiffExportOptions** class.
  * Added **EmbedImages** boolean property to **Html5ExportOptions** class.
  * Added **ShowMediaControls** boolean property to **SlideShowProperties** class.
  * Added **IsDecorative** boolean property to **ShapeBase** class.




  * Added **GetCommentAuthors** method to get list of comment authors.



  * Added **GetAvailableFonts** method to get list of installed system & custom fonts.


  All Aspose.Slides Cloud SDKs are licensed under MIT License.


  The complete source code is available in this repository folder. You can either directly use it in your project via source code or get [PuPi module](https://pypi.org/project/asposeslidescloud) (recommended).


  To use Aspose Slides Cloud SDK for Python you need to register an account with [Aspose Cloud](https://www.aspose.cloud/) and lookup/create App Key and SID at [Cloud Dashboard](https://dashboard.aspose.cloud/#/apps). There is free quota available. For more details, see [Aspose Cloud Pricing](https://purchase.aspose.cloud/pricing).



  ```sh
  python -m pip install asposeslidescloud
  ```



  The example code below converts a PowerPoint document to PDF format using asposeslidescloud library:
  ```python
  	import asposeslidescloud

  	from asposeslidescloud.configuration import Configuration
  	from asposeslidescloud.apis.slides_api import SlidesApi
  	from asposeslidescloud.models.export_format import ExportFormat

  	configuration = Configuration()
  	configuration.app_sid = 'MyClientId'
  	configuration.app_key = 'MyClientSecret'
  	api = SlidesApi(configuration)

  	with open("MyPresentation.pptx", 'rb') as f:
  		document = f.read()

  	response = api.convert(document, ExportFormat.PDF)
  	print('My PDF was saved to ' + response)
  ```

  You can check more [Examples](Examples) of using the SDK.



  | .NET | Java | PHP | Python | Ruby | Node.js | Android | Swift|Perl|Go|
  |---|---|---|---|---|---|---|--|--|--|
  | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-dotnet) | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-java) | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-php) | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-python) | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-ruby)  | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-nodejs) | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-android) | [GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-swift)|[GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-perl) |[GitHub](https://github.com/aspose-slides-cloud/aspose-slides-cloud-go) |
  | [NuGet](https://www.nuget.org/packages/Aspose.slides-Cloud/) | [Maven](https://repository.aspose.cloud/webapp/#/artifacts/browse/tree/General/repo/com/aspose/aspose-slides-cloud) | [Composer](https://packagist.org/packages/aspose/slides-sdk-php) | [PIP](https://pypi.org/project/asposeslidescloud/) | [GEM](https://rubygems.org/gems/aspose_slides_cloud)  | [NPM](https://www.npmjs.com/package/asposeslidescloud) | [Maven](https://repository.aspose.cloud/webapp/#/artifacts/browse/tree/General/repo/com/aspose/aspose-slides-cloud) | [Cocoapods](https://cocoapods.org/pods/AsposeslidesCloud)|[Meta Cpan](https://metacpan.org/release/AsposeSlidesCloud-SlidesApi) | [Go.Dev](https://pkg.go.dev/github.com/aspose-slides-cloud/aspose-slides-cloud-go/) |

  [Product Page](https://products.aspose.cloud/slides/python) | [Documentation](https://docs.aspose.cloud/display/slidescloud/Home) | [API Reference](https://apireference.aspose.cloud/slides/) | [Code Samples](https://github.com/aspose-slides-cloud/aspose-slides-cloud-python) | [Blog](https://blog.aspose.cloud/category/slides/) | [Free Support](https://forum.aspose.cloud/c/slides) | [Free Trial](https://dashboard.aspose.cloud/#/apps)


pkgId: bb11a2d440d1988f59edf977ece2f1db3959f64abc6d26d0652ae71b0756074d
name: python-asreview-help
arch: noarch
version: 1.6.3
epoch: 0
release: 1
summary: Development documents and examples for asreview
url: https://github.com/asreview/asreview
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-asreview-1.6.3-1.src.rpm
location_href: Packages/python-asreview-help-1.6.3-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/asreview/asreview">
      <img width="60%" height="60%" src="https://raw.githubusercontent.com/asreview/asreview-artwork/master/LogoASReview/SVG/GitHub_Repo_Card_Transparent.svg">
    </a>
  </p>



  [![PyPI version](https://badge.fury.io/py/asreview.svg)](https://badge.fury.io/py/asreview) [![Documentation Status](https://readthedocs.org/projects/asreview/badge/?version=latest)](https://asreview.readthedocs.io/en/latest/?badge=latest) [![DOI](https://zenodo.org/badge/164874894.svg)](https://zenodo.org/badge/latestdoi/164874894)
   [![Downloads](https://static.pepy.tech/badge/asreview)](https://github.com/asreview/asreview#installation) [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4755/badge)](https://bestpractices.coreinfrastructure.org/projects/4755)

  Systematically screening large amounts of textual data is time-consuming and
  often tiresome. The rapidly evolving field of Artificial Intelligence (AI) has
  allowed the development of AI-aided pipelines that assist in finding relevant
  texts for search tasks. A well-established approach to increasing efficiency
  is screening prioritization via [Active
  Learning](https://asreview.readthedocs.io/en/latest/guides/activelearning.html).

  The Active learning for Systematic Reviews (ASReview) project, published in
  [*Nature Machine Intelligence*](https://doi.org/10.1038/s42256-020-00287-7)
  implements different machine learning algorithms that interactively query the
  researcher. ASReview LAB  is designed to accelerate the step of screening
  textual data with a minimum of records to be read by a human with no or very
  few false negatives. ASReview LAB will save time, increase the quality of
  output and strengthen the transparency of work when screening large amounts of
  textual data to retrieve relevant information. Active Learning will support
  decision-making in any discipline or industry.

  ASReview software implements three different modes:

  - **Oracle**  Screen textual data in
    interaction with the active learning model. The reviewer is the 'oracle',
    making the labeling decisions.
  - **Exploration**  Explore or
    demonstrate ASReview LAB with a completely labeled dataset. This mode is
    suitable for teaching purposes.
  - **Simulation**  Evaluate
    the performance of active learning models on fully labeled data. Simulations
    can be run in ASReview LAB or via the command line interface with more
    advanced options.




  The ASReview software requires Python 3.8 or later. Detailed step-by-step
  instructions to install Python and ASReview are available for
  [Windows](https://asreview.ai/installation-guide-windows/) and
  [macOS](https://asreview.ai/installation-guide-macos/) users.

  ```bash
  pip install asreview
  ```

  Upgrade ASReview with the following command:

  ```bash
  pip install --upgrade asreview
  ```

  To install ASReview LAB with Docker, see [Install with Docker](https://asreview.readthedocs.io/en/latest/installation.html).



  [![ASReview LAB explained - animation](https://img.youtube.com/vi/k-a2SCq-LtA/0.jpg)](https://www.youtube.com/watch?v=k-a2SCq-LtA)




  [Getting Started with ASReview
  LAB](https://asreview.readthedocs.io/en/latest/about.html).

  [![ASReview LAB](https://github.com/asreview/asreview/blob/master/images/ASReviewWebApp.png?raw=true)](https://asreview.readthedocs.io/en/latest/lab/overview_lab.html "ASReview LAB")



  If you wish to cite the underlying methodology of the ASReview software,
  please use the following publication in Nature Machine Intelligence:

  > van de Schoot, R., de Bruin, J., Schram, R. et al. An open source machine
    learning framework for efficient and transparent systematic reviews.
    Nat Mach Intell 3, 125–133 (2021). https://doi.org/10.1038/s42256-020-00287-7

  For citing the software, please refer to the specific release of
  the ASReview software on Zenodo https://doi.org/10.5281/zenodo.3345592. The menu on the
  right can be used to find the citation format of prevalence.

  For more scientific publications on the ASReview software, go to
  [asreview.ai/papers](https://asreview.ai/papers/).



  For an overview of the team working on ASReview, see [ASReview Research Team](https://asreview.ai/about).
  ASReview LAB is maintained by
  [Jonathan de Bruin](https://github.com/J535D165) and [Yongchao Terry Ma](https://github.com/terrymyc).

  The best resources to find an answer to your question or ways to get in
  contact with the team are:

  - Documentation - [asreview.readthedocs.io](https://asreview.readthedocs.io/)
  - Newsletter - [asreview.ai/newsletter/subscribe](https://asreview.ai/newsletter/subscribe)
  - Quick tour - [ASReview LAB quick tour](https://asreview.readthedocs.io/en/latest/lab/overview_lab.html)
  - Issues or feature requests - [ASReview issue tracker](https://github.com/asreview/asreview/issues)
  - FAQ - [ASReview Discussions](https://github.com/asreview/asreview/discussions?discussions_q=sort%3Atop)
  - Donation - [asreview.ai/donate](https://asreview.ai/donate)
  - Contact - [asreview@uu.nl](mailto:asreview@uu.nl)



  The ASReview software has an Apache 2.0 [LICENSE](LICENSE). The ASReview team
  accepts no responsibility or liability for the use of the ASReview tool or any
  direct or indirect damages arising out of the application of the tool.


pkgId: d8b9af6e9e662e608c5308dce30b795e1c494a7cbe2905f4d3fa215b11b670da
name: python-assemblyline-core-help
arch: noarch
version: 4.5.0.67
epoch: 0
release: 1
summary: Development documents and examples for assemblyline-core
url: https://github.com/CybercentreCanada/assemblyline-core/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-assemblyline-core-4.5.0.67-1.src.rpm
location_href: Packages/python-assemblyline-core-help-4.5.0.67-1.noarch.rpm
checksum_type: sha256
description:
  This repository provides cores services for Assemblyline 4.





  Create alerts for the different submissions in the system.



  Route the files in the system while a submission is tacking place. Make sure all files during a submission are completed by all required services.



  Delete submissions and their results when their TTL expires.



  Move ingested files from the priority queues to the processing queues.



  Generates metrics of the different components in the system.



  Spin up and down services in the system depending on the load.



  Make sure the different services get their latest update files.



  Run the different workflows in the system and apply their labels, priority and status.


pkgId: 3c00a9c888342af611a11fddaf6728871af5515bbf595477e3db53485b85d7c4
name: python-assisted-service-client-help
arch: noarch
version: 2.36.0.post62
epoch: 0
release: 1
summary: Development documents and examples for assisted-service-client
url: https://github.com/openshift/assisted-service
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-assisted-service-client-2.36.0.post62-1.src.rpm
location_href: Packages/python-assisted-service-client-help-2.36.0.post62-1.noarch.rpm
checksum_type: sha256
description:
  *EventsApi* | [**v2_list_events**](docs/EventsApi.md#v2_list_events) | **GET** /v2/events |
  *EventsApi* | [**v2_trigger_event**](docs/EventsApi.md#v2_trigger_event) | **POST** /v2/events |
  *InstallerApi* | [**bind_host**](docs/InstallerApi.md#bind_host) | **POST** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/actions/bind |
  *InstallerApi* | [**deregister_infra_env**](docs/InstallerApi.md#deregister_infra_env) | **DELETE** /v2/infra-envs/{infra_env_id} |
  *InstallerApi* | [**download_minimal_initrd**](docs/InstallerApi.md#download_minimal_initrd) | **GET** /v2/infra-envs/{infra_env_id}/downloads/minimal-initrd |
  *InstallerApi* | [**get_cluster_supported_platforms**](docs/InstallerApi.md#get_cluster_supported_platforms) | **GET** /v2/clusters/{cluster_id}/supported-platforms |
  *InstallerApi* | [**get_infra_env**](docs/InstallerApi.md#get_infra_env) | **GET** /v2/infra-envs/{infra_env_id} |
  *InstallerApi* | [**get_infra_env_download_url**](docs/InstallerApi.md#get_infra_env_download_url) | **GET** /v2/infra-envs/{infra_env_id}/downloads/image-url |
  *InstallerApi* | [**get_infra_env_presigned_file_url**](docs/InstallerApi.md#get_infra_env_presigned_file_url) | **GET** /v2/infra-envs/{infra_env_id}/downloads/files-presigned |
  *InstallerApi* | [**get_supported_architectures**](docs/InstallerApi.md#get_supported_architectures) | **GET** /v2/support-levels/architectures |
  *InstallerApi* | [**get_supported_features**](docs/InstallerApi.md#get_supported_features) | **GET** /v2/support-levels/features |
  *InstallerApi* | [**list_cluster_hosts**](docs/InstallerApi.md#list_cluster_hosts) | **GET** /v2/clusters/{cluster_id}/hosts |
  *InstallerApi* | [**list_infra_envs**](docs/InstallerApi.md#list_infra_envs) | **GET** /v2/infra-envs |
  *InstallerApi* | [**regenerate_infra_env_signing_key**](docs/InstallerApi.md#regenerate_infra_env_signing_key) | **POST** /v2/infra-envs/{infra_env_id}/regenerate-signing-key |
  *InstallerApi* | [**register_infra_env**](docs/InstallerApi.md#register_infra_env) | **POST** /v2/infra-envs |
  *InstallerApi* | [**transform_cluster_to_adding_hosts**](docs/InstallerApi.md#transform_cluster_to_adding_hosts) | **POST** /v2/clusters/{cluster_id}/actions/allow-add-hosts |
  *InstallerApi* | [**transform_cluster_to_day2**](docs/InstallerApi.md#transform_cluster_to_day2) | **POST** /v2/clusters/{cluster_id}/actions/allow-add-workers |
  *InstallerApi* | [**unbind_host**](docs/InstallerApi.md#unbind_host) | **POST** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/actions/unbind |
  *InstallerApi* | [**update_infra_env**](docs/InstallerApi.md#update_infra_env) | **PATCH** /v2/infra-envs/{infra_env_id} |
  *InstallerApi* | [**v2_cancel_installation**](docs/InstallerApi.md#v2_cancel_installation) | **POST** /v2/clusters/{cluster_id}/actions/cancel |
  *InstallerApi* | [**v2_complete_installation**](docs/InstallerApi.md#v2_complete_installation) | **POST** /v2/clusters/{cluster_id}/actions/complete-installation |
  *InstallerApi* | [**v2_deregister_cluster**](docs/InstallerApi.md#v2_deregister_cluster) | **DELETE** /v2/clusters/{cluster_id} |
  *InstallerApi* | [**v2_deregister_host**](docs/InstallerApi.md#v2_deregister_host) | **DELETE** /v2/infra-envs/{infra_env_id}/hosts/{host_id} |
  *InstallerApi* | [**v2_download_cluster_credentials**](docs/InstallerApi.md#v2_download_cluster_credentials) | **GET** /v2/clusters/{cluster_id}/downloads/credentials |
  *InstallerApi* | [**v2_download_cluster_files**](docs/InstallerApi.md#v2_download_cluster_files) | **GET** /v2/clusters/{cluster_id}/downloads/files |
  *InstallerApi* | [**v2_download_cluster_logs**](docs/InstallerApi.md#v2_download_cluster_logs) | **GET** /v2/clusters/{cluster_id}/logs |
  *InstallerApi* | [**v2_download_host_ignition**](docs/InstallerApi.md#v2_download_host_ignition) | **GET** /v2/infra-env/{infra_env_id}/hosts/{host_id}/downloads/ignition |
  *InstallerApi* | [**v2_download_infra_env_files**](docs/InstallerApi.md#v2_download_infra_env_files) | **GET** /v2/infra-envs/{infra_env_id}/downloads/files |
  *InstallerApi* | [**v2_get_cluster**](docs/InstallerApi.md#v2_get_cluster) | **GET** /v2/clusters/{cluster_id} |
  *InstallerApi* | [**v2_get_cluster_default_config**](docs/InstallerApi.md#v2_get_cluster_default_config) | **GET** /v2/clusters/default-config |
  *InstallerApi* | [**v2_get_cluster_install_config**](docs/InstallerApi.md#v2_get_cluster_install_config) | **GET** /v2/clusters/{cluster_id}/install-config |
  *InstallerApi* | [**v2_get_cluster_ui_settings**](docs/InstallerApi.md#v2_get_cluster_ui_settings) | **GET** /v2/clusters/{cluster_id}/ui-settings |
  *InstallerApi* | [**v2_get_credentials**](docs/InstallerApi.md#v2_get_credentials) | **GET** /v2/clusters/{cluster_id}/credentials |
  *InstallerApi* | [**v2_get_host**](docs/InstallerApi.md#v2_get_host) | **GET** /v2/infra-envs/{infra_env_id}/hosts/{host_id} |
  *InstallerApi* | [**v2_get_host_ignition**](docs/InstallerApi.md#v2_get_host_ignition) | **GET** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/ignition |
  *InstallerApi* | [**v2_get_ignored_validations**](docs/InstallerApi.md#v2_get_ignored_validations) | **GET** /v2/clusters/{cluster_id}/ignored-validations |
  *InstallerApi* | [**v2_get_next_steps**](docs/InstallerApi.md#v2_get_next_steps) | **GET** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/instructions |
  *InstallerApi* | [**v2_get_preflight_requirements**](docs/InstallerApi.md#v2_get_preflight_requirements) | **GET** /v2/clusters/{cluster_id}/preflight-requirements |
  *InstallerApi* | [**v2_get_presigned_for_cluster_credentials**](docs/InstallerApi.md#v2_get_presigned_for_cluster_credentials) | **GET** /v2/clusters/{cluster_id}/downloads/credentials-presigned |
  *InstallerApi* | [**v2_get_presigned_for_cluster_files**](docs/InstallerApi.md#v2_get_presigned_for_cluster_files) | **GET** /v2/clusters/{cluster_id}/downloads/files-presigned |
  *InstallerApi* | [**v2_import_cluster**](docs/InstallerApi.md#v2_import_cluster) | **POST** /v2/clusters/import |
  *InstallerApi* | [**v2_install_cluster**](docs/InstallerApi.md#v2_install_cluster) | **POST** /v2/clusters/{cluster_id}/actions/install |
  *InstallerApi* | [**v2_install_host**](docs/InstallerApi.md#v2_install_host) | **POST** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/actions/install |
  *InstallerApi* | [**v2_list_clusters**](docs/InstallerApi.md#v2_list_clusters) | **GET** /v2/clusters |
  *InstallerApi* | [**v2_list_hosts**](docs/InstallerApi.md#v2_list_hosts) | **GET** /v2/infra-envs/{infra_env_id}/hosts |
  *InstallerApi* | [**v2_list_of_cluster_operators**](docs/InstallerApi.md#v2_list_of_cluster_operators) | **GET** /v2/clusters/{cluster_id}/monitored-operators |
  *InstallerApi* | [**v2_post_step_reply**](docs/InstallerApi.md#v2_post_step_reply) | **POST** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/instructions |
  *InstallerApi* | [**v2_register_cluster**](docs/InstallerApi.md#v2_register_cluster) | **POST** /v2/clusters |
  *InstallerApi* | [**v2_register_host**](docs/InstallerApi.md#v2_register_host) | **POST** /v2/infra-envs/{infra_env_id}/hosts |
  *InstallerApi* | [**v2_report_monitored_operator_status**](docs/InstallerApi.md#v2_report_monitored_operator_status) | **PUT** /v2/clusters/{cluster_id}/monitored-operators |
  *InstallerApi* | [**v2_reset_cluster**](docs/InstallerApi.md#v2_reset_cluster) | **POST** /v2/clusters/{cluster_id}/actions/reset |
  *InstallerApi* | [**v2_reset_host**](docs/InstallerApi.md#v2_reset_host) | **POST** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/actions/reset |
  *InstallerApi* | [**v2_reset_host_validation**](docs/InstallerApi.md#v2_reset_host_validation) | **PATCH** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/actions/reset-validation/{validation_id} | Reset failed host validation.
  *InstallerApi* | [**v2_set_ignored_validations**](docs/InstallerApi.md#v2_set_ignored_validations) | **PUT** /v2/clusters/{cluster_id}/ignored-validations |
  *InstallerApi* | [**v2_update_cluster**](docs/InstallerApi.md#v2_update_cluster) | **PATCH** /v2/clusters/{cluster_id} |
  *InstallerApi* | [**v2_update_cluster_finalizing_progress**](docs/InstallerApi.md#v2_update_cluster_finalizing_progress) | **PUT** /v2/clusters/{cluster_id}/progress |
  *InstallerApi* | [**v2_update_cluster_install_config**](docs/InstallerApi.md#v2_update_cluster_install_config) | **PATCH** /v2/clusters/{cluster_id}/install-config |
  *InstallerApi* | [**v2_update_cluster_logs_progress**](docs/InstallerApi.md#v2_update_cluster_logs_progress) | **PUT** /v2/clusters/{cluster_id}/logs-progress |
  *InstallerApi* | [**v2_update_cluster_ui_settings**](docs/InstallerApi.md#v2_update_cluster_ui_settings) | **PUT** /v2/clusters/{cluster_id}/ui-settings |
  *InstallerApi* | [**v2_update_host**](docs/InstallerApi.md#v2_update_host) | **PATCH** /v2/infra-envs/{infra_env_id}/hosts/{host_id} |
  *InstallerApi* | [**v2_update_host_ignition**](docs/InstallerApi.md#v2_update_host_ignition) | **PATCH** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/ignition |
  *InstallerApi* | [**v2_update_host_install_progress**](docs/InstallerApi.md#v2_update_host_install_progress) | **PUT** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/progress |
  *InstallerApi* | [**v2_update_host_installer_args**](docs/InstallerApi.md#v2_update_host_installer_args) | **PATCH** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/installer-args |
  *InstallerApi* | [**v2_update_host_logs_progress**](docs/InstallerApi.md#v2_update_host_logs_progress) | **PUT** /v2/infra-envs/{infra_env_id}/hosts/{host_id}/logs-progress |
  *InstallerApi* | [**v2_upload_cluster_ingress_cert**](docs/InstallerApi.md#v2_upload_cluster_ingress_cert) | **POST** /v2/clusters/{cluster_id}/uploads/ingress-cert |
  *InstallerApi* | [**v2_upload_logs**](docs/InstallerApi.md#v2_upload_logs) | **POST** /v2/clusters/{cluster_id}/logs |
  *ManagedDomainsApi* | [**v2_list_managed_domains**](docs/ManagedDomainsApi.md#v2_list_managed_domains) | **GET** /v2/domains |
  *ManifestsApi* | [**v2_create_cluster_manifest**](docs/ManifestsApi.md#v2_create_cluster_manifest) | **POST** /v2/clusters/{cluster_id}/manifests |
  *ManifestsApi* | [**v2_delete_cluster_manifest**](docs/ManifestsApi.md#v2_delete_cluster_manifest) | **DELETE** /v2/clusters/{cluster_id}/manifests |
  *ManifestsApi* | [**v2_download_cluster_manifest**](docs/ManifestsApi.md#v2_download_cluster_manifest) | **GET** /v2/clusters/{cluster_id}/manifests/files |
  *ManifestsApi* | [**v2_list_cluster_manifests**](docs/ManifestsApi.md#v2_list_cluster_manifests) | **GET** /v2/clusters/{cluster_id}/manifests |
  *ManifestsApi* | [**v2_update_cluster_manifest**](docs/ManifestsApi.md#v2_update_cluster_manifest) | **PATCH** /v2/clusters/{cluster_id}/manifests |
  *OperatorsApi* | [**v2_list_of_cluster_operators**](docs/OperatorsApi.md#v2_list_of_cluster_operators) | **GET** /v2/clusters/{cluster_id}/monitored-operators |
  *OperatorsApi* | [**v2_list_operator_properties**](docs/OperatorsApi.md#v2_list_operator_properties) | **GET** /v2/supported-operators/{operator_name} |
  *OperatorsApi* | [**v2_list_supported_operators**](docs/OperatorsApi.md#v2_list_supported_operators) | **GET** /v2/supported-operators |
  *OperatorsApi* | [**v2_report_monitored_operator_status**](docs/OperatorsApi.md#v2_report_monitored_operator_status) | **PUT** /v2/clusters/{cluster_id}/monitored-operators |
  *VersionsApi* | [**v2_list_component_versions**](docs/VersionsApi.md#v2_list_component_versions) | **GET** /v2/component-versions |
  *VersionsApi* | [**v2_list_release_sources**](docs/VersionsApi.md#v2_list_release_sources) | **GET** /v2/release-sources |
  *VersionsApi* | [**v2_list_supported_openshift_versions**](docs/VersionsApi.md#v2_list_supported_openshift_versions) | **GET** /v2/openshift-versions |

   - [ApiVip](docs/ApiVip.md)
   - [ApiVipConnectivityAdditionalRequestHeader](docs/ApiVipConnectivityAdditionalRequestHeader.md)
   - [ApiVipConnectivityRequest](docs/ApiVipConnectivityRequest.md)
   - [ApiVipConnectivityResponse](docs/ApiVipConnectivityResponse.md)
   - [ArchitectureSupportLevelId](docs/ArchitectureSupportLevelId.md)
   - [BindHostParams](docs/BindHostParams.md)
   - [Boot](docs/Boot.md)
   - [Cluster](docs/Cluster.md)
   - [ClusterCreateParams](docs/ClusterCreateParams.md)
   - [ClusterDefaultConfig](docs/ClusterDefaultConfig.md)
   - [ClusterFinalizingProgress](docs/ClusterFinalizingProgress.md)
   - [ClusterHostRequirements](docs/ClusterHostRequirements.md)
   - [ClusterHostRequirementsDetails](docs/ClusterHostRequirementsDetails.md)
   - [ClusterHostRequirementsList](docs/ClusterHostRequirementsList.md)
   - [ClusterList](docs/ClusterList.md)
   - [ClusterNetwork](docs/ClusterNetwork.md)
   - [ClusterProgressInfo](docs/ClusterProgressInfo.md)
   - [ClusterValidationId](docs/ClusterValidationId.md)
   - [CompletionParams](docs/CompletionParams.md)
   - [ConnectivityCheckHost](docs/ConnectivityCheckHost.md)
   - [ConnectivityCheckNic](docs/ConnectivityCheckNic.md)
   - [ConnectivityCheckParams](docs/ConnectivityCheckParams.md)
   - [ConnectivityRemoteHost](docs/ConnectivityRemoteHost.md)
   - [ConnectivityReport](docs/ConnectivityReport.md)
   - [ContainerImageAvailability](docs/ContainerImageAvailability.md)
   - [ContainerImageAvailabilityRequest](docs/ContainerImageAvailabilityRequest.md)
   - [ContainerImageAvailabilityResponse](docs/ContainerImageAvailabilityResponse.md)
   - [ContainerImageAvailabilityResult](docs/ContainerImageAvailabilityResult.md)
   - [Cpu](docs/Cpu.md)
   - [CreateManifestParams](docs/CreateManifestParams.md)
   - [Credentials](docs/Credentials.md)
   - [DhcpAllocationRequest](docs/DhcpAllocationRequest.md)
   - [DhcpAllocationResponse](docs/DhcpAllocationResponse.md)
   - [Disk](docs/Disk.md)
   - [DiskConfigParams](docs/DiskConfigParams.md)
   - [DiskEncryption](docs/DiskEncryption.md)
   - [DiskInfo](docs/DiskInfo.md)
   - [DiskInstallationEligibility](docs/DiskInstallationEligibility.md)
   - [DiskRole](docs/DiskRole.md)
   - [DiskSkipFormattingParams](docs/DiskSkipFormattingParams.md)
   - [DiskSpeed](docs/DiskSpeed.md)
   - [DiskSpeedCheckRequest](docs/DiskSpeedCheckRequest.md)
   - [DiskSpeedCheckResponse](docs/DiskSpeedCheckResponse.md)
   - [DomainResolutionRequest](docs/DomainResolutionRequest.md)
   - [DomainResolutionResponse](docs/DomainResolutionResponse.md)
   - [DomainResolutionResponseResolutions](docs/DomainResolutionResponseResolutions.md)
   - [DownloadBootArtifactsRequest](docs/DownloadBootArtifactsRequest.md)
   - [DriveType](docs/DriveType.md)
   - [Error](docs/Error.md)
   - [Event](docs/Event.md)
   - [EventList](docs/EventList.md)
   - [FeatureSupportLevelId](docs/FeatureSupportLevelId.md)
   - [FinalizingStage](docs/FinalizingStage.md)
   - [FreeAddressesList](docs/FreeAddressesList.md)
   - [FreeAddressesRequest](docs/FreeAddressesRequest.md)
   - [FreeNetworkAddresses](docs/FreeNetworkAddresses.md)
   - [FreeNetworksAddresses](docs/FreeNetworksAddresses.md)
   - [Gpu](docs/Gpu.md)
   - [Host](docs/Host.md)
   - [HostCreateParams](docs/HostCreateParams.md)
   - [HostIgnitionParams](docs/HostIgnitionParams.md)
   - [HostList](docs/HostList.md)
   - [HostNetwork](docs/HostNetwork.md)
   - [HostProgress](docs/HostProgress.md)
   - [HostProgressInfo](docs/HostProgressInfo.md)
   - [HostRegistrationResponse](docs/HostRegistrationResponse.md)
   - [HostRegistrationResponseNextStepRunnerCommand](docs/HostRegistrationResponseNextStepRunnerCommand.md)
   - [HostRole](docs/HostRole.md)
   - [HostRoleUpdateParams](docs/HostRoleUpdateParams.md)
   - [HostStage](docs/HostStage.md)
   - [HostStaticNetworkConfig](docs/HostStaticNetworkConfig.md)
   - [HostTypeHardwareRequirements](docs/HostTypeHardwareRequirements.md)
   - [HostTypeHardwareRequirementsWrapper](docs/HostTypeHardwareRequirementsWrapper.md)
   - [HostUpdateParams](docs/HostUpdateParams.md)
   - [HostValidationId](docs/HostValidationId.md)
   - [IgnitionEndpoint](docs/IgnitionEndpoint.md)
   - [IgnitionEndpointHttpHeadersParams](docs/IgnitionEndpointHttpHeadersParams.md)
   - [IgnoredValidations](docs/IgnoredValidations.md)
   - [ImageCreateParams](docs/ImageCreateParams.md)
   - [ImageInfo](docs/ImageInfo.md)
   - [ImageType](docs/ImageType.md)
   - [ImportClusterParams](docs/ImportClusterParams.md)
   - [InfraEnv](docs/InfraEnv.md)
   - [InfraEnvCreateParams](docs/InfraEnvCreateParams.md)
   - [InfraEnvList](docs/InfraEnvList.md)
   - [InfraEnvUpdateParams](docs/InfraEnvUpdateParams.md)
   - [InfraError](docs/InfraError.md)
   - [IngressCertParams](docs/IngressCertParams.md)
   - [IngressVip](docs/IngressVip.md)
   - [InlineResponse200](docs/InlineResponse200.md)
   - [InlineResponse2001](docs/InlineResponse2001.md)
   - [InstallCmdRequest](docs/InstallCmdRequest.md)
   - [InstallerArgsParams](docs/InstallerArgsParams.md)
   - [Interface](docs/Interface.md)
   - [Inventory](docs/Inventory.md)
   - [IoPerf](docs/IoPerf.md)
   - [Ip](docs/Ip.md)
   - [Iscsi](docs/Iscsi.md)
   - [KernelArgument](docs/KernelArgument.md)
   - [KernelArguments](docs/KernelArguments.md)
   - [L2Connectivity](docs/L2Connectivity.md)
   - [L3Connectivity](docs/L3Connectivity.md)
   - [LastInstallationPreparation](docs/LastInstallationPreparation.md)
   - [ListManagedDomains](docs/ListManagedDomains.md)
   - [ListManifests](docs/ListManifests.md)
   - [ListVersions](docs/ListVersions.md)
   - [LogsGatherCmdRequest](docs/LogsGatherCmdRequest.md)
   - [LogsProgressParams](docs/LogsProgressParams.md)
   - [LogsState](docs/LogsState.md)
   - [LogsType](docs/LogsType.md)
   - [MacInterfaceMap](docs/MacInterfaceMap.md)
   - [MacInterfaceMapInner](docs/MacInterfaceMapInner.md)
   - [MachineNetwork](docs/MachineNetwork.md)
   - [ManagedDomain](docs/ManagedDomain.md)
   - [Manifest](docs/Manifest.md)
   - [Memory](docs/Memory.md)
   - [MemoryMethod](docs/MemoryMethod.md)
   - [MonitoredOperator](docs/MonitoredOperator.md)
   - [MonitoredOperatorsList](docs/MonitoredOperatorsList.md)
   - [MtuReport](docs/MtuReport.md)
   - [NextStepCmdRequest](docs/NextStepCmdRequest.md)
   - [NodeLabelParams](docs/NodeLabelParams.md)
   - [NtpSource](docs/NtpSource.md)
   - [NtpSynchronizationRequest](docs/NtpSynchronizationRequest.md)
   - [NtpSynchronizationResponse](docs/NtpSynchronizationResponse.md)
   - [OpenshiftVersion](docs/OpenshiftVersion.md)
   - [OpenshiftVersions](docs/OpenshiftVersions.md)
   - [OperatorCreateParams](docs/OperatorCreateParams.md)
   - [OperatorHardwareRequirements](docs/OperatorHardwareRequirements.md)
   - [OperatorHostRequirements](docs/OperatorHostRequirements.md)
   - [OperatorMonitorReport](docs/OperatorMonitorReport.md)
   - [OperatorProperties](docs/OperatorProperties.md)
   - [OperatorProperty](docs/OperatorProperty.md)
   - [OperatorStatus](docs/OperatorStatus.md)
   - [OperatorType](docs/OperatorType.md)
   - [OsImage](docs/OsImage.md)
   - [OsImages](docs/OsImages.md)
   - [Platform](docs/Platform.md)
   - [PlatformExternal](docs/PlatformExternal.md)
   - [PlatformType](docs/PlatformType.md)
   - [PreflightHardwareRequirements](docs/PreflightHardwareRequirements.md)
   - [PresignedUrl](docs/PresignedUrl.md)
   - [Proxy](docs/Proxy.md)
   - [RebootForReclaimRequest](docs/RebootForReclaimRequest.md)
   - [ReleaseChannel](docs/ReleaseChannel.md)
   - [ReleaseImage](docs/ReleaseImage.md)
   - [ReleaseImages](docs/ReleaseImages.md)
   - [ReleaseSource](docs/ReleaseSource.md)
   - [ReleaseSources](docs/ReleaseSources.md)
   - [Route](docs/Route.md)
   - [SecureBootState](docs/SecureBootState.md)
   - [ServiceNetwork](docs/ServiceNetwork.md)
   - [SourceState](docs/SourceState.md)
   - [Step](docs/Step.md)
   - [StepReply](docs/StepReply.md)
   - [StepType](docs/StepType.md)
   - [Steps](docs/Steps.md)
   - [StepsReply](docs/StepsReply.md)
   - [Subnet](docs/Subnet.md)
   - [SupportLevel](docs/SupportLevel.md)
   - [SupportLevels](docs/SupportLevels.md)
   - [SystemVendor](docs/SystemVendor.md)
   - [TangConnectivityRequest](docs/TangConnectivityRequest.md)
   - [TangConnectivityResponse](docs/TangConnectivityResponse.md)
   - [TangConnectivityResponseSignatures](docs/TangConnectivityResponseSignatures.md)
   - [TangConnectivityResponseTangServerResponse](docs/TangConnectivityResponseTangServerResponse.md)
   - [UpdateManifestParams](docs/UpdateManifestParams.md)
   - [UpgradeAgentRequest](docs/UpgradeAgentRequest.md)
   - [UpgradeAgentResponse](docs/UpgradeAgentResponse.md)
   - [UpgradeAgentResult](docs/UpgradeAgentResult.md)
   - [UpgradeChannel](docs/UpgradeChannel.md)
   - [Usage](docs/Usage.md)
   - [V2ClusterUpdateParams](docs/V2ClusterUpdateParams.md)
   - [VerifiedVip](docs/VerifiedVip.md)
   - [VerifyVip](docs/VerifyVip.md)
   - [VerifyVipsRequest](docs/VerifyVipsRequest.md)
   - [VerifyVipsResponse](docs/VerifyVipsResponse.md)
   - [VersionedHostRequirements](docs/VersionedHostRequirements.md)
   - [Versions](docs/Versions.md)
   - [VipType](docs/VipType.md)
   - [VipVerification](docs/VipVerification.md)


  - **Type**: API key
  - **API key parameter name**: X-Secret-Key
  - **Location**: HTTP header

  - **Type**: API key
  - **API key parameter name**: Image-Token
  - **Location**: HTTP header

  - **Type**: API key
  - **API key parameter name**: image_token
  - **Location**: URL query string

  - **Type**: API key
  - **API key parameter name**: api_key
  - **Location**: URL query string

  - **Type**: API key
  - **API key parameter name**: Authorization
  - **Location**: HTTP header

  - **Type**: API key
  - **API key parameter name**: Watcher-Authorization
  - **Location**: HTTP header


pkgId: 2f53c83b67ba62f21b5c79ff130e28d8b99f0aeca97362ed7ae1a5c314344466
name: python-assorthead-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for assorthead
url: https://github.com/BiocPy/assorthead/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-assorthead-0.1.1-1.src.rpm
location_href: Packages/python-assorthead-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![ReadTheDocs](https://readthedocs.org/projects/assorthead/badge/?version=latest)](https://assorthead.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/assorthead/main.svg)](https://coveralls.io/r/<USER>/assorthead)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/assorthead.svg)](https://anaconda.org/conda-forge/assorthead)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/assorthead)
  -->

  [![PyPI-Server](https://img.shields.io/pypi/v/assorthead.svg)](https://pypi.org/project/assorthead/)
  ![Unit tests](https://github.com/BiocPy/assorthead/actions/workflows/pypi-test.yml/badge.svg)



  **assorthead** vendors an assortment of header-only C++ libraries for compilation of downstream packages.
  This centralizes the acquisition and versioning of these libraries for a smoother development experience.
  It is primarily intended for the various [**BiocPy**](https://github.com/BiocPy) packages with C++ extensions,
  e.g., [**scranpy**](https://github.com/BiocPy/scranpy), [**singler**](https://github.com/BiocPy/singler).

  Developers can install **assorthead** via the usual `pip` commands:

  ```shell
  pip install assorthead
  ```

  We can then add all headers to the compiler's search path,
  using the `include_dirs` argument in the `setup()` command in our `setup.py`:

  ```python
  setup(
      use_scm_version={"version_scheme": "no-guess-dev"},
      ext_modules=[
          Extension(
              "foo.core",
              [
                  "src/lib/foo.cpp",
                  "src/lib/bar.cpp",
              ],
              include_dirs=[
                  assorthead.includes(),
              ],
              language="c++",
              extra_compile_args=[
                  "-std=c++17",
              ],
          )
      ],
  )
  ```

  Of course, this is only relevant for developers; all going well, end users should never be aware of these details.

  See [`extern/manifest.csv`](extern/manifest.csv) for the list of vendored libraries and their versions.


pkgId: 96b2976f5d530557cbd9f29b5b7cd5ebcf4206e2e01ddb1beda20ee1ea4d90dd
name: python-ast-tool-py-help
arch: noarch
version: 0.18.1
epoch: 0
release: 1
summary: Development documents and examples for ast-tool-py
url: https://github.com/zoranbosnjak/asterix-tool/tree/master/ast-tool-py#readme
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ast-tool-py-0.18.1-1.src.rpm
location_href: Packages/python-ast-tool-py-help-0.18.1-1.noarch.rpm
checksum_type: sha256
description:
  Features:

  - random asterix data generator
  - asterix decoder to text output
  - UDP receiver and transmitter with multicast mode support
  - asterix category/edition detector
  - stream recorder and replay
  - support for multiple recording file formats
  - simple integration with other standard command line tools via stdin/stdout
  - user defined asterix data processing with custom script



  Install from python package index:

  ``` bash
  pip install ast-tool-py
  ```



  This installation procedures requires `python >= 3.7` and `pip >= 21.3`.
  Tested under `ubuntu-22.04` and `ubuntu-20.04`.

  Prepare virtual environment:

  ```bash
  sudo apt -y install python3-venv
  python3 -m venv env
  source env/bin/activate
  python3 -m pip install wheel # might be required (e.g. under ubuntu 20.04)
  ```

  Under some older OS versions (like ubuntu-18.04) it might be necessary to upgrade the
  the required versions first. In this case, the procedure to prepare the environment
  should be something like:

  ```bash
  sudo apt -y install python3.8 python3.8-venv python3-pip
  python3.8 -m venv env
  source env/bin/activate
  python3 -m pip install --upgrade pip
  python --version # check version
  python3 -m pip --version # check version
  python3 -m pip install wheel
  ```

  Install latest git version of this project and check installation:

  ```bash
  python3 -m pip install "git+https://github.com/zoranbosnjak/asterix-tool.git#subdirectory=ast-tool-py"
  ast-tool-py --version
  ast-tool-py --help
  ```



  If the target server is offline (that is: without internet access), use the
  following installation procedure (tested with `ubuntu-22.04`):

  - prepare installation bundle on auxilary server with internet access
  - transfer files to offline server
  - on the offline server, install from local disk

  **NOTE**:
  At the time of writing, `ubuntu-22.04` contains `pip` version `22.0.2` with a bug.
  For proper operation, `pip` needs to be upgraded on both auxilary and target
  server. Tested with `pip` version `23.3.1`.



  Run on the server with internet access.

  ```bash
  sudo apt -y install python3-pip
  mkdir ast-tool-py-bundle
  cd ast-tool-py-bundle


  python3 -m pip --version
  python3 -m pip install --upgrade pip
  python3 -m pip --version

  python3 -m pip download -d . pip setuptools wheel
  python3 -m pip download -d . "git+https://github.com/zoranbosnjak/asterix-tool.git#subdirectory=ast-tool-py"
  ```



  It is assumed that target server has `python`, `pip` and `venv` installed already.
  If required, install:

  ```bash
  sudo apt -y install python3-pip python3-venv
  ```

  Manually transfer `ast-tool-py-bundle/` to the target server and install.

  ```bash

  cd
  python3 -m venv env
  source env/bin/activate

  cd ast-tool-py-bundle


  python3 -m pip --version
  python3 -m pip install --upgrade --no-index ./pip*
  python3 -m pip --version


  python3 -m pip install --no-index --find-links=./ ./ast-tool*
  ast-tool-py --version
  ast-tool-py --help
  ```





  Some commands (`random`, `decode`...) need selection of asterix categories
  and edition. By default all available categories and the latest editions
  are used. The following command line arguments are available to adjust the
  setting (can be specified multiple times).

  - `--empty-selection` - start with empty selection instead of *all latest*
  - `--cat CAT EDITION` - add/replace category with explicit edition
  - `--ref CAT EDITION` - add/replace expansion with explicit edition
  - `--expand CAT ITEM-NAME` - Use expansion definition with selected topitem,
    for example `--expand 62 RE`



  The following options are available when program is used in a
  *bash pipeline*:

  - `--simple-input` - force simple mode for data input
  - `--simple-output` - force simple mode for data output
  - `-s` or `--simple` - force simple mode for data input and output
    (this is the same as setting `--simple-input` and `--simple-output`)
  - `--no-flush` - do not flush output on each event (use buffering)

  Examples:

  ```bash

  ast-tool-py random


  ast-tool-py --simple-output random


  ast-tool-py --simple-output random | ast-tool-py --simple-input decode

  ast-tool-py -s random | ast-tool-py -s decode
  ```



  ```bash
  ast-tool-py --help                   # general help
  ast-tool-py {subcommand-name} --help # subcommand help
  ```





  *Pseudo random asterix data generator*

  Examples:

  ```bash

  ast-tool-py random


  ast-tool-py random | stdbuf -oL head -n 10



  ast-tool-py -s random | stdbuf -oL head -n 10 | sha1sum



  ast-tool-py -s random --seed 0 | stdbuf -oL head -n 10 | sha1sum


  ast-tool-py manifest | grep "062" # show available editions
  ast-tool-py --empty-selection --cat 062 1.19 random


  ast-tool-py --expand 62 RE random


  ast-tool-py random --sleep 0.5
  ast-tool-py random | while read x; do echo "$x"; sleep 0.5; done
  ast-tool-py random | pv -qL 300


  ast-tool-py -s random | awk '{print "0: "$1}'


  ast-tool-py random --channel ch1 --channel ch2
  ```



  *Asterix decoder to plain text*

  Examples:

  ```bash

  ast-tool-py random | ast-tool-py decode


  ast-tool-py random | ast-tool-py decode --truncate 80


  ast-tool-py random | ast-tool-py decode --truncate 80 --parsing-level 3
  ast-tool-py random | ast-tool-py decode --truncate 80 --parsing-level 4


  ast-tool-py --expand 62 RE random | ast-tool-py --expand 62 RE decode
  ```

  Run simple self-test:

  Check if the tool can decode it's own random data, ignore decoding results.
  This bash pipeline shall run without error until interrupted.

  ```bash
  ast-tool-py random | ast-tool-py decode --stop-on-error > /dev/null

  ```



  *UDP datagram receiver/transmitter*

  Examples:

  ```bash

  ast-tool-py random | ast-tool-py to-udp --unicast "*" 127.0.0.1 56780


  ast-tool-py from-udp --unicast "ch1" 127.0.0.1 56780 \
      | ast-tool-py to-udp --unicast "*" 127.0.0.1 56781


  ast-tool-py from-udp --unicast "ch1" 127.0.0.1 56781 | ast-tool-py decode


  ast-tool-py random --sleep 0.3 --channel ch1 --channel ch2 \
      | ast-tool-py to-udp \
          --unicast "ch1" 127.0.0.1 56001 \
          --unicast "ch2" 127.0.0.1 56002


  ast-tool-py from-udp --unicast "ch1" 127.0.0.1 56001
  ast-tool-py from-udp --unicast "ch2" 127.0.0.1 56002
  ```



  *Detect valid/invalid asterix editions in a stream*

  This command inspects a stream and tryes to decode asterix with all defined
  asterix category/edition combinations. It runs until the stream is exhausted
  or until the process is interrupted.

  Examples:

  ```bash

  ast-tool-py random | stdbuf -oL head -n 1000 | ast-tool-py inspect


  ast-tool-py from-udp --unicast "ch1" 127.0.0.1 56780 | ast-tool-py inspect
  ```



  *Record/replay data to/from a file*

  Examples:

  ```bash

  ast-tool-py random --sleep 0.2 | stdbuf -oL head -n 10 | ast-tool-py record

  ast-tool-py random --sleep 0.2 | stdbuf -oL head -n 10 | ast-tool-py record | tee recording.simple
  ast-tool-py random --sleep 0.2 | stdbuf -oL head -n 10 | ast-tool-py record > recording.simple


  ast-tool-py record --help # check supported recording file formats
  ast-tool-py random --sleep 0.2 | stdbuf -oL head -n 10 \
      | ast-tool-py record --format final > recording.ff


  ast-tool-py replay recording.simple
  ast-tool-py replay recording.simple --full-speed


  ast-tool-py replay --help # check supported replay file formats
  ast-tool-py replay --format final recording.ff


  gzip recording.simple
  cat recording.simple.gz | gunzip | ast-tool-py replay
  zcat recording.simple.gz | ast-tool-py replay # or using 'zcat'
  ```



  *Running custom python script*

  This command dynamically imports a custom `python` script and runs required
  function (custom script entry point). The entry point function shall accept
  the following arguments:

  - `base`, `gen` - base and generated asterix module (encoder/decoder), see
    python asterix library:
    [libasterix](https://github.com/zoranbosnjak/asterix-libs/tree/main/libs/python#readme)
  - `io` - standard input/output instance
  - `args` - program arguments

  Custom script can use:

  - `io.rx` to fetch events as data *consumer*,
    for example to decode and display asterix data in any data-serialization
    format (json, xml, bson...)
  - `io.tx` to generate events as data *producer*,
    for example: reading and parsing non-standard recording file from disk
  - both `io.rx` and `io.tx` to act as custom data *filter* with arbitrary
    data manipulation capabilities



  ```python

  def custom(base, gen, io, args):
      print("Hello from custom script!")
      print(args.args) # explicit arguments
      print(args)      # all program arguments
  ```

  Test:

  ```bash
  ast-tool-py custom --script custom.py --call custom --args "additional arguments, any string"
  ```



  Basic filtering loop (transparent filter), use `io.rx` and `io.tx`.

  ```python

  def custom(base, gen, io, args):
      for event in io.rx():
          io.tx(event)
  ```

  Test:

  ```bash
  ast-tool-py random \
      | ast-tool-py custom --script custom.py --call custom \
      | ast-tool-py decode
  ```



  Drop events unless `channel == "ch1"`.

  ```python

  def custom(base, gen, io, args):
      for event in io.rx():
          (t_mono, t_utc, channel, data) = event
          if channel != "ch1":
              continue
          io.tx(event)
  ```

  ```bash

  ast-tool-py random --channel ch1 --channel ch2 --channel ch3 \
      | ast-tool-py custom --script custom.py --call custom
  ```



  Use `args`.

  ```python

  def custom(base, gen, io, args):
      valid_channels = args.args.strip().split()
      for event in io.rx():
          (t_mono, t_utc, channel, data) = event
          if not channel in valid_channels:
              continue
          io.tx(event)
  ```

  Specify channels with command line argument.

  ```bash

  ast-tool-py random --channel ch1 --channel ch2 --channel ch3 \
      | ast-tool-py custom --script custom.py --call custom --args "ch1 ch2"
  ```



  Note: This project is using
  [libasterix](https://github.com/zoranbosnjak/asterix-libs/tree/main/libs/python#readme)
  for asterix data processing. The `asterix` module is automatically imported
  and available in custom script (it does not require separate installation step).

  In general, if both `rx` and `tx` are used, custom scripts are in the form similar to
  the code snipped below. User might decide to handle exceptions differently.

  ```python



  def custom(base, gen, io, args):
      cfg = setup(base, gen)
      for event in io.rx():
          try:
              result = handle_event(cfg, event)
          except Exception as e:
              raise Exception('problem: ', event, e)
          io.tx(result)


  def setup(base, gen):
      return (base,gen) # for example if complete module is required


  def handle_event(cfg, event):
      (t_mono, t_utc, channel, data) = event
      
      return event # possible modified event
  ```



  ```python



  def custom(base, gen, io, args):
      cfg = setup(base)
      for event in io.rx():
          handle_event(cfg, event)

  def setup(base):
      return (base.RawDatablock, base.Bits)

  def handle_event(cfg, event):
      RawDatablock, Bits = cfg
      (t_mono, t_utc, channel, data) = event
      raw_datablocks = RawDatablock.parse(Bits.from_bytes(data))
      print(t_utc, channel, len(raw_datablocks))
  ```

  Test:

  ```bash
  ast-tool-py random --channel ch1 --channel ch2 --channel ch3 \
      | ast-tool-py custom --script custom.py --call custom
  ```



  ... ignore errors.

  ```python


  def custom(base, gen, io, args):
      manifest = gen.manifest
      specs = {cat: manifest['CATS'][cat][-1] for cat in manifest['CATS']}
      for event in io.rx():
          try: handle_event(base, specs, event)
          except: pass

  def handle_event(base, specs, event):
      (t_mono, t_utc, channel, data) = event
      bits = base.Bits.from_bytes(data)
      raw_datablocks = base.RawDatablock.parse(bits)
      for raw_db in raw_datablocks:
          cat = raw_db.get_category()
          spec = specs.get(cat)
          records = spec.cv_uap.parse(raw_db.get_raw_records())
          for record in spec.cv_uap.parse(raw_db.get_raw_records()):
              i010 = record.get_item('010').variation
              sac = i010.get_item('SAC').as_uint()
              sic = i010.get_item('SIC').as_uint()
              print(t_utc, channel, cat, (sac, sic))
  ```

  Test:

  ```bash
  ast-tool-py random --channel ch1 --channel ch2 --channel ch3 \
      | ast-tool-py custom --script custom.py --call custom
  ```



  ... for example *north marker* and *sector crossing* message in category 034.

  ```python



  def custom(base, gen, io, args):
      cfg = setup((base, gen))
      for event in io.rx():
          handle_event(cfg, event)

  def setup(cfg):
      base, gen = cfg
      return (base, gen.Cat_034_1_29) # use cat 034, explicit edition

  def handle_event(cfg, event):
      base, Spec = cfg
      (t_mono, t_utc, channel, data) = event
      
      bits = base.Bits.from_bytes(data)
      raw_datablocks = base.RawDatablock.parse(bits)
      for raw_db in raw_datablocks:
          
          if raw_db.get_category() != Spec.cv_category:
              continue
          
          records = Spec.cv_uap.parse(raw_db.get_raw_records())
          for rec in records:
              handle_record(t_utc, channel, rec)

  def handle_record(t_utc, channel, rec):
      msg_type = rec.get_item('000')
      if msg_type is None:
          return
      x = msg_type.as_uint()
      s = None
      if x == 1:
          s = 'north marker'
      elif x == 2:
          s = 'sector crossing'
      if s is not None:
          print(t_utc, channel, s)
  ```

  Test:

  ```bash
  ast-tool-py --empty-selection --cat 34 1.29 random --channel ch1 --channel ch2 --channel ch3 \
      | ast-tool-py custom --script custom.py --call custom
  ```



  ```python



  def custom(base, gen, io, args):
      for event in io.rx():
          (t_mono, t_utc, channel, data) = event
          data2 = handle_datagram(base, data)
          event2 = (t_mono, t_utc, channel, data2)
          io.tx(event2)

  def handle_datagram(base, data):
      bits = base.Bits.from_bytes(data)
      raw_datablocks = base.RawDatablock.parse(bits)
      if len(raw_datablocks) <= 1:
          return data
      return b''.join([db.unparse().to_bytes() for db in reversed(raw_datablocks)])
  ```

  Test:

  ```bash
  ast-tool-py random | ast-tool-py custom --script custom.py --call custom
  ```



  Accept category number as argument, drop other categories.

  ```python



  def custom(base, gen, io, args):
      cat = int(args.args.strip())
      for event in io.rx():
          (t_mono, t_utc, channel, data) = event
          bits = base.Bits.from_bytes(data)
          lst = base.RawDatablock.parse(bits)
          lst = [db for db in lst if db.get_category() == cat]
          if not lst:
              continue
          data2 = b''.join([db.unparse().to_bytes() for db in lst])
          event2 = (t_mono, t_utc, channel, data2)
          io.tx(event2)
  ```

  Run custom filter on random data, filte out all categories but `62`.

  ```bash
  ast-tool-py random \
      | ast-tool-py custom --script custom.py --call custom --args 62 \
      | ast-tool-py decode --parsing-level 2 --truncate 80
  ```



  Keep other items unmodified.

  ```python



  def custom(base, gen, io, args):
      Spec = gen.Cat_062_1_20
      for event in io.rx():
          (t_mono, t_utc, channel, data) = event
          bits = base.Bits.from_bytes(data)
          lst = base.RawDatablock.parse(bits)
          lst = [handle_datablock(Spec, db) for db in lst]
          data2 = b''.join([db.unparse().to_bytes() for db in lst])
          event2 = (t_mono, t_utc, channel, data2)
          io.tx(event2)

  def handle_datablock(Spec, raw_db):
      if raw_db.get_category() != Spec.cv_category:
          return raw_db
      records1 = Spec.cv_uap.parse(raw_db.get_raw_records())
      records2 = map(handle_record, records1)
      return Spec.create(records2)

  def handle_record(rec):
      return rec.set_item('010', (('SAC', 0), ('SIC', 0)))
  ```

  Test:

  ```bash
  ast-tool-py --empty-selection --cat 62 1.20 random | \
      ast-tool-py custom --script custom.py --call custom | \
      ast-tool-py decode | grep \'010\' | grep -E 'SAC|SIC'
  ```



  This example fully decodes and converts each *event* to `json` format.
  Obviously, there are multiple ways to perform such conversion, depending
  on user preferences and information that needs to be preserved.
  This is one example.

  ```python


  import json


  def custom(base, gen, io, args):
      cfg = setup(base, gen, args)
      for event in io.rx():
          try:
              obj = convert_event(cfg, event)
          except Exception as e:
              raise Exception('problem: ', event, e)
          print(json.dumps(obj))

  def get_selection(gen, empty, explicit_cats, explicit_refs):
      """Get category selection."""

      manifest = gen.manifest

      
      cats = {cat: manifest['CATS'][cat][-1] for cat in manifest['CATS']} # type: ignore
      refs = {cat: manifest['REFS'][cat][-1] for cat in manifest['REFS']} # type: ignore

      
      if empty:
          cats = {}
          refs = {}

      
      for (a, b, c) in [
          (cats, manifest['CATS'], explicit_cats),
          (refs, manifest['REFS'], explicit_refs),
      ]:
          for (cat_i, ed_s) in c:
              cat = int(cat_i)
              ed1, ed2 = ed_s.split('.')
              ed = (int(ed1), int(ed2))
              for spec in b[cat]: # type: ignore
                  if spec.cv_edition == ed:
                      a.update({cat: spec})
      return {'CATS': cats, 'REFS': refs}

  def get_expansions(base, gen, selection, expansions):
      result = []
      for (cat, name) in expansions:
          cat = int(cat)
          assert cat in selection['REFS'].keys(), 'REF not defined'
          spec = selection['CATS'][cat]
          subitem = spec.cv_record.spec(name)
          assert issubclass(subitem.cv_rule.cv_variation, base.Explicit)
          result.append((cat, name))
      return result

  def setup(base, gen, args):
      
      sel = get_selection(gen, args.empty_selection, args.cat or [], args.ref or [])
      exp = get_expansions(base, gen, sel, args.expand or [])
      return (base, sel, exp)

  def convert_event(cfg, event):
      """Turn 'event' to json-serializable object"""
      (t_mono, t_utc, channel, data) = event
      return {
          'tMono':    t_mono,
          'tUtc':     t_utc.isoformat(),
          'channel':  channel,
          'data':     convert_datagram(cfg, data),
      }

  def convert_datagram(cfg, data):
      (base, sel, exp) = cfg
      
      bits = base.Bits.from_bytes(data)
      raw_datablocks = base.RawDatablock.parse(bits)
      return [convert_datablock(cfg, raw_db) for raw_db in raw_datablocks]

  def convert_datablock(cfg, raw_db):
      (base, sel, exp) = cfg
      cat = raw_db.get_category()
      spec = sel['CATS'].get(cat)
      if spec is None: # asterix category unknown
          return raw_db.unparse().to_bytes().hex()
      records = spec.cv_uap.parse(raw_db.get_raw_records())
      return {
          'cat': cat,
          'records': [convert_record(cfg, cat, rec) for rec in records]
      }

  def convert_record(cfg, cat, rec):
      (base, sel, exp) = cfg

      def convert_content(content):
          if isinstance(content, base.ContentRaw):
              return {'type': 'raw', 'raw': content.as_uint()}
          elif isinstance(content, base.ContentTable):
              return {'type': 'table', 'raw': content.as_uint(), 'str': content.table_value()}
          elif isinstance(content, base.ContentString):
              return {'type': 'string', 'raw': content.as_uint(), 'str': content.as_string()}
          elif isinstance(content, base.ContentInteger):
              return {'type': 'integer', 'raw': content.as_uint(), 'int': content.as_integer()}
          elif isinstance(content, base.ContentQuantity):
              return {'type': 'quantity', 'raw': content.as_uint(), 'float': content._as_quantity()
                      , 'unit': content.__class__.cv_unit}
          elif isinstance(content, base.ContentBds):
              return {'type': 'bds', 'raw': content.as_uint()}
          else:
              raise Exception('internal error, unexpected content', content)

      def convert_rulecontent(rule):
          if isinstance(rule, base.RuleContentContextFree):
              return convert_content(rule.content)
          elif isinstance(rule, base.RuleContentDependent):
              return '(content dependent structure...)'
          else:
              raise Exception('internal error, unexpected rule', rule)

      def convert_variation(var, path):
          if isinstance(var, base.Element):
              return {
                  'type': 'Element',
                  'content': convert_rulecontent(var.rule),
              }
          elif isinstance (var, base.Group):
              return {
                  'type': 'Group',
                  'items': [convert_item(i, path) for i in var.arg]
              }
          elif isinstance (var, base.Extended):
              items = []
              for lists in var.arg:
                  for i in lists:
                      if i is not None:
                          items.append((convert_item(i, path),))
                      else:
                          items.append('(FX)')
              return {
                  'type': 'Extended',
                  'items': items,
              }
          elif isinstance (var, base.Repetitive):
              return {
                  'type': 'Repetitive',
                  'items': [convert_variation(sub, path+[cnt]) for (cnt, sub) in enumerate(var.arg)]
              }
          elif isinstance (var, base.Explicit):
              this_item = (cat, path[0])
              b = var.get_bytes()
              content = b.hex()
              if this_item in exp:
                  sub = sel['REFS'][cat].cv_expansion
                  bits = base.Bits.from_bytes(b)
                  (val, remaining) = sub.parse(bits)
                  assert not len(remaining)
                  content = convert_expansion(val, path)
              return {
                  'type': 'Explicit',
                  'content': content,
              }
          elif isinstance (var, base.Compound):
              return {
                  'type': 'Compound',
                  'items': {name: convert_rulevariation(nsp.rule, path+[name]) for name, nsp in var.arg.items()},
              }
          else:
              raise Exception('internal error, unexpected variation', var.variation, var)

      def convert_item(item, path):
          if isinstance(item, base.Spare):
              return item.as_uint()
          elif isinstance(item, base.Item):
              nsp = item.arg
              name = nsp.__class__.cv_name
              return (name, convert_rulevariation(nsp.rule, path+[name]))
          else:
              raise Exception('internal error, unexpected item', item)

      def convert_rulevariation(rule, path):
          if isinstance(rule, base.RuleVariationContextFree):
              return convert_variation(rule.variation, path)
          elif isinstance(rule, base.RuleVariationDependent):
              return '(content dependent structure...)'
          else:
              raise Exception('internal error, unexpected rule', rule)

      def convert_expansion(var, path):
          return {name: convert_rulevariation(nsp.rule, path+[name]) for name, nsp in var.arg.items()}

      result = {}
      for ui in rec.cv_items_list:
          if not issubclass(ui, base.UapItem):
              continue
          name = ui.cv_non_spare.cv_name
          nsp = rec.get_item(name)
          if nsp is None:
              continue
          result[name] = convert_rulevariation(nsp.rule, [name])
      return result
  ```

  As an example:

  - use random input data
  - use latest edition for each known category
  - in addition, decode cat021 'RE' expansion field

  ```bash
  sudo apt install jq
  ast-tool-py --expand 21 RE random --seed 0 --populate-all-items \
      | ast-tool-py --expand 21 RE custom --script custom.py --call custom \
      | jq
  ```



  Scenario:

  - read data from recording file, filter required channels
  - filter out non-asterix data
  - restamp several asterix categories to current time
  - send to udp destination, according to channel name mapping

  ```python


  import datetime


  def cleanup(base, gen, io, args):
      for event in io.rx():
          (t_mono, t_utc, channel, data) = event
          bits = base.Bits.from_bytes(data)
          result = base.RawDatablock.parse(bits)
          if isinstance(result, ValueError): # skip non-asterix
              continue
          io.tx(event)


  def restamp(base, gen, io, args):
      
      updates = {
          1: (gen.Cat_001_1_4, "141"),
          2: (gen.Cat_002_1_1, '030'),
          19: (gen.Cat_019_1_3, '140'),
          20: (gen.Cat_020_1_10, '140'),
          34: (gen.Cat_034_1_29, '030'),
          48: (gen.Cat_048_1_32, '140'),
          
      }

      for event in io.rx():
          now = datetime.datetime.now(tz=datetime.timezone.utc)
          (t_mono, t_utc, channel, data) = event
          bits = base.Bits.from_bytes(data)
          result = base.RawDatablock.parse(bits)
          if isinstance(result, ValueError):
              continue
          raw_datablocks = [db for db in result if db.get_category() in updates]
          if not raw_datablocks:
              continue
          t2 = seconds_since_midnight(t_utc)
          t3 = seconds_since_midnight(now)
          lst = [handle_datablock(t2, t3, updates, db) for db in raw_datablocks]
          data2 = b''.join([db.unparse().to_bytes() for db in lst])
          event2 = (t_mono, now, channel, data2)
          io.tx(event2)

  def seconds_since_midnight(t):
      """Calculate seconds since midnight."""
      midnight = datetime.datetime.combine(t, datetime.time(0), t.tzinfo)
      dt = t - midnight
      return dt.total_seconds()

  def handle_datablock(t2, t3, updates, raw_db):
      cat = raw_db.get_category()
      (Spec, name) = updates.get(cat)
      result = Spec.cv_uap.parse(raw_db.get_raw_records())
      assert not isinstance(result, ValueError)
      records = [handle_record(t2, t3, rec, name) for rec in result]
      return Spec.create(records)

  def handle_record(t2, t3, rec, name):
      
      def stamp(t1):
          t1 = t1.variation.content.as_quantity()
          original_delay = t2 - t1
          return t3 - original_delay
      x = rec.get_item(name)
      if x is None:
          return rec
      return rec.set_item(name, stamp(x))
  ```

  Test:

  ```bash

  ast-tool-py random --seed 0 --sleep 0.05 --channel ch1 --channel ch2 \
      | stdbuf -oL head -n 100 \
      | ast-tool-py record | tee recording


  cat recording | ast-tool-py replay | ast-tool-py inspect


  cat recording | ast-tool-py replay \
      | ast-tool-py custom --script custom.py --call cleanup \
      | ast-tool-py custom --script custom.py --call restamp \
      | ast-tool-py to-udp \
          --unicast ch1 127.0.0.1 56001 \
          --unicast ch2 127.0.0.1 56002
  ```


pkgId: 762d8a6cc7290b7da43ac1b6c278ec70f9373b2c048a04c3c21fc24ad1046ba9
name: python-ast_monitor-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for ast_monitor
url: https://github.com/firefly-cpp/AST-Monitor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ast_monitor-0.5.3-1.src.rpm
location_href: Packages/python-ast_monitor-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width="300" src=".github/img/logo.png" alt="logo.png">
  </p>

  <h1 align="center">
  AST-Monitor --- A wearable Raspberry Pi computer for cyclists
  </h1>

  <p align="center">
    <img alt="PyPI Version" src="https://img.shields.io/pypi/v/ast-monitor.svg" href="https://pypi.python.org/pypi/ast-monitor">
    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/ast-monitor.svg">
    <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/ast-monitor.svg">
    <img alt="Fedora package" src="https://img.shields.io/fedora/v/python3-ast-monitor?color=blue&label=Fedora%20Linux&logo=fedora" href="https://src.fedoraproject.org/rpms/python-ast-monitor">
    <img alt="AUR package" src="https://img.shields.io/aur/version/python-ast-monitor?color=blue&label=Arch%20Linux&logo=arch-linux" href="https://aur.archlinux.org/packages/python-ast-monitor">
    <img alt="GitHub license" src="https://img.shields.io/github/license/firefly-cpp/ast-monitor.svg" href="https://github.com/firefly-cpp/AST-Monitor/blob/master/LICENSE">
    <img alt="Check codestyle and test build" src="https://github.com/firefly-cpp/AST-Monitor/actions/workflows/python-app.yml/badge.svg">
    <img alt="Documentation Status" src="https://readthedocs.org/projects/ast-monitor/badge/?version=latest" href="http://ast-monitor.readthedocs.io/en/latest/?badge=latest">
  </p>

  <p align="center">
    <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/w/firefly-cpp/ast-monitor.svg">
    <img alt="GitHub repo size" src="https://img.shields.io/github/repo-size/firefly-cpp/ast-monitor">
    <img alt="GitHub contributors" src="https://img.shields.io/github/contributors/firefly-cpp/ast-monitor.svg">
    <img alt="All Contributors" src="https://img.shields.io/badge/all_contributors-4-orange.svg" href="#-contributors">
  </p>

  <p align="center">
    <img alt="DOI" src="https://img.shields.io/badge/DOI-10.1109/ISCMI53840.2021.9654817-blue" href="https://doi.org/10.3390/app122412741">
    <img alt="DOI" src="https://img.shields.io/badge/DOI-10.3390/app122412741-blue" href="https://doi.org/10.3390/app122412741">
  </p>

  <p align="center">
    <a href="#-graphical-user-interface">💻 Graphical User Interface</a> •
    <a href="#️-hardware">⚙️ Hardware</a> •
    <a href="#️-software">🖥️ Software</a> •
    <a href="#-installation">📦 Installation</a> •
    <a href="#-deployment">📢 Deployment</a> •
    <a href="#-examples">🚀 Examples</a> •
    <a href="#-license">🔑 License</a> •
    <a href="#-cite-us">📄 Cite us</a> •
    <a href="#-further-read">📖 Further read</a> •
    <a href="#-related-packagesframeworks">🔗 Related packages</a> •
    <a href="#-references">📝 References</a> •
    <a href="#-contributors">🫂 Contributors</a>
  </p>

  Welcome to AST-Monitor: Revolutionizing Sport Training Sessions! 🏋️‍♂️ This repository aims to introduce a low-cost, and efficient embedded device that can transform the way you monitor
  cycling training sessions. Allow us to present AST-Monitor.

  To begin, we invite you to explore the paper that introduces the capabilities of AST-Monitor. Dive into the future of artificial sports trainers by reading this [paper](https://arxiv.org/abs/2109.13334). 📄💡

  * **Free software:** MIT license
  * **Python versions:** 3.8.x, 3.9.x, 3.10.x, 3.11.x, 3.12.x
  * **Documentation:** [https://ast-monitor.readthedocs.io/en/latest](https://ast-monitor.readthedocs.io/en/latest)
  * **Tested OS:** Windows, Ubuntu, Fedora, Alpine, Arch, macOS. **However, that does not mean it does not work on others**





  <p align="center">
    <img width="600" src="https://user-images.githubusercontent.com/73126820/179205064-160bdd44-fd67-4d8d-85dd-badea999885c.png" alt="AST-GUI">
  </p>
  The initial page of the AST-Monitor application presents essential parameters, providing real-time insights into an athlete's performance. Gain access to information such as the athlete's current speed and heart rate. After a training session, you'll also receive a comprehensive overview, including total distance covered, session duration, and total ascent conquered. 📱🚴‍♂️



  <p align="center">
    <img width="600" src="https://github.com/alenrajsp/AST-Monitor/blob/main/.github/img/route3.png?raw=true" alt="AST-Map">
  </p>
  As you navigate uncharted territories, this map reveals your precise location in real-time. And allows you to track your progress on the route in real time. 🌍🚴‍♂️🗺️



  <p align="center">
    <img width="600" src="https://user-images.githubusercontent.com/73126820/179205160-edce581c-1ea8-4287-a795-7d05fb7c8ddc.png" alt="AST-Intervals">
  </p>
    Discover the duration of each phase, track your current heart rate, and marvel at the average heart rate achieved. But that's not all—brace yourself for the Digital Twin proposed heart rate and witness the thrilling difference between your current heart rate and the proposed target. Prepare to dominate your workouts with the AST-Monitor! 🏋️‍♀️



  <p align="center">
    <img width="600" src="https://user-images.githubusercontent.com/73126820/189926103-e0895132-9bbc-41bf-8868-51e3e6c23f8a.png" alt="AST-Trainings">
  </p>
   Load up and embark on thrilling interval trainings that await you in the "AST-Monitor/development/trainings" folder. These trainings, meticulously crafted in the domain-specific language <a href="https://github.com/firefly-cpp/ast-tdl">AST-TDL</a>, are designed to take you to the next level. Once successfully loaded, witness the training plan come to life before your eyes. 🚀📋💥




  Prepare to be dazzled by the complete hardware setup featured in AST-Monitor.

  <p align="center">
    <img width="600" src="https://raw.githubusercontent.com/firefly-cpp/AST-Monitor/main/.github/img/complete_small.JPG" alt="AST-Monitor">
  </p>

  Let's take a closer look at the components:

  * **A platform with fixing straps** that securely attach to your bicycle, ensuring a seamless training experience. 🚲🔒
  * **The powerful Raspberry Pi 4 Model B micro-controller**, powered by the dynamic Raspbian OS. 💻
  * **A five-inch LCD touchscreen display**, allowing the interaction with AST-Monitor during the training. ✨🖥️
  * **Equipped with a USB ANT+ stick**, AST-Monitor captures the heartbeat of your training, providing crucial data for your journey to greatness. 📡
  * **Adafruit's Ultimate GPS HAT module** joins the lineup, empowering you with location information and paving the way for GPS integration (coming soon!). 🌐🛰️

  But that's not all:

  A Serial Peripheral Interface (SPI) protocol ensures seamless communication between the Raspberry Pi and the GPS
  peripheral, guaranteeing accurate and timely data. The screen display, connected using a physically shortened HDMI
  cable, ensures a sleek and compact design that doesn't compromise performance.

  During the testing phase, the AST-Monitor prototype was powered by Trust's 5 VDC power bank, providing unparalleled
  endurance. While the current prototype may be a bit bulky, rest assured, our team is hard at work, exploring sleeker and
  more discreet solutions. 💪💦

  For those who crave a glimpse inside AST-Monitor:

  <p align="center">
    <img width="600" src="https://user-images.githubusercontent.com/73126820/189920171-ac946a93-ad78-4e4b-bf09-5de5bf69bef9.png" alt="AST-Monitor">
  </p>

  Welcome to the next stage of sports training. Welcome to AST-Monitor—your ultimate companion on the road to victory!
  🌟🏆🚀





  List of dependencies:

  | Package                   | Version | Platform |
  |---------------------------|:-------:|:--------:|
  | PyQt6                     | ^5.15.6 |   All    |
  | matplotlib                | ^3.5.1  |   All    |
  | geopy                     | ^2.2.0  |   All    |
  | openant                   | ^1.2.0  |   All    |
  | pyqt-feedback-flow        | ^0.1.0  |   All    |
  | tcxreader                 | ^0.4.1  |   All    |
  | sport-activities-features | ^0.3.6  |   All    |

  Additional note: adafruit-circuitpython-gps package must be installed in order to work with the GPS sensor:

  ```sh
  $ pip install adafruit-circuitpython-gps
  ```



  Install AST-Monitor with pip:

  ```sh
  $ pip install ast-monitor
  ```

  In case you want to install directly from the source code, use:

  ```sh
  $ git clone https://github.com/firefly-cpp/AST-Monitor.git
  $ cd AST-Monitor
  $ poetry build
  $ python setup.py install
  ```

  To install AST-Monitor on Fedora Linux, please use:

  ```sh
  $ dnf install python3-ast-monitor
  ```

  To install AST-Monitor on Alpine Linux, please use:

  ```sh
  $ apk add py3-ast-monitor
  ```

  To install AST-Monitor on Arch Linux, please use an [AUR helper](https://wiki.archlinux.org/title/AUR_helpers):

  ```sh
  $ yay -Syyu python-ast-monitor
  ```



  Our project was deployed on a Raspberry Pi device using Raspberry Pi OS.

  The hardware configuration of AST-Monitor using Raspberry Pi OS is described
  in <a href="https://github.com/firefly-cpp/AST-Monitor/blob/main/HARDWARE_CONFIGURATION.md">
  HARDWARE_CONFIGURATION.md</a>.





  ```python
  import os
  import sys

  from PyQt6 import QtWidgets

  try:
      from ast_monitor.model import AST
  except ModuleNotFoundError:
      sys.path.append('../')
      from ast_monitor.model import AST


  hr_data = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'sensor_data', 'hr.txt')
  gps_data = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'sensor_data', 'gps.txt')
  route_data = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'development', 'routes', 'route.json')

  if __name__ == '__main__':
      app = QtWidgets.QApplication(sys.argv)
      window = AST(hr_data, gps_data, route_data)
      window.show()
      sys.exit(app.exec())
  ```



  This package is distributed under the MIT License. This license can be found online
  at <http://www.opensource.org/licenses/MIT>.



  This framework is provided as-is, and there are no guarantees that it fits your purposes or that it is bug-free. Use it
  at your own risk!



  Lukač, L., Fister Jr., I., Fister,
  I. "[Digital Twin in Sport: From an Idea to Realization](https://www.mdpi.com/2076-3417/12/24/12741)." Applied Sciences
  12.24 (2022): 12741, DOI: [10.3390/app122412741](http://dx.doi.org/10.3390/app122412741).


  [1] [Awesome Computational Intelligence in Sports](https://github.com/firefly-cpp/awesome-computational-intelligence-in-sports)



  [1] [sport-activities-features: A minimalistic toolbox for extracting features from sports activity files written in Python](https://github.com/firefly-cpp/sport-activities-features)

  [2] [ast-tdl: Training Description Language for Artificial Sport Trainer](https://github.com/firefly-cpp/ast-tdl)



  Fister Jr, I., Fister, I., Iglesias, A., Galvez, A., Deb, S., & Fister, D. (2021). On deploying the Artificial Sport
  Trainer into practice. arXiv preprint [arXiv:2109.13334](https://arxiv.org/abs/2109.13334).

  Fister Jr, I., Salcedo-Sanz, S., Iglesias, A., Fister, D., Gálvez, A., & Fister, I. (2021). New Perspectives in the
  Development of the Artificial Sport Trainer. Applied Sciences, 11(23), 11452.
  DOI: [10.3390/app112311452](https://doi.org/10.3390/app112311452)



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://www.iztok-jr-fister.eu/"><img src="https://avatars.githubusercontent.com/u/1633361?v=4?s=100" width="100px;" alt="Iztok Fister Jr."/><br /><sub><b>Iztok Fister Jr.</b></sub></a><br /><a href="https://github.com/firefly-cpp/AST-Monitor/issues?q=author%3Afirefly-cpp" title="Bug reports">🐛</a> <a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=firefly-cpp" title="Documentation">📖</a> <a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=firefly-cpp" title="Code">💻</a> <a href="#maintenance-firefly-cpp" title="Maintenance">🚧</a> <a href="#mentoring-firefly-cpp" title="Mentoring">🧑‍🏫</a> <a href="#platform-firefly-cpp" title="Packaging/porting to new platform">📦</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/luckyLukac"><img src="https://avatars.githubusercontent.com/u/73126820?v=4?s=100" width="100px;" alt="luckyLukac"/><br /><sub><b>luckyLukac</b></sub></a><br /><a href="https://github.com/firefly-cpp/AST-Monitor/issues?q=author%3AluckyLukac" title="Bug reports">🐛</a> <a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=luckyLukac" title="Documentation">📖</a> <a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=luckyLukac" title="Code">💻</a> <a href="#design-luckyLukac" title="Design">🎨</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://carlosal1015.github.io"><img src="https://avatars.githubusercontent.com/u/21283014?v=4?s=100" width="100px;" alt="Oromion"/><br /><sub><b>Oromion</b></sub></a><br /><a href="#platform-carlosal1015" title="Packaging/porting to new platform">📦</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/alenrajsp"><img src="https://avatars.githubusercontent.com/u/27721714?v=4?s=100" width="100px;" alt="alenrajsp"/><br /><sub><b>alenrajsp</b></sub></a><br /><a href="#content-alenrajsp" title="Content">🖋</a> <a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=alenrajsp" title="Code">💻</a> <a href="#maintenance-alenrajsp" title="Maintenance">🚧</a> <a href="https://github.com/firefly-cpp/AST-Monitor/issues?q=author%3Aalenrajsp" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/KukovecRok"><img src="https://avatars.githubusercontent.com/u/33880044?v=4?s=100" width="100px;" alt="Tatookie"/><br /><sub><b>Tatookie</b></sub></a><br /><a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=KukovecRok" title="Documentation">📖</a> <a href="https://github.com/firefly-cpp/AST-Monitor/issues?q=author%3AKukovecRok" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/rhododendrom"><img src="https://avatars.githubusercontent.com/u/3198785?v=4?s=100" width="100px;" alt="rhododendrom"/><br /><sub><b>rhododendrom</b></sub></a><br /><a href="#design-rhododendrom" title="Design">🎨</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/sertonix"><img src="https://avatars.githubusercontent.com/u/83883937?v=4?s=100" width="100px;" alt="Sertonix"/><br /><sub><b>Sertonix</b></sub></a><br /><a href="https://github.com/firefly-cpp/AST-Monitor/issues?q=author%3Asertonix" title="Bug reports">🐛</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lahovniktadej"><img src="https://avatars.githubusercontent.com/u/57890734?v=4?s=100" width="100px;" alt="Tadej Lahovnik"/><br /><sub><b>Tadej Lahovnik</b></sub></a><br /><a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=lahovniktadej" title="Documentation">📖</a> <a href="https://github.com/firefly-cpp/AST-Monitor/commits?author=lahovniktadej" title="Code">💻</a> <a href="https://github.com/firefly-cpp/AST-Monitor/issues?q=author%3Alahovniktadej" title="Bug reports">🐛</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->


