# packages

pkgId: 5736e7550fe27d7f39528f3679c36024bc6607a5232ae3489d7cb916acbc7506
name: python-duckling-chinese-help
arch: noarch
version: 1.1.6
epoch: 0
release: 1
summary: Development documents and examples for duckling-chinese
url: https://pypi.org/project/duckling-chinese/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-duckling-chinese-1.1.6-1.src.rpm
location_href: Packages/python-duckling-chinese-help-1.1.6-1.noarch.rpm
checksum_type: sha256
description:
  中文 Duckling (duckling-chinese) 是基于 Jpype1 的 [duckling-fork-chinese](https://github.com/XiaoMi/MiNLP/tree/main/duckling-fork-chinese) 的 Python 封装版本，提供例如时间、日期、数字等中文解析服务。

  中文 Duckling 利用 Jpype1 调用 duckling-fork-chinese，需要系统正确安装配置 JVM，再通过 `pip` 安装最新版本。
  ```
  pip install duckling-chinese
  ```
  具体使用方式详见文档：<https://duckling.leovan.tech>。

  Haskell 原始版本：[Duckling](https://github.com/facebook/duckling)
  Scala 中文版本：[duckling-fork-chinese](https://github.com/XiaoMi/MiNLP/tree/main/duckling-fork-chinese)

  The MIT License (MIT)
  版权所有 &copy; 2023-2024，<a href="https://leovan.me" target="_blank">范叶亮 | Leo Van</a>


pkgId: 70cc760b399eaaecfee6f60f0ea3bc4e16ac9ea6d93453f52130f2745975c322
name: python-ducktype-mypy-plugin
arch: noarch
version: 0.2.dev1
epoch: 0
release: 1
summary: Duck-typing plugin for mypy.
url: https://github.com/pyvista/ducktype-mypy-plugin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ducktype-mypy-plugin-0.2.dev1-1.src.rpm
location_href: Packages/python-ducktype-mypy-plugin-0.2.dev1-1.noarch.rpm
checksum_type: sha256
description:
  Mypy plugin for the PyVista project.

  This plugin is primarily used for type-promotion between related classes that do not
  inherit from each other. For example, the abstract class `pyvista.DataSet` does not
  inherit from `vtk.vtkDataSet`, and will generate type errors wherever a `vtk.vtkDataSet`
  is expected. Without this plugin, the following is a type error:

  ``` python
  from pyvista import DataSet
  from vtkmodules.vtkCommonDataModel import vtkDataSet

  x: vtkDataSet
  x = DataSet()  # error: Incompatible types in assignment (expression has type "DataSet", variable has type "vtkDataSet")'
  ```

  (Note that the example above is not valid at runtime since `DataSet` is an abstract
  class and cannot be instantiated.)

  With this plugin, `DataSet` is promoted as type `vtkDataSet`, allowing `DataSet`
  type to be used wherever `vtkDataSet` is used.



  Dependencies:
  - [mypy](https://github.com/python/mypy)
  - [pyvista](https://github.com/pyvista/pyvista)
  - [vtk](https://pypi.org/project/vtk/)

  Install it with:

  ``` bash
  python -m pip install pyvista-mypy-plugin
  ```

  Alternatively, add `pyvista-mypy-plugin` as a project dependency wherever `mypy` is
  used, e.g. as an optional dev requirement in `pyproject.toml`:

  ``` toml
  [project.optional-dependencies]
  dev = ["mypy", "pyvista-mypy-plugin"]
  ```



  To enable the plugin, it must be added to your project's mypy configuration file.
  E.g. add the following to `pyproject.toml`:

  ``` toml
  [tool.mypy]
  plugins = [
    'pyvista_mypy_plugin',
  ]
  ```



  First, install `pyvista-mypy-plugin` with dev requirements:
  ``` bash
  python -m pip install pyvista-mypy-plugin[dev]
  ```

  To run the tests, execute:
  ``` bash
  pytest
  ```


pkgId: 9960d7b3ec5500e96d354eda6094d0b3de67d159cbc7fd563498883d2ef4eaa8
name: python-duckyai-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for duckyai
url: https://pypi.org/project/duckyai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-duckyai-0.3.0-1.src.rpm
location_href: Packages/python-duckyai-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Developer-friendly & type-safe Python SDK specifically catered to leverage *duckyai* API.

  <div align="left">
      <a href="https://www.speakeasy.com/?utm_source=duckyai&utm_campaign=python"><img src="https://custom-icon-badges.demolab.com/badge/-Built%20By%20Speakeasy-212015?style=for-the-badge&logoColor=FBE331&logo=speakeasy&labelColor=545454" /></a>
      <a href="https://opensource.org/licenses/MIT">
          <img src="https://img.shields.io/badge/License-MIT-blue.svg" style="width: 100px; height: 28px;" />
      </a>
  </div>


  <br /><br />
  > [!IMPORTANT]
  > This SDK is not yet ready for production use. To complete setup please follow the steps outlined in your [workspace](https://app.speakeasy.com/org/ducky/feather-backend). Delete this section before > publishing to a package manager.

  <!-- Start Summary [summary] -->


  Ducky API: API for managing and retrieving data from Ducky.
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->

  <!-- $toc-max-depth=2 -->
  * [duckyai](#duckyai)
    * [SDK Installation](#sdk-installation)
    * [IDE Support](#ide-support)
    * [SDK Example Usage](#sdk-example-usage)
    * [Authentication](#authentication)
    * [Available Resources and Operations](#available-resources-and-operations)
    * [Retries](#retries)
    * [Error Handling](#error-handling)
    * [Server Selection](#server-selection)
    * [Custom HTTP Client](#custom-http-client)
    * [Debugging](#debugging)
  * [Development](#development)
    * [Maturity](#maturity)
    * [Contributions](#contributions)

  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install duckyai
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add duckyai
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from duckyai import DuckyAI
  import os

  with DuckyAI(
      api_key=os.getenv("DUCKYAI_API_KEY", ""),
  ) as ducky_ai:

      res = ducky_ai.ducky.list_indexes()

      
      print(res)
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from duckyai import DuckyAI
  import os

  async def main():
      async with DuckyAI(
          api_key=os.getenv("DUCKYAI_API_KEY", ""),
      ) as ducky_ai:

          res = await ducky_ai.ducky.list_indexes_async()

          
          print(res)

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name      | Type   | Scheme  | Environment Variable |
  | --------- | ------ | ------- | -------------------- |
  | `api_key` | apiKey | API key | `DUCKYAI_API_KEY`    |

  To authenticate with the API the `api_key` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from duckyai import DuckyAI
  import os

  with DuckyAI(
      api_key=os.getenv("DUCKYAI_API_KEY", ""),
  ) as ducky_ai:

      res = ducky_ai.ducky.list_indexes()

      
      print(res)

  ```
  <!-- End Authentication [security] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>



  * [list_indexes](docs/sdks/ducky/README.md#list_indexes) - List indexes within a project
  * [create_index](docs/sdks/ducky/README.md#create_index) - Create an index
  * [delete_index](docs/sdks/ducky/README.md#delete_index) - Delete an index
  * [index_text](docs/sdks/ducky/README.md#index_text) - Index a document from text content
  * [delete_document](docs/sdks/ducky/README.md#delete_document) - Delete a document
  * [get_document](docs/sdks/ducky/README.md#get_document) - Get a document by ID with pagination
  * [retrieve_documents](docs/sdks/ducky/README.md#retrieve_documents) - Retrieve documents from an index


  </details>
  <!-- End Available Resources and Operations [operations] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from duckyai import DuckyAI
  from duckyai.utils import BackoffStrategy, RetryConfig
  import os

  with DuckyAI(
      api_key=os.getenv("DUCKYAI_API_KEY", ""),
  ) as ducky_ai:

      res = ducky_ai.ducky.list_indexes(,
          RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

      
      print(res)

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from duckyai import DuckyAI
  from duckyai.utils import BackoffStrategy, RetryConfig
  import os

  with DuckyAI(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      api_key=os.getenv("DUCKYAI_API_KEY", ""),
  ) as ducky_ai:

      res = ducky_ai.ducky.list_indexes()

      
      print(res)

  ```
  <!-- End Retries [retries] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a models.APIError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `list_indexes_async` method may raise the following exceptions:

  | Error Type           | Status Code | Content Type     |
  | -------------------- | ----------- | ---------------- |
  | models.ErrorResponse | 400         | application/json |
  | models.APIError      | 4XX, 5XX    | \*/\*            |



  ```python
  from duckyai import DuckyAI, models
  import os

  with DuckyAI(
      api_key=os.getenv("DUCKYAI_API_KEY", ""),
  ) as ducky_ai:
      res = None
      try:

          res = ducky_ai.ducky.list_indexes()

          
          print(res)

      except models.ErrorResponse as e:
          
          raise(e)
      except models.APIError as e:
          
          raise(e)
  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from duckyai import DuckyAI
  import os

  with DuckyAI(
      server_url="https://${BACKEND_ADDRESS}/",
      api_key=os.getenv("DUCKYAI_API_KEY", ""),
  ) as ducky_ai:

      res = ducky_ai.ducky.list_indexes()

      
      print(res)

  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from duckyai import DuckyAI
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = DuckyAI(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from duckyai import DuckyAI
  from duckyai.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = DuckyAI(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from duckyai import DuckyAI
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = DuckyAI(debug_logger=logging.getLogger("duckyai"))
  ```

  You can also enable a default debug logger by setting an environment variable `DUCKYAI_DEBUG` to true.
  <!-- End Debugging [debug] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation.
  We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.


pkgId: 70cfe3a2c7fa69d470bd45a9c9a47290a48568ea658da16e9d91ee9d5306c24a
name: python-dulwich-debuginfo
arch: aarch64
version: 0.22.7
epoch: 0
release: 1
summary: Debug information for package python-dulwich
url: https://www.dulwich.io/
rpm_license: Apachev2 or later or GPLv2
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-dulwich-0.22.7-1.src.rpm
location_href: Packages/python-dulwich-debuginfo-0.22.7-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-dulwich.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: b9db3ec5faedb6e0c00d59319105f32a4753ad63556a8af55869087e99e9a226
name: python-dulwich-debugsource
arch: aarch64
version: 0.22.7
epoch: 0
release: 1
summary: Debug sources for package python-dulwich
url: https://www.dulwich.io/
rpm_license: Apachev2 or later or GPLv2
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-dulwich-0.22.7-1.src.rpm
location_href: Packages/python-dulwich-debugsource-0.22.7-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-dulwich.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 14f6fa56101c3b19a8068ffac97d1e0e7ced403f376703ba3e6afced72ae8a8d
name: python-dulwich-help
arch: aarch64
version: 0.22.7
epoch: 0
release: 1
summary: Development documents and examples for dulwich
url: https://www.dulwich.io/
rpm_license: Apachev2 or later or GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dulwich-0.22.7-1.src.rpm
location_href: Packages/python-dulwich-help-0.22.7-1.aarch64.rpm
checksum_type: sha256
description:
  This is the Dulwich project.
  It aims to provide an interface to git repos (both local and remote) that
  doesn't call out to git directly but instead uses pure Python.
  **Main website**: <https://www.dulwich.io/>
  **License**: Apache License, version 2 or GNU General Public License, version 2 or later.
  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
  The project is named after the part of London that Mr. and Mrs. Git live in
  the particular Monty Python sketch.


pkgId: 103da46306ba23b3dc942c7095447cf2d0b97d118658dc78f115052793756860
name: python-dumpyara-help
arch: noarch
version: 1.0.9
epoch: 0
release: 1
summary: Development documents and examples for dumpyara
url: https://github.com/sebaubuntu-python/dumpyara
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dumpyara-1.0.9-1.src.rpm
location_href: Packages/python-dumpyara-help-1.0.9-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/dumpyara)](https://pypi.org/project/dumpyara/)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/85d2c39edbed4dc38f680db01f7b83af)](https://www.codacy.com/gh/sebaubuntu-python/dumpyara/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=sebaubuntu-python/dumpyara&amp;utm_campaign=Badge_Grade)

  Requires Python 3.8 or greater



  ```sh
  pip3 install dumpyara
  ```



  ```sh
  python3 -m dumpyara <path to OTA file>
  ```




  -   All the ones supported by shutil's extract_archive
  -   Samsung's `.tar.md5` archives
  -   Nested archives


  -   A-only OTAs (Brotli and/or sdat compressed)
  -   A/B OTAs
  -   Dynamic partitions (super.img)
  -   payload.bin
  -   Raw images (e.g. Xiaomi fastboot packages)
  -   Sparse images
  -   LZ4 images


  -   Android boot images
  -   7z supported archives/images
  -   EROFS images using erofs-utils


  -   AIK: osm0sis
  -   [extract_android_ota_payload](https://github.com/erfanoabdi/extract_android_ota_payload): cyxx and erfanoabdi
  -   sdat2img: xpirt



  ```





  ```


pkgId: 3dc35c5384df723987e5f3a2159deda09c594a62727a832f3f84c5baff6fdf1f
name: python-duowen-agent-help
arch: noarch
version: 0.1.11
epoch: 0
release: 1
summary: Development documents and examples for duowen-agent
url: https://pypi.org/project/duowen-agent/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-duowen-agent-0.1.11-1.src.rpm
location_href: Packages/python-duowen-agent-help-0.1.11-1.noarch.rpm
checksum_type: sha256
description:
  LLM核心开发包





  ```python
  from duowen_agent.llm import OpenAIChat
  from os import getenv

  llm_cfg = {"model": "THUDM/glm-4-9b-chat", "base_url": "https://api.siliconflow.cn/v1",
             "api_key": getenv("SILICONFLOW_API_KEY")}

  _llm = OpenAIChat(**llm_cfg)

  print(_llm.chat('''If you are here, please only reply "1".'''))

  for i in _llm.chat_for_stream('''If you are here, please only reply "1".'''):
      print(i)

  ```





  ```python
  from duowen_agent.llm import OpenAIEmbedding
  from os import getenv

  emb_cfg = {"model": "BAAI/bge-large-zh-v1.5", "base_url": "https://api.siliconflow.cn/v1",
             "api_key": getenv("SILICONFLOW_API_KEY")}

  _emb = OpenAIEmbedding(**emb_cfg)
  print(_emb.get_embedding('123'))
  print(_emb.get_embedding(['123', '456']))
  ```



  ```python
  from duowen_agent.llm import OpenAIEmbedding, EmbeddingCache
  from os import getenv
  from duowen_agent.utils.cache import Cache
  from redis import StrictRedis
  from typing import List, Optional, Any

  emb_cfg = {"model": "BAAI/bge-large-zh-v1.5", "base_url": "https://api.siliconflow.cn/v1",
             "api_key": getenv("SILICONFLOW_API_KEY")}

  _emb = OpenAIEmbedding(**emb_cfg)

  redis = StrictRedis(host='127.0.0.1', port=6379)


  class RedisCache(Cache):
      
      def __init__(self, redis_cli: StrictRedis):
          self.redis_cli = redis_cli
          super().__init__()

      def set(self, key, value, expire=60):
          return self.redis_cli.set(key, value, ex=expire)

      def mget(self, keys: List[str]) -> List[Optional[Any]]:
          return self.redis_cli.mget(keys)

      def get(self, key: str) -> Optional[Any]:
          return self.redis_cli.get(key)

      def delete(self, key: str):
          return self.redis_cli.delete(key)

      def exists(self, key: str) -> bool:
          return self.redis_cli.exists(key)

      def clear(self):
          raise InterruptedError("不支持")


  embedding_cache = EmbeddingCache(RedisCache(redis), _emb)
  print(embedding_cache.get_embedding('hello world'))
  for i in embedding_cache.get_embedding(['sadfasf', 'hello world']):
      print(i)
  ```


  ```python
  from duowen_agent.llm import GeneralRerank
  from os import getenv
  import tiktoken

  rerank_cfg = {
      "model": "BAAI/bge-reranker-v2-m3",
      "base_url": "https://api.siliconflow.cn/v1/rerank",
      "api_key": getenv("SILICONFLOW_API_KEY")}

  rerank = GeneralRerank(
      model=rerank_cfg["model"],
      api_key=rerank_cfg["api_key"],
      base_url=rerank_cfg["base_url"],
      encoding=tiktoken.get_encoding("o200k_base")
  )

  data = rerank.rerank(query='Apple', documents=["苹果", "香蕉", "水果", "蔬菜"], top_n=3)
  for i in data:
      print(i)
  ```


pkgId: fc2648082ba02069d807ef971677dab64c89d44a94795c42a9ac4eb7256535e4
name: python-duplicate_images-help
arch: noarch
version: 0.11.4
epoch: 0
release: 1
summary: Development documents and examples for duplicate_images
url: https://github.com/lene/DuplicateImages
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-duplicate_images-0.11.4-1.src.rpm
location_href: Packages/python-duplicate_images-help-0.11.4-1.noarch.rpm
checksum_type: sha256
description:
  Finds equal or similar images in a directory containing (many) image files.

  Official home page: https://github.com/lene/DuplicateImages

  Development page: https://gitlab.com/lilacashes/DuplicateImages

  PyPI page: https://pypi.org/project/duplicate-images



  Installing:
  ```shell
  $ pip install duplicate_images
  ```

  Printing the help screen:
  ```shell
  $ find-dups -h
  ```

  Quick test run:
  ```shell
  $ find-dups $IMAGE_ROOT
  ```

  Typical usage:
  ```shell
  $ find-dups $IMAGE_ROOT --parallel --progress --hash-db hashes.json
  ```



  * JPEG and PNG (tested quite thoroughly)
  * HEIC (experimental support, tested cursorily only)
  * All other
    [formats supported](https://pillow.readthedocs.io/en/latest/handbook/image-file-formats.html) by
    the `pillow` Python Imaging Library should work, but are not specifically tested.



  The `PIL` image library, which is used as backend, limits the size of images to 178956970 pixels by
  default, to guard against memory exhaustion. For larger images, specify the maximum image size in
  pixels with the `--max-image-pixels` option.



  Use the `--algorithm` option to select how equal images are found. The default algorithm is `phash`.

  `ahash`, `colorhash`, `dhash`, `dhash_vertical`, `phash`, `phash_simple`, `whash`: seven different
  image hashing algorithms. See https://pypi.org/project/ImageHash for an introduction on image
  hashing and https://tech.okcupid.com/evaluating-perceptual-image-hashes-okcupid for some gory
  details which image hashing algorithm performs best in which situation. For a start I recommend
  using `phash`, and only evaluating the other algorithms if `phash` does not perform satisfactorily
  in your use case.



  Use the `--hash-size` parameter to tune the precision of the hashing algorithms. For the `colorhash`
  algorithm the hash size is interpreted as the number of bin bits and defaults to 3. For all other
  algorithms the hash size defaults to 8. For `whash` it must be a power of 2.

  Use the `--max-distance` parameter to tune how close images should be to be considered duplicates.
  The argument is a positive integer. Its value is highly dependent on the algorithm used and the
  nature of the images compared, so the best value for your use case can oly be found through
  experimentation.

  **NOTE:** using the `--max-distance` parameter slows down the comparison considerably with large
  image collections, making the runtime complexity go from O(N) to O(N<sup>2</sup>). If you want to
  scan collections with at least thousands of images, it is highly recommended to tune the desired
  similarity threshold with the `--hash-size` parameter alone, if that is at all possible.
  The '--max-distance' parameter it's incompatible with --group parameter.

  **NOTE:** the `--max-distance` parameter conflicts with tho `--group` parameter. You can only use
  one at a time.



  Use the `--hash-db ${FILE}.json` or `--hash-db ${FILE}.pickle` option to store image hashes in the
  file `$FILE` in JSON or Pickle format and read image hashes from that file if they are already
  present there. This avoids having to compute the image hashes anew at every run and can
  significantly speed up run times.



  By default, matching images are presented as pairs. With the `--group` CLI option, they are handled
  as a group containing all matching images.

  Example: `1.jpg`, `2.jpg` and `3.jpg` in the current folder `.` are equal.

  ```shell
  $ find-dups .
  1.jpg 2.jpg
  1.jpg 3.jpg
  2.jpg 3.jpg
  $ find-dups . --group
  1.jpg 2.jpg 3.jpg
  ```



  Use the `--on-equal` option to select what to do to pairs of equal images. The default action is
  `print`.
  - `delete-first` or `d1`: deletes the first of the files in the group
  - `delete-last` or `dl`: deletes the last of the files in the group
  - `delete-biggest` or `d>`: deletes the file with the biggest size
  - `delete-smallest` or `d<`: deletes the file with the smallest size
  - `symlink-smaller`: delete the smaller files and replace them to a symlink to the biggest file
  - `eog`: launches the `eog` image viewer to compare the files in the group (*deprecated* by `exec`)
  - `xv`: launches the `xv` image viewer to compare the files in the group (*deprecated* by `exec`)
  - `print`: prints the files in the group
  - `print_inline`: like `print` but without newline
  - `quote`: prints the files in the group quoted for POSIX shells
  - `quote_inline`: like `quote` but without newline
  - `exec`: executes a command (see `--exec` argument below)
  - `none`: does nothing; may be useful for benchmarking and testing

  The `--exec` argument allows calling another program when the `--on-equal exec` option is given.
  You can pass a command line string like `--exec "program {1} {2}"` where `{1}` and `{2}` are
  replaced by the matching pair files (or first two files in a group), quoted so the shell recognizes
  the files properly. The wildcard `{*}` expands to all files in a matching group, which when called
  with the `--group` argument may be more than two images considered equal.


  * `--exec "open -a Preview -W {1} {2}"`: Opens the files in MacOS Preview app and waits for it.
  * `--exec "ls -s {*}"`: Prints the size (in blocks) next to all files.
  * `--exec 'for i in {*}; do dirname $i; basename $i; done'`: Shows the directory and the filename
    separately for all files.



  Use the `--parallel` option to utilize all free cores on your system for calculating image hashes.
  Optionally, you can specify the number of processes to use with `--parallel $N`.

  To execute the `--on-equal` actions in parallel, use the `--parallel-actions` option, which also can
  take an optional number of processes to use as argument.



  Use the `--exclude-dir` option to exclude subfolders of `$IMAGE_ROOT` from the search. The argument
  is a regular expression matching the subfolder names to be excluded. Multiple arguments can be
  passed to `--exclude-dir` to exclude multiple subfolders.

  The argument(s) given to `--exclude-dir` may be regular expressions. These regular expressions are
  matched only against the directory name, not the file name.



  Exclude subfolder `$IMAGE_ROOT/foo`:
  ```shell
  $ find-dups $IMAGE_ROOT --exclude-dir $IMAGE_ROOT/foo
  ```
  Exclude all subfolders named `foo` or `bar`:
  ```shell
  $ find-dups $IMAGE_ROOT --exclude-dir foo bar
  ```



  `find-dups` can also use an alternative algorithm which exhaustively compares all images to each
  other, being O(N<sup>2</sup>) in the number of images. This algorithm is selected automatically if
  `--max-distance` is not 0.

  You can use the `--slow` option to use this alternative algorithm specifically. The `--slow` switch
  is mutually exclusive with the `--group` switch.



  - `--progress` prints a progress bar each for the process of reading the images, and the process of
    finding duplicates among the scanned image
  - `--debug` prints debugging output
  - `--quiet` decreases the log level by 1 for each time it is called; `--debug` and `--quiet` cancel
    each other out



  Needs Python3, Pillow imaging library and `pillow-heif` HEIF plugin to run, additionally Wand for
  the test suite.

  Uses Poetry for dependency management.



  From source:
  ```shell
  $ git clone https://gitlab.com/lilacashes/DuplicateImages.git
  $ cd DuplicateImages
  $ pip3 install poetry
  $ poetry install
  ```



  ```shell
  $ poetry run find-dups $PICTURE_DIR
  ```
  or
  ```shell
  $ poetry run find-dups -h
  ```
  for a list of all possible options.



  Running it all:
  ```shell
  $ poetry run pytest
  $ poetry run mypy duplicate_images tests
  $ poetry run flake8
  $ poetry run pylint duplicate_images tests
  $ poetry run bandit -r duplicate_images
  ```
  or simply
  ```shell
  $ .git_hooks/pre-push
  ```
  Setting the test suite to be run before every push:
  ```shell
  $ cd .git/hooks
  $ ln -s ../../.git_hooks/pre-push .
  ```



  A tag is created and the new version is published automatically by GitLab CI on every successful
  merge to `master`.



  For every Merge Request to `master` it is checked that:
  - the `version` number in `pyproject.toml` is not an already existing git tag
  - the `CHANGELOG.md` contains an entry for the current version number



  There is a job in GitLab CI for publishing to `pypi.org` that runs as soon as a new tag is added,
  which happens automatically whenever a MR is merged. The tag is the same as the `version` in the
  `pyproject.toml` file. For every MR it needs to be ensured that the `version` is not the same as an
  already existing tag.

  To publish the package on PyPI manually:
  ```shell
  $ poetry config repositories.testpypi https://test.pypi.org/legacy/
  $ poetry build
  $ poetry publish --username $PYPI_USER --password $PYPI_PASSWORD --repository testpypi && \
    poetry publish --username $PYPI_USER --password $PYPI_PASSWORD
  ```
  (obviously assuming here that username and password are the same on PyPI and TestPyPI)



  The GitHub repo `git@github.com:lene/DuplicateImages.git` is set up as a push mirror in GitLab CI,
  but mirroring is flaky at the time and may or may not succeed. The CI job `PushToGithub` should take
  care of mirroring to GitHub after every merge to `master`.

  To push to the GitHub repository manually (assuming the GitHub repo is set up as remote `github`):
  ```shell
  $ git checkout master
  $ git fetch
  $ git pull --rebase
  $ git tag  # to check that the latest tag is present
  $ git push --tags github master
  ```



  The CI job `CreateGithubRelease` creates a Release on GitHub, which can then be found under
  https://github.com/lene/DuplicateImages/releases.




  To show the top functions by time spent, including called functions:
  ```shell
  $ poetry run python -m cProfile -s tottime ./duplicate_images/duplicate.py \
      --algorithm $ALGORITHM --action-equal none $IMAGE_DIR 2>&1 | head -n 15
  ```
  or, to show the top functions by time spent in the function alone:
  ```shell
  $ poetry run python -m cProfile -s cumtime ./duplicate_images/duplicate.py \
      --algorithm $ALGORITHM --action-equal none $IMAGE_DIR 2>&1 | head -n 15
  ```


  ```shell
  $ poetry run fil-profile run ./duplicate_images/duplicate.py \
      --algorithm $ALGORITHM --action-equal none $IMAGE_DIR 2>&1
  ```
  This will open a browser window showing the functions using the most memory (see
  https://pypi.org/project/filprofiler for more details).



  - Lene Preuss (https://github.com/lene): primary developer
  - Mike Reiche (https://github.com/mreiche): support for arbitrary actions, speedups
  - https://github.com/beijingjazzpanda: bug fix


pkgId: 3665cb280ab425eea4d21444dc01765c3693c7bfd44e4cdad781c08b82a68265
name: python-durkinza.cdk-networkfirewall-l2-help
arch: noarch
version: 0.0.12
epoch: 0
release: 1
summary: Development documents and examples for durkinza.cdk-networkfirewall-l2
url: https://github.com/durkinza/cdk-networkfirewall-l2#readme
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-durkinza.cdk-networkfirewall-l2-0.0.12-1.src.rpm
location_href: Packages/python-durkinza.cdk-networkfirewall-l2-help-0.0.12-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
      <h1> AWS CDK Network Firewall L2 </h1>
  This repo holds some experimental L2 constructs for the

  [AWS-CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_networkfirewall-readme.html)
  <br/>

  [![release](https://github.com/durkinza/cdk-networkfirewall-l2/actions/workflows/release.yml/badge.svg?branch=main)](https://github.com/durkinza/cdk-networkfirewall-l2/actions/workflows/release.yml)

  [![View on Construct Hub](https://constructs.dev/badge?package=%40durkinza%2Fcdk-networkfirewall-l2)](https://constructs.dev/packages/@durkinza/cdk-networkfirewall-l2)

  </div>---




  AWS Network Firewall is a stateful, managed, network firewall and intrusion detection and prevention service.
  These L2 Constructs can be used to create managed network firewalls with stateful and stateless rules and rule groups.

  The goal of these constructs is to provide a way to decouple the creation of firewall rules from their rule groups and reduce the amount of boilerplate code required to define a network firewall.

  The ideal examples shown below provide only the parameters required to create a resource.
  Wherever possible, optional parameters are available to give the same level of customization as the L1 API.



  To keep the constructs unopinionated, default actions are required for deployment of new resources.
  It may be possible to reduce boilerplate code more if default actions were to be defined.
  Some examples of possible opinionated approaches:

  An unobtrusive logging approach, to promote implementation of network firewalls in existing stacks.

  > When a parameter in an L2 construct is optional, where it would normally be required for an L1 construct, an unobtrusive and logging default option would be implied. This allows resources to be implemented in an existing stack with minimal obstruction to the existing operation of the stack.
  > After implementing a network firewall with logging defaults in a testing environment, a user can define a standard of "normal traffic" for their environment and implement firewall rules and default actions to restrict traffic.

  A more obtrusive, but higher security approach could be:

  > When a parameter in an L2 construct is optional, where it would normally be required for an L1 construct, a default drop rule would be implied. This ensures traffic that is not specifically allowed is blocked, a user would need to define rules to allow the traffic that is expected in their environment.

  For new policies, it would also be possible to mirror the defaults set for security groups, where a default action of drop is set, with a single stateless rule being set to allow all outbound traffic. This approach would require generating an entire set of Policy, Stateless group, and stateless rule.

  In any case a user can overwrite the default action(s) and create their own policies and rules as they see fit.
  Given the relatively small amount of code required to define the resources with default actions, I would opt to leave the code unopinionated for the first revision, as defaults can be specified in a later revision if needed.



  An ideal implementation would allow users to create firewall with minimal boiler plate.

  ```python
  const policy = NetFW.FirewallPolicy.fromFirewallPolicyName(stack, 'MyNetworkFirewallPolicy', 'MyFirewallPolicy');
  new NetFW.Firewall(stack, 'MyNetworkFirewall', {
    vpc: vpc,
    policy: policy,
  });
  ```

  Where the firewall would be created in the provided vpc with the given firewall policy applied.

  In this example, `policy` is defined only to meet the requirement that a firewall must have a firewall policy attached.
  As explained in the Defaults section above, it may be possible to generate a default policy when one is not provided.



  Firewall policy definitions can be done by referencing an existing name/ARN as shown in the last example, or by generating a new policy.
  Since a policy does not require rule groups to be attached, it will only need a few requirements to get started.

  ```python
  new NetFW.FirewallPolicy(stack, 'MyNetworkFirewallPolicy', {
    statelessDefaultActions: [NetFW.StatelessStandardAction.DROP],
    statelessFragmentDefaultActions: [NetFW.StatelessStandardAction.DROP],
  });
  ```

  Editing an existing Policy (e.x. adding a rule group to an existing policy that has been referenced via ARN) would be out of scope.

  When applying rule groups to a policy, a unique priority of must be provided for each group.

  ```python
  const statelessRuleGroupList:NetFW.StatelessRuleGroupList[] = [
    {
      priority: 10,
      ruleGroup: statelessRuleGroup1,
    },
  ];
  const statefulRuleGroupList:NetFW.StatefulRuleGroupList[] = [
    {
      priority: 10,
      ruleGroup: statefulRuleGroup1,
    },
    {
      priority: 20,
      ruleGroup: statefulRuleGroup2,
    },
    {
      priority: 30,
      ruleGroup: statefulRuleGroup3,
    },
  ];
  const policy = new NetFW.FirewallPolicy(stack, 'MyNetworkFirewallPolicy', {
    statelessDefaultActions: [NetFW.StatelessStandardAction.DROP],
    statelessFragmentDefaultActions: [NetFW.StatelessStandardAction.DROP],
    statelessRuleGroups: statelessRuleGroupList,
    statefulRuleGroups: statefulRuleGroupList,
  });
  ```



  Stateless firewall rule groups can be defined by referencing an existing name/ARN, or by generating a new group.
  New groups don't require any rules to be defined, so their implementation can be fairly quick.

  ```python
  new NetFW.StatelessRuleGroup(stack, 'MyStatelessRuleGroup');
  ```

  The capacity requirements of a stateless rule group is fairly trivial to determine programmatically, but it can't be edited throughout the life time of the rule group. ([ref](https://docs.aws.amazon.com/network-firewall/latest/developerguide/rule-group-managing.html#nwfw-rule-group-capacity))
  The stateless rule group could programmatically determine the capacity required for the rules assigned to it when no capacity is provided. Using the exact capacity requirements for a rule group by default may cause the user issues later if they decide to add another rule to the group.

  Editing an existing rule-group (e.x. adding a rule to an existing group referenced via ARN) would be out of scope.



  Stateless rules are not defined as a resource in AWS, they only exist in the context of the rule group they are defined in.
  To allow stateless rules to be decoupled from the rule group throughout the stack, they are defined as their own class, but reduce down to a L1 `RuleDefinitionProperty`

  ```python
  new NetFW.StatelessRule({
    actions: [NetFW.StatelessStandardAction.DROP]
  });
  ```

  Assigning stateless rules to a stateless rule-group requires a priority mapping, similar to the way a rule-group requires a priority map when assigned to a policy.

  ```python
  const statelessRule1 = new NetFW.StatelessRule({
    actions: [NetFW.StatelessStandardAction.DROP],
  });
  const statelessRule2 = new NetFW.StatelessRule({
    actions: [NetFW.StatelessStandardAction.DROP],
  });
  new NetFW.StatelessRuleGroup(stack, 'MyStatelessRuleGroup', {
    rules: [
      {
        rule: statelessRule1,
        priority: 10,
      },
      {
        rule: statelessRule2,
        priority: 20,
      },
    ],
  });
  ```



  Stateful firewall rules are split into 3 categories (5Tuple, Suricata, Domain List).
  The console requires the category of rules to be defined when creating the rule group.
  However, from my understanding, the L1 constructs reduced all 3 down into Suricata rules. So a single stateful rule group could hold a mix of all 3 types of rules.

  It appeared easier to merge the three types in a future revision than to split them apart if the requirements happened to change.
  I opted to match the AWS console, giving each rule group category has it's own class. Stateful rule groups are based on the same abstract class, to reduce duplicate code.

  Stateful rule groups can be defined with no actionable rules within them, so the minimal implementation would be the same for all of them.

  ```python
  new NetFW.Stateful5TupleRuleGroup(stack, 'MyStateful5TupleRuleGroup', {
    // Assumes the following
    // rules: None
    // ruleOrder: NetFW.StatefulRuleOptions.DEFAULT_ACTION_ORDER,
    // capacity: 100
  });
  new NetFW.StatefulDomainListRuleGroup(stack, 'MyStatefulDomainListRuleGroup', {
    // Assumes the following
    // rule: None
    // ruleOrder: NetFW.StatefulRuleOptions.DEFAULT_ACTION_ORDER,
    // capacity: 100
  });
  new NetFW.StatefulSuricataRuleGroup(stack, 'MyStatefulSuricataRuleGroup', {
    // Assumes the following
    // rules: ""
    // ruleOrder: NetFW.StatefulRuleOptions.DEFAULT_ACTION_ORDER,
    // capacity: 100
  });
  ```



  To define a stateful 5tuple rule, all parameters must be provided to the L1 construct. In most cases the ANY keyword is used to generalize the rule as much as possible by default. Allowing the user to narrow down the rule as needed. A default action must be specified to determine what the rule does when it matches the traffic.

  ```python
  new NetFW.Stateful5TupleRule({
    action: NetFW.StatefulStandardAction.DROP,
    // Assumes the following
    // destination: 'ANY',
    // destinationPort: 'ANY',
    // direction: 'ANY',
    // protocol: 'IP',
    // source: 'ANY',
    // sourcePort: 'ANY',
    // ruleOptions: None
  });
  ```

  When adding the stateful 5Tuple rule to a stateful5Tuple rule-group, no priority is required, the ruleOrder assigned to the rule-group will be used.

  ```python
  const stateful5TupleRule1 = new NetFW.Stateful5TupleRule({
    action: NetFW.StatefulStandardAction.DROP,
  });
  const stateful5TupleRule2 = new NetFW.Stateful5TupleRule({
    action: NetFW.StatefulStandardAction.PASS,
  });
  new NetFW.Stateful5TupleRuleGroup(stack, 'MyStateful5TupleRuleGroup', {
    capacity: 100,
    rules: [stateful5TupleRule1, stateful5TupleRule2],
  });
  ```



  When defining a Domain List, only a single set of targets can be provided, as set by the L1 construct.
  All Domain List specific parameters are required for this rule.

  ```python
    const statefulDomainListRule = new NetFW.StatefulDomainListRule({
      type: NetFW.StatefulDomainListType.ALLOWLIST,
      targets: ["example.com"],
      targetTypes: [StatefulDomainListTargetType.HTTP_HOST],
    });
  ```



  Suricata rules are just strings, so they don't have a class type, they are defined directly into the suricata rule-group.

  ```python
  new NetFW.StatefulSuricataRuleGroup(stack, 'MyStatefulSuricataRuleGroup', {
    rules: 'drop tls $HOME_NET any -> $EXTERNAL_NET any (tls.sni; content:"evil.com"; startswith; nocase; endswith; msg:"matching TLS denylisted FQDNs"; priority:1; flow:to_server, established; sid:1; rev:1;)
            drop http $HOME_NET any -> $EXTERNAL_NET any (http.host; content:"evil.com"; startswith; endswith; msg:"matching HTTP denylisted FQDNs"; priority:1; flow:to_server, established; sid:2; rev:1;)'
  });
  ```

  Suricata rule groups can also be imported from a file.

  ```python
  const ruleGroup:NetFW.StatefulSuricataRuleGroup = NetFW.StatefulSuricataRuleGroup.fromFile(stack, 'MyStatefulSuricataRuleGroup', {
        path: './suricata.rules'
  });
  ```

  All other arguments for creating a Suricata Rule Group are also supported here with an exception of the `rules` property.
  The `rules` property will be filled in with the contents from the file path, anything supplied will be ignored.



  Logging can be done using 3 AWS services, Cloud Watch trails, S3 buckets, and Kinesis Data Firehose streams.

  The logging locations are configured with a Logging type, either Flow or Alert logs.
  In the case of Alert logs, it is up to the firewall policy to decide when a log should be generated.

  Logs can be configured to be sent to multiple locations simultaneously.

  ```python
  new NetFW.Firewall(stack, 'MyNetworkFirewall', {
    vpc: vpc,
    policy: policy,
    loggingCloudWatchLogGroups: [
      {
        logGroup: logGroup.logGroupName,
        logType: NetFW.LogType.ALERT,
      },
    ],
    loggingS3Buckets: [
      {
        bucketName: s3LoggingBucket.bucketName,
        logType: NetFW.LogType.ALERT,
        prefix: 'alerts',
      },
      {
        bucketName: s3LoggingBucket.bucketName,
        logType: NetFW.LogType.FLOW,
        prefix: 'flow',
      },
    ],
    loggingKinesisDataStreams: [
      {
        deliveryStream: kinesisStream.streamName,
        logType: NetFW.LogType.ALERT,
      }
    ],
  });
  ```


pkgId: b3daa2715ced79a8f57b923173f2de00fce40a55df14fcb1b72142955913181c
name: python-dvclive-help
arch: noarch
version: 3.48.1
epoch: 0
release: 1
summary: Development documents and examples for dvclive
url: https://github.com/iterative/dvclive
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dvclive-3.48.1-1.src.rpm
location_href: Packages/python-dvclive-help-3.48.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/dvclive.svg)](https://pypi.org/project/dvclive/)
  [![Status](https://img.shields.io/pypi/status/dvclive.svg)](https://pypi.org/project/dvclive/)
  [![Python Version](https://img.shields.io/pypi/pyversions/dvclive)](https://pypi.org/project/dvclive)
  [![License](https://img.shields.io/pypi/l/dvclive)](https://opensource.org/licenses/Apache-2.0)

  [![Tests](https://github.com/iterative/dvclive/workflows/Tests/badge.svg?branch=main)](https://github.com/iterative/dvclive/actions?workflow=Tests)
  [![Codecov](https://codecov.io/gh/iterative/dvclive/branch/main/graph/badge.svg)](https://app.codecov.io/gh/iterative/dvclive)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  DVCLive is a Python library for logging machine learning metrics and other
  metadata in simple file formats, which is fully compatible with DVC.



  - [Get Started](https://dvc.org/doc/start/experiments)
  - [How it Works](https://dvc.org/doc/dvclive/how-it-works)
  - [API Reference](https://dvc.org/doc/dvclive/live)
  - [Integrations](https://dvc.org/doc/dvclive/ml-frameworks)

  ______________________________________________________________________



  | Python API Overview | PyTorch Lightning | Scikit-learn | Ultralytics YOLO v8 |
  |--------|--------|--------|--------|
  | <a href="https://colab.research.google.com/github/iterative/dvclive/blob/main/examples/DVCLive-Quickstart.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" /></a> | <a href="https://colab.research.google.com/github/iterative/dvclive/blob/main/examples/DVCLive-PyTorch-Lightning.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" /></a> | <a href="https://colab.research.google.com/github/iterative/dvclive/blob/main/examples/DVCLive-scikit-learn.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" /></a> | <a href="https://colab.research.google.com/github/iterative/dvclive/blob/main/examples/DVCLive-YOLO.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" /></a> |



  ```console
  $ pip install dvclive
  ```



  ```console
  $ git init
  $ dvc init
  $ git commit -m "DVC init"
  ```



  Copy the snippet below into `train.py` for a basic API usage example:

  ```python
  import time
  import random

  from dvclive import Live

  params = {"learning_rate": 0.002, "optimizer": "Adam", "epochs": 20}

  with Live() as live:

      
      for param in params:
          live.log_param(param, params[param])

      
      offset = random.uniform(0.2, 0.1)
      for epoch in range(1, params["epochs"]):
          fuzz = random.uniform(0.01, 0.1)
          accuracy = 1 - (2 ** - epoch) - fuzz - offset
          loss = (2 ** - epoch) + fuzz + offset

          
          live.log_metric("accuracy", accuracy)
          live.log_metric("loss", loss)
          live.next_step()
          time.sleep(0.2)
  ```

  See [Integrations](https://dvc.org/doc/dvclive/ml-frameworks) for examples using
  DVCLive alongside different ML Frameworks.



  Run this a couple of times to simulate multiple experiments:

  ```console
  $ python train.py
  $ python train.py
  $ python train.py
  ...
  ```



  DVCLive outputs can be rendered in different ways:



  You can use [dvc exp show](https://dvc.org/doc/command-reference/exp/show) and
  [dvc plots](https://dvc.org/doc/command-reference/plots) to compare and
  visualize metrics, parameters and plots across experiments:

  ```console
  $ dvc exp show
  ```

  ```
  ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
  Experiment                 Created    train.accuracy   train.loss   val.accuracy   val.loss   step   epochs
  ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
  workspace                  -                  6.0109      0.23311          6.062    0.24321      6   7
  master                     08:50 PM                -            -              -          -      -   -
  ├── 4475845 [aulic-chiv]   08:56 PM           6.0109      0.23311          6.062    0.24321      6   7
  ├── 7d4cef7 [yarer-tods]   08:56 PM           4.8551      0.82012         4.5555   0.033533      4   5
  └── d503f8e [curst-chad]   08:56 PM           4.9768     0.070585         4.0773    0.46639      4   5
  ─────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ```

  ```console
  $ dvc plots diff $(dvc exp list --names-only) --open
  ```

  ![dvc plots diff](./docs/dvc_plots_diff.png)



  Inside the
  [DVC Extension for VS Code](https://marketplace.visualstudio.com/items?itemName=Iterative.dvc),
  you can compare and visualize results using the
  [Experiments](https://github.com/iterative/vscode-dvc/blob/main/extension/resources/walkthrough/experiments-table.md)
  and
  [Plots](https://github.com/iterative/vscode-dvc/blob/main/extension/resources/walkthrough/plots.md)
  views:

  ![VSCode Experiments](./docs/vscode_experiments.png)

  ![VSCode Plots](./docs/vscode_plots.png)

  While experiments are running, live updates will be displayed in both views.



  If you push the results to [DVC Studio](https://dvc.org/doc/studio), you can
  compare experiments against the entire repo history:

  ![Studio Compare](./docs/studio_compare.png)

  You can enable
  [Studio Live Experiments](https://dvc.org/doc/studio/user-guide/projects-and-experiments/live-metrics-and-plots)
  to see live updates while experiments are running.

  ______________________________________________________________________



  **DVCLive** is an *ML Logger*, similar to:

  - [MLFlow](https://mlflow.org/)
  - [Weights & Biases](https://wandb.ai/site)
  - [Neptune](https://neptune.ai/)

  The main differences with those *ML Loggers* are:

  - **DVCLive** does not **require** any additional services or servers to run.
  - **DVCLive** metrics, parameters, and plots are
    [stored as plain text files](https://dvc.org/doc/dvclive/how-it-works#directory-structure)
    that can be versioned by tools like Git or tracked as pointers to files in DVC
    storage.
  - **DVCLive** can save experiments or runs as
    [hidden Git commits](https://dvc.org/doc/dvclive/how-it-works#track-the-results).

  You can then use different [options](#comparing) to visualize the metrics,
  parameters, and plots across experiments.

  ______________________________________________________________________



  Contributions are very welcome. To learn more, see the
  [Contributor Guide](CONTRIBUTING.rst).



  Distributed under the terms of the
  [Apache 2.0 license](https://opensource.org/licenses/Apache-2.0), *dvclive* is
  free and open source software.


pkgId: 822c03c96cae6830593fd43683971bb937fc2554a458d0e7523fc1d260b8817f
name: python-dwclib-help
arch: noarch
version: 2024.12.17
epoch: 0
release: 1
summary: Development documents and examples for dwclib
url: https://github.com/larib-data/dwclib
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dwclib-2024.12.17-1.src.rpm
location_href: Packages/python-dwclib-help-2024.12.17-1.noarch.rpm
checksum_type: sha256
description:
  Python wrapper to DataWarehouse Connect.
  -   Free software: ISC license


  `conda install -c conda-forge dwclib`

  `pip install dwclib`


  - 2024.9.17
      - Support reading waves in binary chunks without conversion

  - 2024.5.10
      - Support searching patients directly in DWC without DWCmeta

  - 2024.4.4
      - Support querying enumerations
      - Update dependencies

  - 2023.6.21
      - Remove all occurences of naive datetime since dask now support tz-aware
      - New config file syntax to be compatible with other libraries
      - Fix a bug when Pleth waveform return all NaN

  - 2023.6.7
      - Support for querying alerts using the read_alerts call
      - Use the platformdirs package for config file location

  - 2022.9.14
      - Support numeric labels and sublabels in read_patients and read_numerics
      - Support to query for multiple patients at once in read_numerics

  - 2022.6.23
      - Convert packaging from flit to poetry
      - Add linting and testing with nox, flake8 and safety
      - Create scaffolding for future Sphinx documentation
      - Fix a number of bugs in corner cases (division by zero, ...)
      - Add a generic Dask wrapper to run custom DWC queries with Dask

  - 2022.3.22
      - Convert packaging from old-style setup.py to flit
      - Refactor: extract common code between dask and pandas version
      - No longer relies on user defined function in the database
      - Patients: add read_patient function to fetch a single patient
      - Numerics: read_numerics patientids can be a list or a str. When it is a list, a MultiIndex is returned


pkgId: dbcdd36f5e7fd83d345fb1512465e7f62dbe608c46264c712cd87a95325e59ad
name: python-dxsp-help
arch: noarch
version: 11.1.5
epoch: 0
release: 1
summary: Development documents and examples for dxsp
url: https://pypi.org/project/dxsp/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dxsp-11.1.5-1.src.rpm
location_href: Packages/python-dxsp-help-11.1.5-1.noarch.rpm
checksum_type: sha256
description:
  <table style="border: 1px solid transparent">
    <tr>
      <td>
  <a href="http://talky.readthedocs.io"><img src="https://img.shields.io/badge/Wiki-%23000000.svg?style=for-the-badge&logo=wikipedia&logoColor=white"></a>
  <a href="https://github.com/mraniki/tt/"><img src="https://img.shields.io/badge/github-%23000000.svg?style=for-the-badge&logo=github&logoColor=white"></a><br>
  <a href="https://hub.docker.com/r/mraniki/tt"><img src="https://img.shields.io/docker/pulls/mraniki/tt?style=for-the-badge"></a><br>
    </td>
      <td align="center"><img width="200" alt="Logo" src="https://user-images.githubusercontent.com/8766259/231213427-63ea2752-13d5-4993-aee2-90671b57fc6e.png"></td>
    </tr>
    <tr>
      <td>
        <a href="https://pypi.org/project/dxsp/"><img src="https://img.shields.io/pypi/v/dxsp?style=for-the-badge&logo=PyPI&logoColor=white"></a><br>
        <a href="https://pypi.org/project/dxsp/"><img src="https://img.shields.io/pypi/dm/dxsp?style=for-the-badge&logo=PyPI&logoColor=white&label=pypi&labelColor=grey"></a><br>
        <a href="https://github.com/mraniki/dxsp/"><img src="https://img.shields.io/github/actions/workflow/status/mraniki/dxsp/%F0%9F%91%B7Flow.yml?style=for-the-badge&logo=GitHub&logoColor=white"></a><br>
     <a href="https://talky.readthedocs.io/projects/dxsp/"><img src="https://readthedocs.org/projects/dxsp/badge/?version=latest&style=for-the-badge"></a><br>
     <a href="https://codebeat.co/projects/github-com-mraniki-dxsp-main"><img src="https://codebeat.co/badges/b1376839-73bc-4b41-bfc1-2fb099f1fc2a"/></a><br>
     <a href="https://codecov.io/gh/mraniki/dxsp"><img src="https://codecov.io/gh/mraniki/dxsp/branch/main/graph/badge.svg?token=39ED0ZA6IH"/> </a><br>
    <a href="https://codeclimate.com/github/mraniki/dxsp/maintainability"><img src="https://api.codeclimate.com/v1/badges/ec80e827d5878e60ba12/maintainability" /></a>
      </td>
      <td align="left">
  Swap made easy<br>
  Trade on any blockchains <br>with uniswap based router, 0x protocol and kwenta sdk.
      </td>
    </tr>
  </table>

  <h5>How to use it</h5>
  <pre>
  <code>
     from dxsp import DexSwap
      dex = DexSwap()
      
      
          "action": "BUY",
          "instrument": "BTC",
          "quantity": 1,
      })
  </code>
  </pre>

  <h5>Documentation</h5>

  <a href="https://talky.readthedocs.io/projects/dxsp/"><img src="https://img.shields.io/badge/Documentation-000000?style=for-the-badge&logo=readthedocs&logoColor=white"></a><br>


pkgId: b137452d1f8584a374282c86f4aca825728ce19bb233694b9b30e2758f36eaac
name: python-dyada-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for dyada
url: https://pypi.org/project/dyada/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyada-0.0.2-1.src.rpm
location_href: Packages/python-dyada-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Python package CI](https://github.com/freifrauvonbleifrei/DyAda/actions/workflows/python-package.yml/badge.svg)](https://github.com/freifrauvonbleifrei/DyAda/actions/workflows/python-package.yml/)
  ![Coverage](coverage.svg)
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)



  Dyadic adaptivity means: A given hypercube of 2 or more dimensions may or may not
  be subdivided into two parts in any number of dimensions.
  Of the resulting sub-boxes, each may again be subdivided into two in any dimension,
  and so forth.



  Currently, the most common approach to adaptivity are octrees, which are a
  special type of dyadic adaptivity: Each box is either refined in *every* dimension
  or not at all.
  For a three-d domain, the tree and the resulting partitioning could look like this:

  <!--
  images generated like this:
  ```bash
  for f in *.tex ; do latexmk -pdf $f ; done
  for d in *.pdf ; do inkscape --without-gui --file=$d --export-plain-svg=${d%.*}.svg ; done
  rsvg-convert tikz_cubes_solid.svg -w 268 -h 252 -f svg -o tikz_cubes_solid.svg #etc.
  ``` -->
  ![The octree tree](docs/gfx/octree_tree.svg)

  ![The octree partitioning](docs/gfx/octree_solid.svg)

  But maybe you didn't need all this resolution?

  Maybe, in the finely-resolved areas, you only needed only *some* of the dimensions
  resolved finely:

  ![The dyadic partitioning](docs/gfx/tikz_cubes_solid.svg)

  This is what DyAda provides.

  The tree will then look like this:

  ![The omnitree tree](docs/gfx/omnitree.svg)

  And you will only have to use 14 degrees of freedom instead of 29!
  This reduction will be even stronger if you go to higher dimensions.



  Feel free to request features or voice your intent to work on/with DyAda as an
  [issue](https://github.com/freifrauvonbleifrei/DyAda/issues).
  Depending on what you are looking for, exciting features may be in preparation,
  or they may just be waiting for you to implement them!


pkgId: 558eaebe6c3dc7607cc48f928bf519a3761c832e48520db8a4b03b67abda804d
name: python-dyatel-wrapper-help
arch: noarch
version: 2.3.1
epoch: 0
release: 1
summary: Development documents and examples for dyatel-wrapper
url: https://github.com/EnvInc/dyatel
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyatel-wrapper-2.3.1-1.src.rpm
location_href: Packages/python-dyatel-wrapper-help-2.3.1-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">Dyatel Wrapper</h1>

  <h2 align="center">Automation Beyond Limits</h2>

  <p align="center">
  <a href="https://dyatel-wrapper.readthedocs.io"><img alt="Documentation Status" src="https://readthedocs.org/projects/dyatel-wrapper/badge/?version=latest"></a>
  <a href="https://github.com/CustomEnv/dyatel/blob/master/LICENSE"><img alt="License: MIT" src="https://dyatel-wrapper.readthedocs.io/_static/license.svg"></a>
  <a href="https://pypi.org/project/dyatel-wrapper/"><img alt="PyPI" src="https://img.shields.io/pypi/v/dyatel-wrapper"></a>
  </p>


  Dyatel Wrapper is a Python framework that seamlessly wraps over Selenium, Appium, and sync Playwright,
  providing a unified interface for browser and mobile automation. With Dyatel Wrapper, you can effortlessly switch
  between these engines within the same test, allowing you to leverage the unique features of each framework without boundaries.

  Whether you're running tests on web browsers, mobile devices, or a combination of both, Dyatel Wrapper simplifies the
  process, giving you the flexibility and power to automate complex testing scenarios with ease.



  - **Seamless Integration**: Dyatel Wrapper integrates with Selenium, Appium, and Playwright, allowing you to use the best-suited engine for your specific testing needs.
  - **Unified API**: A single, easy-to-use API that abstracts away the differences between Selenium, Appium, and Playwright, making your test scripts more readable and maintainable.
  - **Engine Switching**: Switch between Selenium, Appium, and Playwright within the same test case, enabling cross-platform and cross-browser testing with minimal effort.
  - **Visual Regression Testing**: Perform visual regression tests using the integrated visual regression tool, available across all supported frameworks. This ensures your UI remains consistent across different browsers and devices.
  - **Advanced Features**: Leverage the advanced features of each framework, such as Playwright's mocks and Appium's real mobile devices support, all while using the same testing framework.
  - **Extensibility**: Extend the framework with custom functionality tailored to your project's specific requirements.
  - **Automatic Locator Type Definition**: The locator type will be automatically determined based on the provided locator string or `Locator` object.



  For information on installation and usage, please refer to our **[ReadTheDocs documentation](https://dyatel-wrapper.readthedocs.io)**. Check it out for more details.




  Dyatel Wrapper is an open-source project, and we welcome contributions from the community. If you'd like to contribute, please open an pull request from your fork



  Dyatel Wrapper is licensed under the Apache License. See the [LICENSE](https://github.com/CustomEnv/dyatel/blob/master/LICENSE) file for more details.



  If you encounter any issues or have questions, please feel free to reach out via our [GitHub Issues](https://github.com/CustomEnv/dyatel/issues) page.

  Thank you for choosing Dyatel Wrapper for your automation needs!


pkgId: d07279252c3c7957bf3e49a7d3e3855c97aaae2784704bd0daa52a48377edf79
name: python-dyff-audit-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for dyff-audit
url: https://pypi.org/project/dyff-audit/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyff-audit-0.10.1-1.src.rpm
location_href: Packages/python-dyff-audit-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- BADGIE TIME -->

  [![pipeline status](https://img.shields.io/gitlab/pipeline-status/dyff/packages/dyff-audit?branch=main)](https://gitlab.com/dyff/packages/dyff-audit/-/commits/main)
  [![coverage report](https://img.shields.io/gitlab/pipeline-coverage/dyff/packages/dyff-audit?branch=main)](https://gitlab.com/dyff/packages/dyff-audit/-/commits/main)
  [![latest release](https://img.shields.io/gitlab/v/release/dyff/packages/dyff-audit)](https://gitlab.com/dyff/packages/dyff-audit/-/releases)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![code style: black](https://img.shields.io/badge/code_style-black-000000.svg)](https://github.com/psf/black)
  [![imports: isort](https://img.shields.io/badge/imports-isort-1674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![formatter: docformatter](https://img.shields.io/badge/formatter-docformatter-fedcba.svg)](https://github.com/PyCQA/docformatter)
  [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
  [![cici-tools Enabled](https://img.shields.io/badge/%E2%9A%A1_cici--tools-enabled-c0ff33)](https://gitlab.com/buildgarden/tools/cici-tools)

  <!-- END BADGIE TIME -->

  Audit tools for the Dyff AI audit platform.

  > Do not use this software unless you are an active collaborator on the
  > associated research project.
  >
  > This project is an output of an ongoing, active research project. It is
  > published without warranty, is subject to change at any time, and has not been
  > certified, tested, assessed, or otherwise assured of safety by any person or
  > organization. Use at your own risk.



  `dyff-audit` requires Python 3.9+ and can be installed via `pip`:

  ```bash
  python3 -m pip install dyff-audit
  ```



  Copyright 2024 UL Research Institutes.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at

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

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


pkgId: ed3dc384455dea7fd2b3e7117bbe7d7db52bde55750343396fdcd8efc574d95a
name: python-dyff-client-help
arch: noarch
version: 0.15.0
epoch: 0
release: 1
summary: Development documents and examples for dyff-client
url: https://pypi.org/project/dyff-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyff-client-0.15.0-1.src.rpm
location_href: Packages/python-dyff-client-help-0.15.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- BADGIE TIME -->

  [![pipeline status](https://img.shields.io/gitlab/pipeline-status/dyff/packages/dyff-client?branch=main)](https://gitlab.com/dyff/packages/dyff-client/-/commits/main)
  [![coverage report](https://img.shields.io/gitlab/pipeline-coverage/dyff/packages/dyff-client?branch=main)](https://gitlab.com/dyff/packages/dyff-client/-/commits/main)
  [![latest release](https://img.shields.io/gitlab/v/release/dyff/packages/dyff-client)](https://gitlab.com/dyff/packages/dyff-client/-/releases)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![code style: black](https://img.shields.io/badge/code_style-black-000000.svg)](https://github.com/psf/black)
  [![imports: isort](https://img.shields.io/badge/imports-isort-1674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
  [![cici-tools Enabled](https://img.shields.io/badge/%E2%9A%A1_cici--tools-enabled-c0ff33)](https://gitlab.com/buildgarden/tools/cici-tools)

  <!-- END BADGIE TIME -->

  Python client for the Dyff AI auditing platform.

  > Do not use this software unless you are an active collaborator on the
  > associated research project.
  >
  > This project is an output of an ongoing, active research project. It is
  > published without warranty, is subject to change at any time, and has not been
  > certified, tested, assessed, or otherwise assured of safety by any person or
  > organization. Use at your own risk.



  `dyff-client` requires Python 3.9+ and can be installed via `pip`:

  ```bash
  python3 -m pip install dyff-client
  ```



  ```python
  from dyff.client import Client

  client = Client(api_key="XXXXXX")
  ```

  The API key must be provisioned by a Dyff administrator.



  ```python
  dataset = client.datasets.create_arrow_dataset(
      "/my/data", account="XXX", name="mydata"
  )
  ```

  For more examples, see the [client
  examples](https://docs.dyff.io/examples/client/).

  For the full API, see the [client API
  reference](https://docs.dyff.io/api-reference/client/).



  Copyright 2024 UL Research Institutes.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at

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

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


pkgId: 800f6798192efb0d2f497e4b7546d44b595c6ff569ae3790cc1c2046a65430b1
name: python-dyff-help
arch: noarch
version: 0.30.0
epoch: 0
release: 1
summary: Development documents and examples for dyff
url: https://pypi.org/project/dyff/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyff-0.30.0-1.src.rpm
location_href: Packages/python-dyff-help-0.30.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- BADGIE TIME -->

  [![pipeline status](https://img.shields.io/gitlab/pipeline-status/dyff/packages/dyff?branch=main)](https://gitlab.com/dyff/packages/dyff/-/commits/main)
  [![latest release](https://img.shields.io/gitlab/v/release/dyff/packages/dyff)](https://gitlab.com/dyff/packages/dyff/-/releases)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
  [![cici-tools Enabled](https://img.shields.io/badge/%E2%9A%A1_cici--tools-enabled-c0ff33)](https://gitlab.com/buildgarden/tools/cici-tools)

  <!-- END BADGIE TIME -->

  Meta-package to install the local SDK for the Dyff AI auditing platform.

  > Do not use this software unless you are an active collaborator on the
  > associated research project.
  >
  > This project is an output of an ongoing, active research project. It is
  > published without warranty, is subject to change at any time, and has not been
  > certified, tested, assessed, or otherwise assured of safety by any person or
  > organization. Use at your own risk.



  `dyff` requires Python 3.9+ and can be installed via `pip`:

  ```bash
  python3 -m pip install dyff
  ```



  Copyright 2024 UL Research Institutes.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at

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

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


pkgId: 7c47b4a729941be76f564e5342fd1dd085211d263da8cbe9d675493c92a17156
name: python-dyff-schema-help
arch: noarch
version: 0.20.0
epoch: 0
release: 1
summary: Development documents and examples for dyff-schema
url: https://pypi.org/project/dyff-schema/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyff-schema-0.20.0-1.src.rpm
location_href: Packages/python-dyff-schema-help-0.20.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- BADGIE TIME -->

  [![pipeline status](https://img.shields.io/gitlab/pipeline-status/dyff/packages/dyff-schema?branch=main)](https://gitlab.com/dyff/packages/dyff-schema/-/commits/main)
  [![coverage report](https://img.shields.io/gitlab/pipeline-coverage/dyff/packages/dyff-schema?branch=main)](https://gitlab.com/dyff/packages/dyff-schema/-/commits/main)
  [![latest release](https://img.shields.io/gitlab/v/release/dyff/packages/dyff-schema)](https://gitlab.com/dyff/packages/dyff-schema/-/releases)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![code style: black](https://img.shields.io/badge/code_style-black-000000.svg)](https://github.com/psf/black)
  [![imports: isort](https://img.shields.io/badge/imports-isort-1674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
  [![cici-tools Enabled](https://img.shields.io/badge/%E2%9A%A1_cici--tools-enabled-c0ff33)](https://gitlab.com/buildgarden/tools/cici-tools)

  <!-- END BADGIE TIME -->

  Data models for the Dyff AI auditing platform.

  > Do not use this software unless you are an active collaborator on the
  > associated research project.
  >
  > This project is an output of an ongoing, active research project. It is
  > published without warranty, is subject to change at any time, and has not been
  > certified, tested, assessed, or otherwise assured of safety by any person or
  > organization. Use at your own risk.



  Python 3.9+ is required. Install `dyff-schema` via `pip`:

  ```bash
  python3 -m pip install dyff-schema
  ```



  Copyright 2024 UL Research Institutes.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at

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

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


pkgId: d0658b9a701978936e2b2be6cc747f3abd30c277cdd904af24a1a8070e957928
name: python-dyff-storage-help
arch: noarch
version: 0.19.0
epoch: 0
release: 1
summary: Development documents and examples for dyff-storage
url: https://pypi.org/project/dyff-storage/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dyff-storage-0.19.0-1.src.rpm
location_href: Packages/python-dyff-storage-help-0.19.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- BADGIE TIME -->

  [![pipeline status](https://img.shields.io/gitlab/pipeline-status/dyff/packages/dyff-storage?branch=main)](https://gitlab.com/dyff/packages/dyff-storage/-/commits/main)
  [![coverage report](https://img.shields.io/gitlab/pipeline-coverage/dyff/packages/dyff-storage?branch=main)](https://gitlab.com/dyff/packages/dyff-storage/-/commits/main)
  [![latest release](https://img.shields.io/gitlab/v/release/dyff/packages/dyff-storage)](https://gitlab.com/dyff/packages/dyff-storage/-/releases)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![code style: black](https://img.shields.io/badge/code_style-black-000000.svg)](https://github.com/psf/black)
  [![imports: isort](https://img.shields.io/badge/imports-isort-1674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![cici-tools Enabled](https://img.shields.io/badge/%E2%9A%A1_cici--tools-enabled-c0ff33)](https://gitlab.com/buildgarden/tools/cici-tools)
  [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)

  <!-- END BADGIE TIME -->

  Python storage API for the Dyff AI auditing platform.

  > Do not use this software unless you are an active collaborator on the
  > associated research project.
  >
  > This project is an output of an ongoing, active research project. It is
  > published without warranty, is subject to change at any time, and has not been
  > certified, tested, assessed, or otherwise assured of safety by any person or
  > organization. Use at your own risk.



  Python 3.9+ is required. Install `dyff-storage` via `pip`:

  ```bash
  python3 -m pip install dyff-storage
  ```



  Copyright 2024 UL Research Institutes.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at

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

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


pkgId: 0b7aa1b64ee0c3a96b475b0fe67254905dd0d1b8e38558d20a4fe543082f042b
name: python-dygest-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for dygest
url: https://github.com/tsmdt/dygest
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dygest-0.3.3-1.src.rpm
location_href: Packages/python-dygest-help-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  > [!NOTE]
  **dygest** is a text analysis tool that extracts insights from `.txt` files, generating summaries, keywords, TOCs, and performing Named Entity Recognition (NER).


  **dygest** was created to gain fast insights into longer transcripts of audio and video content by retrieving relevant topics and providing an easy to use HTML interface with short cuts from summaries to corresponding text chunks. NER processing further enhances those insights by identifying names of individuals, organisations, locations etc.


  - **Text insights**
    Generate concise insights for your text files using various LLM services by creating *summaries*, *keywords*, *table of contents* (TOC) and *named entities* (NER).
  - **Unified LLM Interface**
    dygest uses [litellm](https://github.com/BerriAI/litellm) and provides integration for various LLM service providers: `OpenAI`, `Anthropic`, `HuggingFace`, `Groq`, `Ollama` etc. Check the [complete provider list](https://docs.litellm.ai/docs/providers) for all available services.
  - **Token Friendly**
    dygest performs token-heavy text analysis and summarization tasks. Therefore, the underlying LLM pipeline can be tailored to your needs and specific rate limits using a *mixed experts approach*.
  - **Mixed Experts Approach**
    dygest utilizes two fully customizable LLMs to handle different processing tasks. The first, referred to as the `light_model`, is designed for lighter tasks such as summarization and keyword extraction. The second, called the `expert_model`, is optimized for more complex tasks like constructing Tables of Contents (TOCs).

    This flexibility allows for various pipeline configurations. For example, the `light_model` can run locally using `Ollama`, while the `expert_model` can leverage an external API service like `OpenAI` or `Groq`. This approach ensures efficiency and adaptability based on specific requirements.

  > [!TIP]
  > As the `expert_model` is dealing with a lot of input content it is recommended to use a larger LLM (`>=32B`) for this task. Smaller LLMs (`3B` to `7B`) perform well as `light_model`.

  - **Named Entity Recognition (NER)**
    Named Entity Recognition via fast and reliable `flair` framework (identifies persons, organisations, locations etc.).

  - **User-friendly HTML Editor**
    By default `dygest` will create a `.html` file that can be viewed in standard browsers and combines summaries, keywords, TOC and NER for your text. It features a text editor for you to make further changes.

  - **Export Formats**: `.json` `.csv` `.html`


  <p align="center">
    <img src="./assets/dygest_html.png" width="80%">
  </p>


  - 🐍 Python `>=3.10`
  - 🔑 API keys for LLM services like `OpenAI`, `Anthropic` and `Groq` *and / or* a running `Ollama` instance

  > [!NOTE]
  > API Keys have to be stored in your environment (e.g. `export $OPENAI_API_KEY=skj....`)






  ```shell
  python3.10 -m venv venv
  ```


  ```shell
  source venv/bin/activate
  ```


  ```shell
  pip install dygest
  ```




  ```shell
  git clone https://github.com/tsmdt/dygest.git
  cd dygest
  ```


  ```shell
  python3.10 -m venv venv
  ```


  ```shell
  source venv/bin/activate
  ```


  ```shell
  pip install .
  ```




  Customize the **dygest** LLM pipeline by running the `dygest config` command:

  ```shell
   Usage: dygest config [OPTIONS]

   Configure LLMs, Embeddings and Named Entity Recognition.

  ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ --light_model      -l                 TEXT     LLM model name for lighter tasks (summarization, keywords) [default: None]                │
  │ --expert_model     -x                 TEXT     LLM model name for heavier tasks (TOCs). [default: None]                                  │
  │ --embedding_model  -e                 TEXT     Embedding model name. [default: None]                                                     │
  │ --temperature      -t                 FLOAT    Temperature of LLM. [default: None]                                                       │
  │ --sleep            -s                 FLOAT    Pause LLM requests to prevent rate limit errors (in seconds). [default: None]             │
  │ --chunk_size       -c                 INTEGER  Maximum number of tokens per chunk. [default: None]                                       │
  │ --ner                     --no-ner             Enable Named Entity Recognition (NER). Defaults to False. [default: no-ner]               │
  │ --precise                 --fast               Enable precise mode for NER. Defaults to fast mode. [default: fast]                       │
  │ --lang             -lang              TEXT     Language of file(s) for NER. Defaults to auto-detection. [default: None]                  │
  │ --api_base         -api               TEXT     Set custom API base url for providers like Ollama and Hugginface. [default: None]         │
  │ --view_config      -v                          View loaded config parameters.                                                            │
  │ --help                                         Show this message and exit.                                                               │
  ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  The configuration is saved as `dygest_config.yaml` in the project directory. The `.yaml` config looks like this:

  ```yaml
  light_model: ollama/mistral:latest
  expert_model: groq/llama-3.3-70b-versatile
  embedding_model: ollama/nomic-embed-text:latest
  temperature: 0.4
  chunk_size: 1000
  ner: true
  language: auto
  precise: false
  api_base: null
  sleep: 0
  ```


  Run the **dygest** LLM pipeline with the `dygest run` command:

  ```shell
   Usage: dygest run [OPTIONS]

   Create insights for your documents (summaries, keywords, TOCs).

  ╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
  │ --files            -f         TEXT             Path to the input folder or .txt file. [default: None]                                    │
  │ --output_dir       -o         TEXT             If not provided, outputs will be saved in the input folder. [default: None]               │
  │ --export_format    -ex        [json|csv|html]  Set the data format for exporting. [default: html]                                        │
  │ --toc              -t                          Create a Table of Contents (TOC) for the text. Defaults to False.                         │
  │ --summarize        -s                          Include a short summary for the whole text. Defaults to False.                            │
  │ --keywords         -k                          Create descriptive keywords for the text. Defaults to False.                              │
  │ --sim_threshold    -sim       FLOAT            Similarity threshold for removing duplicate topics. [default: 0.85]                       │
  │ --verbose          -v                          Enable verbose output. Defaults to False.                                                 │
  │ --export_metadata  -meta                       Enable exporting metadata to output file(s). Defaults to False.                           │
  │ --help                                         Show this message and exit.                                                               │
  ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```

  **dygest** uses great python packages:
  - `litellm`: https://github.com/BerriAI/litellm
  - `flair`: https://github.com/flairNLP/flair
  - `typer`: https://github.com/fastapi/typer
  - `json_repair`: https://github.com/mangiucugna/json_repair


pkgId: 31611cc8aa5e29094a0372f84f49f475a584d91f39586b0080fbcd07eae8df4e
name: python-dymoapi-help
arch: noarch
version: 0.0.18
epoch: 0
release: 1
summary: Development documents and examples for dymoapi
url: https://github.com/TPEOficial/dymo-api-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dymoapi-0.0.18-1.src.rpm
location_href: Packages/python-dymoapi-help-0.0.18-1.noarch.rpm
checksum_type: sha256
description:
  You can see the library documentation by clicking [here](https://docs.tpeoficial.com/docs/dymo-api/getting-started/libraries?ch-pg=r-dm-python).


pkgId: d8265ffe3106340eff35f3d2f36dd07b217d8e340e32828fefe7614687f075ad
name: python-dynamicforms-help
arch: noarch
version: 0.77.7
epoch: 0
release: 1
summary: Development documents and examples for dynamicforms
url: https://github.com/velis74/DynamicForms
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dynamicforms-0.77.7-1.src.rpm
location_href: Packages/python-dynamicforms-help-0.77.7-1.noarch.rpm
checksum_type: sha256
description:
  Releases 0.50.x and 0.70.x are interim releases with which we prepare the stage for 1.x release.

  0.50.x moves all "existing" code to `dynamicforms_legacy` module. If you weren't following vue
  development branches, you will need to change all imports in python to this "new" module.

  This is done to keep legacy code still running as existing code is transitioned to vue-based approach. Unless there is
  significant interest, we will remove this module with 1.x release.

  0.70.x re-introduces `dynamicforms` module, but this time refactored to only provide .componentdef OPTIONS +
  payload data responses needed by the vue front-end library. This will hopefully be refactored to be more OpenAPI
  compatible. The new primary branch is now `main`.

  HTML renderers will no longer be supported and have been removed from the "new" dynamicforms module. It was too slow
  and required too many hacks to remain viable. So we moved to Vue. The components in 0.70 will be vue3, vuetify3, vite
  and typescript-compatible. We're in final stages of adapting to the new stack. Some inputs and some table functionality
  isn't working yet.

  We're keeping the Bootstrap stubs too, but not actively developing to support seamless selection of the two frameworks.
  If there is interest to support CSS frameworks other than Vuetify, pull requests welcome. Hopefully the stubs should
  point the way on how to do it.

  Migration path is thus:

  - Upgrade to dynamicforms \>= 0.50.3
  - replace all dynamicforms imports with dynamicforms_legacy
  - because of the rename, there is a bit of work required in settings.py so that Django can find the templates and
    filters:

        ``` python
        from dynamicforms_legacy import __file__ as DYNAMICFORMS_BASEDIR_FILE
        DYNAMICFORMS_BASEDIR = os.path.dirname(DYNAMICFORMS_BASEDIR_FILE)
        ...
        INSTALLED_APPS = [
          ...
          'dynamicforms_legacy'

        TEMPLATES = [
           ...
                'DIRS': [
                    os.path.join(DYNAMICFORMS_BASEDIR, 'templates'),
           ...
                'OPTIONS': {
           ...
                    'libraries': {
                        'dynamicforms': 'dynamicforms_legacy.templatetags.dynamicforms',
                    }
        STATICFILES_DIRS = [
            ...
            os.path.join(DYNAMICFORMS_BASEDIR, 'static'),
        ]
        ```
  - replace any javascript dynamicforms progress calls with progress-legacy
  - all other javascript code remains the same (including the dynamicforms object with support functions)
  - check that everything still works
  - Upgrade dynamicforms to \>= 0.70.1
  - Start migration to Vue front-end and the new backend



  DynamicForms wants to eliminate HTML form boilerplate for generic tables & forms. Specifying a single DRF Serializer /
  ViewSet and possibly desired form layout instantly provides both HTML renders and JSON renders (and anything else DRF
  supports) keeping you free to implement your project.

  There are two parts to DanymicForms:

  - Django / DRF extensions providing the JSON definitions for on-screen objects
  - HTML / Javascript component library providing the visualisation

  It performs all the visualisation & data entry of your DRF Serializers & ViewSets and adds some candy of its own: It is
  a [django](https://www.djangoproject.com/) library that gives you the power of dynamically-shown form fields,
  autofilled default values, dynamic record loading and similar candy with little effort. To put it differently: once
  defined, a particular ViewSet / Serializer can be rendered in multiple ways allowing you to perform viewing and
  authoring operations on the data in question.

  It is based on
  [django-rest-framework](http://www.django-rest-framework.org/)

  Documentation [on readthedocs](https://dynamicforms.readthedocs.io/)



  - Turn your rest-framework ViewSets into HTML tables & forms
  - Powerful HTML based CRUD
      - Support for fetching "new" records
      - Render to table, form or dialog, with plenty of customisation options
      - Full nested data support
      - Dynamically display & hide fields based on other fields' values
      - Easily add actions and place the buttons to execute them anywhere you like
  - Clear separation of list & dialog templates
  - Dynamic loading of additional records for table views supported by infinite scroll
  - Responsive tables (multiple table layouts for various screen widths)
  - Easy implementation of filtering
  - Action items, declared globally, placed where you need them
  - Custom templates whenever & wherever you want them
  - Support for form validation, will show errors even if they are not tied to a field
  - Progress dialog for long lasting ajax operations


pkgId: 2cffd1ef8df0b2613455a066e52ce124795193ff2fa27a8cf2dc2bdacf2fa73e
name: python-dynamont-help
arch: noarch
version: 0.5
epoch: 0
release: 1
summary: Development documents and examples for dynamont
url: https://pypi.org/project/dynamont/
rpm_license: GNUv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dynamont-0.5-1.src.rpm
location_href: Packages/python-dynamont-help-0.5-1.noarch.rpm
checksum_type: sha256
description:
  - [](#)
    - [Dynamont](#dynamont)
    - [Installation](#installation)
      - [Pypi/pip](#pypipip)
      - [Conda](#conda)
    - [Usage](#usage)


pkgId: 5b25d2b2d4dd0c5f1e9c54e8225b95a252551e0141951b44dd3fecb6131a216c
name: python-dynesty-help
arch: noarch
version: 2.1.5
epoch: 0
release: 1
summary: Development documents and examples for dynesty
url: https://github.com/joshspeagle/dynesty
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dynesty-2.1.5-1.src.rpm
location_href: Packages/python-dynesty-help-2.1.5-1.noarch.rpm
checksum_type: sha256
description:
  ![dynesty in action](https://github.com/joshspeagle/dynesty/blob/master/docs/images/title.gif)
  A Dynamic Nested Sampling package for computing Bayesian posteriors and
  evidences. Pure Python. MIT license.

  Documentation can be found [here](https://dynesty.readthedocs.io).

  The most stable release of `dynesty` can be installed
  through [pip](https://pip.pypa.io/en/stable) via
  ```
  pip install dynesty
  ```
  The current (less stable) development version can be installed by running
  ```
  python setup.py install
  ```
  from inside the repository.

  Several Jupyter notebooks that demonstrate most of the available features
  of the code can be found
  [here](https://github.com/joshspeagle/dynesty/tree/master/demos).

  If you find the package useful in your research, please cite at least *both* of these references:
  * The original paper [Speagle (2020)](https://ui.adsabs.harvard.edu/abs/2020MNRAS.493.3132S/abstract)
  * The python implementation [Koposov et al. (2023)](https://doi.org/10.5281/zenodo.3348367) (the citation info is at the bottom of the page on the right)
  and ideally also papers describing the underlying methods (see the [documentation](https://dynesty.readthedocs.io/en/latest/references.html) for more details)

  If you want to report issues, or have questions, please do that on [github](https://github.com/joshspeagle/dynesty/issues).

  Patches and contributions are very welcome! Please see [CONTRIBUTING.md](https://github.com/joshspeagle/dynesty/blob/master/CONTRIBUTING.md) for more details.


pkgId: 288aadf0d4dcedbe614c30be75019b9c71e296def744860a3ac675d4ed0330d7
name: python-e2b-code-interpreter-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for e2b-code-interpreter
url: https://e2b.dev/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-e2b-code-interpreter-1.0.3-1.src.rpm
location_href: Packages/python-e2b-code-interpreter-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  [E2B](https://www.e2b.dev/) is an open-source infrastructure that allows you run to AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter).


  ```
  pip install e2b-code-interpreter
  ```

  1. Sign up to E2B [here](https://e2b.dev).
  2. Get your API key [here](https://e2b.dev/dashboard?tab=keys).
  3. Set environment variable with your API key.
  ```
  E2B_API_KEY=e2b_***
  ```

  ```py
  from e2b_code_interpreter import Sandbox
  with Sandbox() as sandbox:
      sandbox.run_code("x = 1")
      execution = sandbox.run_code("x+=1; x")
      print(execution.text)  # outputs 2
  ```

  Visit [E2B documentation](https://e2b.dev/docs).

  Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.


pkgId: 4a64cf6f914a7b4c79e169ae42f892ddf641c26864b14cabd7e591f3f67114ac
name: python-e2b-desktop-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for e2b-desktop
url: https://e2b.dev/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-e2b-desktop-1.0.2-1.src.rpm
location_href: Packages/python-e2b-desktop-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  E2B Desktop Sandbox is an isolated cloud environment with a desktop-like interface powered by [E2B](https://e2b.dev).

  Launching E2B Sandbox takes about 300-500ms. You can customize the desktop environment and preinstall any dependencies you want using our [custom sandbox templates](https://e2b.dev/docs/sandbox-template).

  ![Desktop Sandbox](screenshot.png)

  **Work in progress**
  This repository is a work in progress. We welcome feedback and contributions. Here's the list of features we're working on:
  - [ ] JavaScript SDK
  - [ ] Streaming live desktop
  - [ ] Tests
  - [ ] Docstrings


  The E2B Desktop Sandbox is built on top of [E2B Sandbox](https://e2b.dev/docs).


  Sign up at [E2B](https://e2b.dev) and get your API key.
  Set environment variable `E2B_API_KEY` with your API key.


  **Python**
  ```bash
  pip install e2b-desktop
  ```

  **JavaScript**
  ```bash
  Coming soon
  ```


  ```python
  from e2b_desktop import Sandbox

  desktop = Sandbox()
  ```




  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()

  desktop.double_click()
  desktop.left_click()
  desktop.right_click()
  desktop.middle_click()
  desktop.scroll(10) # Scroll by the amount. Positive for up, negative for down.
  desktop.mouse_move(100, 200) # Move to x, y coordinates
  ```


  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()


  x, y = desktop.locate_on_screen("Home")

  desktop.mouse_move(x, y)
  ```


  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()

  desktop.write("Hello, world!") # Write text at the current cursor position
  desktop.hotkey("ctrl", "c") # Press ctrl+c
  ```


  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()


  desktop.screenshot("screenshot.png")
  ```


  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()


  desktop.files.write("/home/user/index.js", "console.log('hello')") # First create the file
  desktop.open("/home/user/index.js") # Then open it
  ```


  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()


  desktop.commands.run("ls -la /home/user")
  ```


  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()


  desktop.pyautogui("pyautogui.click()")
  ```

  <!-- ### Customization
  ```python
  from e2b_desktop import Sandbox
  desktop = Sandbox()
  ``` -->


  You can use [PyAutoGUI](https://pyautogui.readthedocs.io/en/latest/) to control the whole environment programmatically.

  The desktop-like environment is based on Linux and [Xfce](https://www.xfce.org/) at the moment. We chose Xfce because it's a fast and lightweight environment that's also popular and actively supported. However, this Sandbox template is fully customizable and you can create your own desktop environment.
  Check out the code [here](./template/)


pkgId: 7a7930201df03e08dd317ea520d6113cc537f8006b2ee0a23048ea8efdc425ef
name: python-e2b-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for e2b
url: https://e2b.dev/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-e2b-1.0.5-1.src.rpm
location_href: Packages/python-e2b-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width="100" src="https://raw.githubusercontent.com/e2b-dev/E2B/refs/heads/main/readme-assets/logo-circle.png" alt="e2b logo">
  </p>

  <h4 align="center">
    <a href="https://pypi.org/project/e2b/">
      <img alt="Last 1 month downloads for the Python SDK" loading="lazy" width="200" height="20" decoding="async" data-nimg="1"
      style="color:transparent;width:auto;height:100%" src="https://img.shields.io/pypi/dm/e2b?label=PyPI%20Downloads">
    </a>
  </h4>



  [E2B](https://www.e2b.dev/) is an open-source infrastructure that allows you to run AI-generated code in secure isolated sandboxes in the cloud. To start and control sandboxes, use our [JavaScript SDK](https://www.npmjs.com/package/@e2b/code-interpreter) or [Python SDK](https://pypi.org/project/e2b_code_interpreter).





  ```
  pip install e2b-code-interpreter
  ```


  1. Sign up to E2B [here](https://e2b.dev).
  2. Get your API key [here](https://e2b.dev/dashboard?tab=keys).
  3. Set environment variable with your API key
  ```
  E2B_API_KEY=e2b_***
  ```



  ```py
  from e2b_code_interpreter import Sandbox

  with Sandbox() as sandbox:
      sandbox.run_code("x = 1")
      execution = sandbox.run_code("x+=1; x")
      print(execution.text)  # outputs 2
  ```


  Visit [E2B documentation](https://e2b.dev/docs).


  Visit our [Cookbook](https://github.com/e2b-dev/e2b-cookbook/tree/main) to get inspired by examples with different LLMs and AI frameworks.


pkgId: a21555995468b228e1fb26d86c8649c707298f75e261a9c8bc63c959d9d4eea4
name: python-e5-help
arch: noarch
version: 1.3.20
epoch: 0
release: 1
summary: Development documents and examples for e5
url: https://github.com/surf3s/E5
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-e5-1.3.20-1.src.rpm
location_href: Packages/python-e5-help-1.3.20-1.noarch.rpm
checksum_type: sha256
description:
  E5 is a generalized data entry program intended for archaeologists but likely useful for others as well.  It works with a configuration file where the data entry fields are defined.  Importantly, E5 makes it simple to make entry in one field conditional on values previously entered for other fields.  The goal is to make data entry fast, efficient and error free.

  E5 is a complete, from scratch re-write of E4.  It is backwards compatible with E4 configuration files, but it supports several new features (with more to come).  For one, it is now built on Python to be cross-platform compatible, and the source code is available at GitHub.  E5 will run on Windows, Mac OS, Linux and Android tablets and phones.  For this reason and others, E5 now uses an open database format.  All data are stored in human readable, ASCII formatted JSON files.  Data can also be exported to CSV files for easy import into any database, statistics or spreadsheet software.



  - Cross-platform support for Windows, Mac OS, Linux and Android
  - JSON data format (CSV export)
  - Open source
  - DateTime field for automated recording of when the record was entered
  - Boolean field for easy True/False recording
  - Notes field for easier text entry
  - Automated back-ups



  - Support for device cameras to link images with data records
  - Support for device GPS to link locations to data records
  - Support for related tables with one to many relationships



  - Support for iPhones.  Unfortunately the technology used for this version of E5 cannot be easily ported to iPhones.
  - Support for older, serial port (COM) calipers and scales.  If there is a demand for this, I can consider adding it. I am interested in finding solutions for connecting calipers to Android phones as well.



  E5 is written with Python 3.8.1 (but is compatible with 3.6 for now) using as few dependencies as possible for portability and maintainability.  The graphical user interface is built on Kivy 2.0.  Kivy is specifically designed for touch screens and cross-platform support; however, I made every effort to retain the efficiency of keyboard data entry for Windows and Mac OS.  The database is built on TinyDB, which is written in pure Python.  E3 (the DOS version) lasted a good 15 years (and still works actually).  E4 lasted 10-15 years as well.  My hope is that E5 will have at least this same use life, and I am cautiously optimistic that the switch to Python will give it a longer use life (though I expect that I will have to change the graphical user interface technology more frequently).



  E5 is a complete re-write of E4 in a language that I am still learning.  It also tries to do some things I have never done before (like cross-platform compatibility).  At the same time, E5 is responsible for your scientific data.  I can assure you that I take this responsibility, like the collection of my own data, very seriously, and I am making every effort to have a bug free program.  If you encounter bugs, please report them by emailing me at mcpherron@eva.mpg.de.  To effectively replicate the problem and fix the bug, I will need your configuration file, a description of how to replicate the bug, and the name of the platform (Windows, Android etc.).  If you want to add features, again, please write me.  And if you are a programmer and want to contribute features, that's great.  Please use GitHub so that I can incorporate your improvements into the general release versions (and I would prefer it if you contact me beforehand about working on the project).





  A Windows exe file can be found in the folder [Windows](https://github.com/surf3s/E5/tree/master/E5/Windows).  Download this file, place it in a folder where you want to start your data entry, and launch the program.

  I have tested E5 on several Windows 10 machines, and it worked well (though in some instance some of the time it was slow to load and then this problem went away).  I doubt it works on Windows 7 and it almost certainly does not work on Windows XP.  If you have to use Windows XP (and you really, really shouldn't) or Windows 7 (and you really, really shouldn't) then I recommend using my previous software (E4 or Entrer Trois).

  If you know Python, you can also install the source code and run the program directly that way.



  These instructions are similar to what is required for Linux.  Several things can vary.  Sometimes you type python to run Python and sometimes it is python3.  Just try them both.  You need one that gives you a version of Python of 3 or greater.  The same is true for pip.  Sometimes you use pip and sometimes pip3.  Again, just try it.  I think I would start in each case with python3 and pip3 and go from there.  If pip or pip3 do not work, you can try python3 -m pip instead of pip3 in the lines below.

  ```
  pip3 install --upgrade pip wheel setuptools
  pip3 install e5 --user
  python3 -m e5py
  ```

  To upgrade E5, you should be able to do the following.  Sometimes this does not work for me, so check the version number once you upgrade.

  ```
  pip install --upgrade e5
  ```



  Works but I am still working on getting the code uploaded to the Google Play store.



  The following has been tested on clean installs of Ubuntu.  There may be some small differences in the code base from what it stored on GitHub and what is pulled from PyPi using pip, but I will try to maintain both equally.  As with the Mac OS instructions above, you may need to replace the initial pip command with pip3 or maybe with python -m pip.  And you may need to replace python with python3.

  ```
  pip install --upgrade pip wheel setuptools
  pip install e5
  python -m e5py
  ```

  I prefer to do installations in a virtual environment to avoid Python conflicts.  To this you can use the following.  Again, you may need to use python3 instead of python and pip3 instead of pip.  These instructions assume you are in your home directory.

  ```
  mkdir e5
  cd e5
  python -m venv ./venv
  source venv/bin/activate
  pip install --upgrade pip wheel setuptools
  pip install e5
  python -m e5py
  ```

  When you leave the virtual environment (either shutting down your computer or with the command source venv/bin/deactivate), you will need to reactivate your virtual environment before starting E5.  So navigate to your e5 folder again and do the following.

  ```
  source venv/bin/activate
  python -m e5py
  ```

  To upgrade E5, you should be able to do the following.  Sometimes this does not work for me, so check the version number once you upgrade.

  ```
  pip install --upgrade e5
  ```



  Version 1.3.20
  1.    Fix references to package modules

  Version 1.3.19
  1.    Fix in installation to include missing dependency

  Version 1.3.18
  1.    Refactoring to make PyPi work
        Moved all modules to one folder package folder (dropped lib)
        Dropped the scr folder and instead use e5py directly from root level

  Version 1.3.17 (important - please update version)
  1.  Fixed a huge bug with selecting items with the mouse.
  2.  Fixed some issues with screen size and placement
  3.  Fixed some issues with clicking outside a window
  4.  Fixed an issue with how menus are displayed
        (this may fix the bouncing that sometimes happens)
        (and definitely makes the menus refresh smoother)
  5.  Fixed an issue with moving MacOS CFGs to Windows

  Version 1.3.16
  1.  Substantial structural changes to accomodate moving the program to Google Play store

  Version 1.3.15 (October, 2023)
  1.  A lot more fixes to button and font sizing throughout (though some issues remain)
  2.  Warning on settings changes that restart is required.

  Version 1.3.14 (October, 2023)
  1.  Fixed button sizing issues to work better on a variety of computers
  2.  In menus, button height now tied to font size for button text
  3.  In menus, number of menu columns tied to longest menu item and font size

  Version 1.3.13 (October, 2023)
  1.  Fixed issue with UNIQUE fields
  2.  Fixed another issue with the Enter key

  Version 1.3.12 (October, 2023)
  1.  Moved fixes done in EDM over to E5 (should resolve a Mac formatting issue as well)
  2.  Resolved a ton of data entry issues mostly related to keyboard entry

  Version 1.3.11
  1.  Brought in all changes made to EDMpy interface
  2.  Fixed issue with parsing conditions - matches starting with NOT did not work (e.g. NOTCH)
  3.  Put classes into separate files

  Version 1.3 (June, 2022)

  I finally had a chance to work on this and EDM.  The main effort here was to upgrade the program to Kivy 2.0 so that it would once again easily work across platforms.  This is done in the new version.  Additionally, I fixed a number of buys/annoyances including:
  1.  Delete key now works in addition to backspace
  2.  When only one record was present, the datagrid did not work properly.  This is fixed.
  3.  When deleting records, sometimes the last record didn't show as deleted in the datagrid.  This is fixed.




  The key element of E5 is the configuration file where the data entry fields are defined.  Configuration files (ending with a CFG file extension) may seem a bit complicated at first, and they must be written in a separate program (an ASCII text editor like NotePad or NotePad++ on Windows).  The effort of thinking through a configuration file, however, means thinking through the structure of your data before you start collecting it (unlike, for instance, if you use a spreadsheet), and this effort typically pays off later when you go to analyze the data.

  Several example CFG files are included here in the CFGs folder, and here is a sample configuration file to illustrate some features:

  ```
  [E5]
  TABLE=lithics

  [ID]
  TYPE=TEXT
  PROMPT=Enter the artifact ID
  UNIQUE=True

  [ARTIFACTTYPE]
  TYPE=MENU
  PROMPT=Select the artifact type
  MENU=Tool,Flake,Core

  [TOOLTYPE]
  TYPE=MENU
  PROMPT=Select the tool type
  MENU=Scraper,Notch,Point,Other
  CONDITION1=ArtifactType Tool

  [PLATFORMTYPE]
  TYPE=MENU
  PROMPT=What is the platform
  MENU=Plain,Cortical,Missing,Other
  CONDITION1=ArtifactType Tool,Flake

  [PLATFORMWIDTH]
  TYPE=NUMERIC
  PROMPT=Measure the platform width
  CONDITION1=ArtifactType Tool,Flake
  CONDITION2=PlatformType not Missing

  [WEIGHT]
  TYPE=NUMERIC
  PROMPT=WEIGHT
  ```

  The file is organized into blocks defined by the [].  Each file will have an [E5] block (usually at the start) that contains settings that apply to the whole configuration file.  In this example, there is one option (table=) which tells E5 what to call the database table.  If no table is specified, E5 uses '_default'.  Because it is not specified here, the database file itself (a JSON file) will have the same name as the configuration file.

  Next is a series of data entry fields (again, each defined with []).  Here the first field is an artifact ID.  The 'type' option tells E5 what kind of data to accept.  Valid options include text, note, numeric, menus, boolean (True/False), and the date and time.  The *prompt* is specified with an option, and then the *unique* option tells E5 that each data record must have a unique value for this field.  Attempts to duplicate a value for this field will generate a warning, and if data entry continues it will edit (or overwrite) the previous record with this ID.

  The *ArtifactType* field demonstrates the use of menus.  The actual menu items are specified in the *menu* option and are comma separated.  There is no limit to the number of menu items, and they are displayed in the order specified here (unless the *sorted* option is set to *True*).  The *ToolType* field that follows is also a menu, but it demonstrates the use of conditionals.  During data entry, the *ToolType* menu will only be displayed when *ArtifactType* is a tool, otherwise E5 will skip to the next field and insert an empty string ("") for the *ToolType* field.

  Likewise *PlatformType* is conditioned on the *ArtifactType* being a tool or a flake.  The field that follows, *PlatformWidth*, has two conditionals which must both be true otherwise the field will be skipped and an empty value will be inserted into the database table.  Notice that the second condition illustrates the use of the not keyword on conditions.  When the *PlatformType* is a value other than missing, this condition is true.

  Both the *PlatformWidth* field and the last field, *Weight*, are numeric fields meaning that only valid numbers are accepted as input.  All other entries will generate an error and data entry cannot continue.







  Name of the JSON file where the data will be stored. If a database is not specified, E5 will use the name of the CFG file and will create the database in the same folder as the CFG.  If the path is invalid or does not contain a database file, E5 will look for it first in the same folder as the CFG.



  The name of the data table within the database.  If a table is not specified, E5 will use the name '_default'.





  Valid values are *text*, *note*, *numeric*, *instrument*, *menu*, *boolean*, *datetime*, *camera* (experimental) and *gps* (not yet implemented).  *Text* provides a one line entry box and accepts any alphanumeric characters.  *Note* is like *text* accept that provides a multiline entry box.  *Numeric* constrains input to valid numbers and an Android the keyboard defaults to numeric.  *Instrument* is retained for backwards compatibility but is now equivalent to *numeric*.  *Menu* works with the menu option (below) to provide a menu list.  *Boolean* is a menu with only two options (*True* and *False*).  *Datetime* automatically inserts the current date and time.  *Camera* is in testing mode but is intended to allow photos to be linked to data records.  A *GPS* feature is planned to also attach coordinates to data records.  If missing, type defaults to *text*.



  The prompt associated with each field.  If missing a default will be provided.



  A comma separated menu list.  Unless the sorted option is specified (below), the menu list is shown in the order provided.  Pressing the first letters of the menu items filters to the list to matching values.



  If *True*, the menu list is sorted alphabetically.



  The maximum length of an entry.  Only valid for *text* and *note* fields.  The default is no limit.



  A message to be displayed for this field.



  The name of a text file containing help text to be displayed for this field.  Unless a full path name is given, files are assumed to be in the same folder as the CFG.  If a full path is given, but this path is not valid or does not contain the file, E5 will search for the file in the same folder as the CFG.



  If *True*, the numeric value in this field will be incremented by one each new record.  The default is *False*.



  Valid values are *True* and *False*.  Default is *false*.



  If *True*, all entries in this field must be unique within the data table.  Entering a repeat value will generate a warning but data entry can continue.  However, when the record is saved, it will replace the previous record with this unique value.  If multiple unique fields are specified, they are all taken together to form a unique value.  For example, if there is one field called Square and another field called ID, E5 will generate a warning only when the combination of Square and ID are repeated within the data table.  The default is *False*.



  If *True*, the previously entered value is retained as the default for the next data record. The default is *False*.



  Conditionals are a powerful feature of E5.  They are evaluated for each field as they are encountered, and if the result is *false*, the field is skipped.  There can be up to five conditions (each numbered condition1, condition2, etc.).  The first value of the condition is the conditional field.  This should be the name of a field previously encountered in the CFG.  Next, optionally, a *not* can be specified.  Next come the conditional matches.  These should be a comma separated list of values that could have been entered for the conditional field.  When the conditional field matches one of these, the condition is *true* unless *not* was specified in which case it is *false*.  If there are multiple conditions (e.g. condition1, condition2) then all conditions must be *true* unless *or* is specified.  In evaluating conditions with mixed *or*s and *and*s, *or*s are evaluated first and then the *and*s.  So, for instance, "*true* and *false* or *true*" results in *true* because "*false* or *true*" is *true* and then "*true* and *true*" is *true* (programmers note that the Python eval() function is used to evaluate conditions).  To test for an empty entry, use "" or '' in the conditional matches (e.g. compflake, proxflake, '' will match either a compflake, a proxflake or no entered value for the conditional field).



  The name of a file containing a list of values for a menu field.  These values should be one to a line. Unless a full path name is given, files are assumed to be in the same folder as the CFG.  If a full path is given, but this path is not valid or does not contain the file, E5 will search for the file in the same folder as the CFG.



  *E5* is by Shannon P. McPherron.  It is based on *E4* also written by Shannon McPherron in collaboration with Harold L. Dibble.  *E4* was based on *Entrer Trois* which had the help also of Simon Holdaway.  All of these programs were written in the context of my own personal research but also excavation and analyses conducted by the *OldStoneAge* team.  Thus over the years the program has greatly benefit from their feedback.


pkgId: 6438b61d62f01c6c8d084758a03815ba639fcfdfa5db84c15098a3d270baa295
name: python-eQuimageLab-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for eQuimageLab
url: https://pypi.org/project/eQuimageLab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eQuimageLab-1.0.0-1.src.rpm
location_href: Packages/python-eQuimageLab-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Author: Yann-Michel Niquet (https://astro.ymniquet.fr)



  eQuimageLab is developed in Python 3. To install the latest version of eQuimageLab, open a linux terminal/windows command prompt and run:

    `pip install --user eQuimageLab`

  pip will automatically download eQuimageLab and the missing python modules if necessary (dash, plotly, etc...). You can then launch eQuimageLab by typing:

    `eQuimagelab`

  in this same terminal. You can also create a link to eQuimageLab from your desktop; an icon is distributed for this purpose with the python package.



  Preliminary documentation is available at: https://astro.ymniquet.fr/codes/equimagelab/docs/

  Dec. 15, 2024: this project is still under heavy development and not yet ready for general use; a more complete documentation with examples will follow soon.


pkgId: cff1c92635f69a20fca0bcecbef78b084fc3cf92ba56e65661e9dbeb6a6b74ff
name: python-earningscall-help
arch: noarch
version: 0.0.26
epoch: 0
release: 1
summary: Development documents and examples for earningscall
url: https://earningscall.biz
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-earningscall-0.0.26-1.src.rpm
location_href: Packages/python-earningscall-help-0.0.26-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/earningscall.svg)](https://pypi.org/project/earningscall/)
  [![Build Status](https://github.com/EarningsCall/earningscall-python/actions/workflows/release.yml/badge.svg?branch=master)](https://github.com/EarningsCall/earningscall-python/actions?query=branch%3Amaster)
  [![Coverage Status](https://coveralls.io/repos/github/EarningsCall/earningscall-python/badge.svg?branch=master)](https://coveralls.io/github/EarningsCall/earningscall-python?branch=master)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/earningscall?color=blue)](https://pypi.org/project/earningscall/)

  [![Python](https://img.shields.io/badge/Python-14354C?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)


  The EarningsCall Python library provides convenient access to the [EarningsCall API](https://earningscall.biz/api-guide) from
  applications written in the Python language. It includes a pre-defined set of
  classes for API resources that initialize themselves dynamically from API
  responses.



  * Python 3.8+



  You don't need this source code unless you want to modify the package. If you just want to use the package, just run:

  ```sh
  pip install --upgrade earningscall
  ```



  ```python
  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  transcript = company.get_transcript(year=2021, quarter=3)
  print(f"{company} Q3 2021 Transcript Text: \"{transcript.text[:100]}...\"")
  ```

  Output

  ```text
  Apple Inc. Q3 2021 Transcript Text: "Good day, and welcome to the Apple Q3 FY 2021 Earnings Conference Call. Today's call is being record..."
  ```





  ```python
  from datetime import datetime

  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  print(f"Getting all transcripts for: {company}..")

  for event in company.events():
      if datetime.now().timestamp() < event.conference_date.timestamp():
          print(f"* {company.company_info.symbol} Q{event.quarter} {event.year} -- skipping, conference date in the future")
          continue
      transcript = company.get_transcript(event=event)  # Fetch the earnings call transcript for this event
      print(f"* Q{event.quarter} {event.year}")
      if transcript:
          print(f"  Transcript Text: \"{transcript.text[:100]}...\"")
      else:
          print(f"  No transcript found.")

  ```

  Output

  ```text
  Getting all transcripts for: Apple Inc...
  * Q4 2023
    Transcript Text: "Good day and welcome to the Apple Q4 Fiscal Year 2023 earnings conference call. Today's call is bein..."
  * Q3 2023
    Transcript Text: "Good day and welcome to the Apple Q3 Fiscal Year 2023 earnings conference call. Today's call is bein..."
  * Q2 2023
    Transcript Text: "At this time for opening remarks and introductions, I would like to turn the call over to Suhasini T..."
  * Q1 2023

    ...
  ```




  If you want to get the text by speaker, you can do so by setting the `level` parameter to `2`.

  NOTE: Level `2` data is provided in any plan that includes Enhanced Transcript Data.

  ```python
  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  transcript = company.get_transcript(year=2021, quarter=3, level=2)

  first_speaker = transcript.speakers[0]
  speaker_label = first_speaker.speaker
  text = first_speaker.text
  print(f"Speaker: {speaker_label}\nText: {text}")
  ```

  Output

  ```text
  Speaker: spk11
  Text: Good day, and welcome to the Apple Q3 FY 2021 Earnings Conference Call. Today's call is being recorded. At this time, for opening remarks and introductions, I would like to turn the call over to Tejas Ghala, Director, Investor Relations and Corporate Finance. Please go ahead.
  ```




  NOTE: This is a new experimental feature.  It includes Speaker Names and Titles.

  ```python
  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  transcript = company.get_transcript(year=2021, quarter=3, level=2)

  speaker = transcript.speakers[1]  # Get second speaker
  speaker_label = speaker.speaker_info.name
  text = speaker.text
  print("Speaker:")
  print(f"  Name: {speaker.speaker_info.name}")
  print(f"  Title: {speaker.speaker_info.title}")
  print()
  print(f"Text: {text}")
  ```

  Output

  ```text
  Speaker:
    Name: Tejas Ghala
    Title: Director, Investor Relations and Corporate Finance

  Text: Thank you. Good afternoon, and thank you for joining us. Speaking first today is Apple CEO Tim Cook, and he'll be followed by CFO Luca Maestri. After that, we'll open the call to questions from analysts. Please note that some of the information you'll hear during our discussion today will consist of forward-looking statements, including without limitation, those regarding revenue, gross margin, operating expenses, other income and expenses, taxes, capital allocation, and future business outlook, including the potential impact of COVID-19 on the company's business and results of operations. These statements involve risks and uncertainties that may cause actual results or trends to differ materially from our forecast. For more information, please refer to the risk factors discussed in Apple's most recently filed annual report on Form 10-K and the Form 8-K filed with the SEC today, along with the associated press release. Apple assumes no obligation to update any forward-looking statements or information which speak as of their respective dates. I'd like to now turn the call over to Tim for introductory remarks.
  ```



  If you want to get the word-level timestamps, you can do so by setting the `level` parameter to `3`.

  Each timestamp is the number of seconds since the start of the transcript.

  NOTE: Level `3` data is provided in any plan that includes Enhanced Transcript Data.


  ```python
  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  transcript = company.get_transcript(year=2021, quarter=3, level=3)

  first_speaker = transcript.speakers[0]
  words_and_start_times = list(zip(first_speaker.words, first_speaker.start_times))
  print(f"Speaker: {first_speaker.speaker}")
  print(f"Words with start times: {words_and_start_times}")
  ```

  Output

  ```text
  Speaker: spk11
  Words with start times: [('Good', 0.049), ('day,', 0.229), ('and', 0.489), ('welcome', 0.609), ('to', 0.929), ('the', 1.029), ('Apple', 1.229), ('Q3', 1.629), ('FY', 2.65), ('2021', 2.6599999999999997), ('Earnings', 3.81), ('Conference', 4.17), ('Call.', 4.55), ("Today's", 5.411), ('call', 5.811), ('is', 6.111), ('being', 6.271), ('recorded.', 6.471), ('At', 7.571), ('this', 7.671), ('time,', 7.871), ('for', 8.111), ('opening', 8.351), ('remarks', 8.631), ('and', 9.092), ('introductions,', 9.232), ('I', 9.832), ('would', 9.912), ('like', 10.052), ('to', 10.192), ('turn', 10.292), ('the', 10.492), ('call', 10.592), ('over', 10.872), ('to', 11.052), ('Tejas', 11.152), ('Ghala,', 11.532), ('Director,', 12.112), ('Investor', 12.533), ('Relations', 12.873), ('and', 13.353), ('Corporate', 13.473), ('Finance.', 13.773), ('Please', 14.413), ('go', 14.653), ('ahead.', 14.793)]
  ```



  If you want to get the prepared remarks and Q&A for a single quarter, you can do so by setting the `level` parameter to `4`.

  NOTE: Level `4` data is provided in any plan that includes Enhanced Transcript Data.

  ```python
  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  transcript = company.get_transcript(year=2021, quarter=3, level=4)
  print(f"{company} Q3 2021 Prepared Remarks: \"{transcript.prepared_remarks[:100]}...\"")
  print(f"{company} Q3 2021 Q&A: \"{transcript.questions_and_answers[:100]}...\"")
  ```

  Output

  ```text
  Apple Inc. Q3 2021 Prepared Remarks: "Good day, and welcome to the Apple Q3 FY 2021 Earnings Conference Call. Today's call is being record..."
  Apple Inc. Q3 2021 Q&A: "Our first question comes from Katie Huberty from Morgan Stanley. Please go ahead. Hello, Katie. Your..."
  ```



  If you want to download the audio file for a single quarter, you can call the `download_audio_file` function.

  ```python
  from earningscall import get_company

  company = get_company("aapl")  # Lookup Apple, Inc by its ticker symbol, "AAPL"

  print("Downloading audio file for Apple Inc. Q3 2021...")
  audio_file = company.download_audio_file(year=2021, quarter=3, file_name="Apple Q3 2021.mp3")
  ```



  ```python
  from earningscall import get_all_companies

  for company in get_all_companies():
      print(f"{company.company_info} -- {company.company_info.sector} -- {company.company_info.industry}")
  ```

  By default, this library grants you access to only two companies, Apple Inc. and Microsoft, Inc.

  To gain access to 5,000+ companies please [signup here](https://earningscall.biz/api-pricing) to get your API key.

  Once you have access to your API key, you can set the API Key like this:

  ```python
  import earningscall

  earningscall.api_key = "YOUR-SECRET-API-KEY-GOES-HERE"
  ```

  Alternatively, you can pass in your API key as an environment variable:

  ```sh
  export EARNINGSCALL_API_KEY="YOUR-SECRET-API-KEY-GOES-HERE"
  python your-python-script.py
  ```



  ```python
  from earningscall import get_sp500_companies

  for company in get_sp500_companies():
      print(f"{company.company_info} -- {company.company_info.sector} -- {company.company_info.industry}")
  ```






  When you call `get_company("aapl")` to retrieve a company, internally the library retrieves metadata
  from the EarningsCall API.  By default, it caches this metadata on disk in order to speed up subsequent requests.

  If you prefer to disable this local caching behavior, you can do so with this code:

  ```python
  import earningscall

  earningscall.enable_requests_cache = False
  ```

rpm_license:
  MIT License  Copyright (c) 2024 EarningsCall  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: 6706efa1948a89ee399e77f5bddcd29ce80459112a7d74a390f887e44b2500a5
name: python-earthdaily-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for earthdaily
url: https://pypi.org/project/earthdaily/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-earthdaily-0.3.4-1.src.rpm
location_href: Packages/python-earthdaily-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  The **EarthDaily Python client** simplifies access to the Earth Data Store STAC catalog and streamlines workflows for geospatial data analysis and Earth observation. It automates key preprocessing tasks, making it easier to work with Earth observation data.

  - **Easy Data Access**: Connect directly to the Earth Data Store STAC catalog.
  - **Automated Datacube Creation**: Includes reflectance conversion and clipping to areas of interest.
  - **Scalable Processing**: Fully compatible with Dask for handling large datasets.
  This package is designed to make geospatial workflows more efficient and accessible for researchers and analysts working with Earth observation data.

  Make sure you have valid Earth Data Store authentication credentials. These can be retrieved from the [EarthDaily Account Management](https://console.earthdaily.com/account) page.
  <p align="center">
  <img src="https://github.com/earthdaily/earthdaily-python-client/raw/main/docs/assets/images/account.png" width="450">
  </p>


  `pip install earthdaily`

  ```console

  git clone git@github.com:earthdaily/earthdaily-python-client.git
  cd earthdaily-python-client

  conda env create -n earthdaily -f requirements.yml
  conda init
  conda activate earthdaily

  pip install -e .
  ```

  Authentication credentials can be automatically parsed from environment variables.
  The [python-dotenv](https://github.com/theskumar/python-dotenv) package is supported for convenience.
  Rename the `.env.sample` file in this repository to `.env` and enter your Earth Data Store authentication credentials.
  Note this file is gitingored and will not be committed.
  In your script or notebook, add:
  ```python
  from dotenv import load_dotenv
  load_dotenv(".env")  # Load environment variables from .env file
  ```

  To help you get started quickly, we provide a `quickstart.ipynb` Jupyter notebook that demonstrates how to use the EarthDaily Python client. You only need your `.env` file with your authentication credentials to run it.
  Simply open the notebook, load your environment variables as shown above, and follow the instructions to begin accessing and analyzing Earth observation data.

  If this project has been helpful and saved you time, please consider giving it a star ⭐

  © EarthDaily | All Rights Reserved.


pkgId: 3560c0cf1660e5ae095a8ff324a8d8516bd13771edb90076b33c1e96268a285f
name: python-earthkit-data-help
arch: noarch
version: 0.12.0
epoch: 0
release: 1
summary: Development documents and examples for earthkit-data
url: https://github.com/ecmwf/earthkit-data/
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-earthkit-data-0.12.0-1.src.rpm
location_href: Packages/python-earthkit-data-help-0.12.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src="docs/_static/earthkit-data.png" width="120">

  [![PyPI version fury.io](https://badge.fury.io/py/earthkit-data.svg)](https://pypi.python.org/pypi/earthkit-data/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/earthkit-data.svg)](https://pypi.python.org/pypi/earthkit-data/)

  **DISCLAIMER**

  > This project is in the **BETA** stage of development. Please be aware that interfaces and functionality may change as the project develops. If this software is to be used in operational systems you are **strongly advised to use a released tag in your system configuration**, and you should be willing to accept incoming changes and bug fixes that require adaptations on your part. ECMWF **does use** this software in operations and abides by the same caveats.

  A format-agnostic interface for geospatial data with a focus on meteorology and
  climate science.



  The documentation can be found at https://earthkit-data.readthedocs.io/.



  Install via `pip` with:

  ```
  $ pip install earthkit-data
  ```

  More details, such as how to install any necessary binaries, can be found  at https://earthkit-data.readthedocs.io/en/latest/install.html.

  Alternatively, install via `conda` with:

  ```
  $ conda install earthkit-data -c conda-forge
  ```

  This will bring in some necessary binary dependencies for you.



  ```
  Copyright 2022, European Centre for Medium Range Weather Forecasts.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

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

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

  In applying this licence, ECMWF does not waive the privileges and immunities
  granted to it by virtue of its status as an intergovernmental organisation
  nor does it submit to any jurisdiction.
  ```


pkgId: 900d296848f820d0b76b705b6aae982a7bc0b7f4d34bc8db9c9b6c486579c7e2
name: python-earthkit-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for earthkit
url: https://github.com/ecmwf/earthkit/
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-earthkit-0.9.2-1.src.rpm
location_href: Packages/python-earthkit-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  <img src="docs/_static/earthkit.png" width="120">

  [![PyPI version fury.io](https://badge.fury.io/py/earthkit.svg)](https://pypi.python.org/pypi/earthkit/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/earthkit.svg)](https://pypi.python.org/pypi/earthkit/)

  **DISCLAIMER**

  > This project is in the **BETA** stage of development. Please be aware that interfaces and functionality may change as the project develops. If this software is to be used in operational systems you are **strongly advised to use a released tag in your system configuration**, and you should be willing to accept incoming changes and bug fixes that require adaptations on your part. ECMWF **does use** this software in operations and abides by the same caveats.

  **earthkit** is a project led by ECMWF, providing powerful tools for speeding up weather and climate science workflows by simplifying data access, processing, analysis, visualisation and much more.



  The documentation can be found at https://earthkit.readthedocs.io/.



  [Apache License 2.0](LICENSE) In applying this license, ECMWF does not waive the privileges and immunities
  granted to it by virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.


pkgId: 6377964a7deefb08ad89b8d7cbd7e339f5ae48ea6c2ab7ba11ee6a8093ec42db
name: python-earthspeed-help
arch: noarch
version: 1.2
epoch: 0
release: 1
summary: Development documents and examples for earthspeed
url: https://github.com/blillard/earthspeed
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-earthspeed-1.2-1.src.rpm
location_href: Packages/python-earthspeed-help-1.2-1.noarch.rpm
checksum_type: sha256
description:
  By Benjamin Lillard

  **For finding the instantaneous velocity of the Earth with respect to the galactic dark matter halo**



  This package tracks the effective DM wind velocity for a lab on Earth, including the annual effects from the Earth's orbit around the Sun.
  The parameters for the Earth-Sun system are taken from Lewin & Smith (1996), but with the corrected elliptical terms of arXiv:1312.1355. Updated values for the Local Standard of Rest (LSR) are taken from arXiv:2105.00599.
  This notebook uses the astropy package to convert galactic coordinates to ICRS, so that the location of the DM wind source on the sky can be expressed using right ascension (RA) and declination.
  Given a location on Earth, the package can also find the altitude and azimuth angles of the DM wind at any time of day.

  A Jupyter notebook "GalacticOrientations" demonstrates how to use the package with a few examples. The primary function is vEt(obstime), which returns the Earth velocity relative to the galactic center in Cartesian coordinates, at an observation date and time "obstime" provided in the format of the datetime package.


  **References:**

  J. D. Lewin and P. F. Smith, “Review of mathematics, numerical factors, and corrections for dark matter experiments based on elastic nuclear recoil,” Astropart. Phys. 6 (1996) 87–112.

  C. McCabe, "The Earth’s velocity for direct detection experiments," JCAP 02, 027 (2014), arXiv:1312.1355 [astro-ph.CO].

  D. Baxter et al., “Recommended conventions for reporting results from direct dark matter searches,” Eur. Phys. J. C 81 no. 10, (2021) 907, arXiv:2105.00599 [hep-ex].


pkgId: 88c8ba63d980597d99662dcbe7d58a2a4e58c396e3ba555a3d192cd2ab256e6e
name: python-east-tool-help
arch: noarch
version: 0.25.1
epoch: 0
release: 1
summary: Development documents and examples for east-tool
url: https://github.com/IRNAS/irnas-east-software
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-east-tool-0.25.1-1.src.rpm
location_href: Packages/python-east-tool-help-0.25.1-1.noarch.rpm
checksum_type: sha256
description:
  East is a command line meta-tool, useful for creating, managing, and deploying
  [Zephyr] or [nRF Connect SDK] (NCS) projects.

  [zephyr]: https://docs.zephyrproject.org/latest/
  [nrf connect sdk]:
    https://developer.nordicsemi.com/nRF_Connect_SDK/doc/latest/nrf/introduction.html

  It is built on top of Zephyr's RTOS meta-tool [West] and Nordic's [nRF Connect
  Toolchain Manager].

  [west]: https://github.com/zephyrproject-rtos/west
  [nrf connect toolchain manager]:
    https://github.com/NordicSemiconductor/pc-nrfconnect-toolchain-manager



  There are several reasons why someone would like to create yet another tool on
  top of `west`:

  - Working on several projects at once means using different versions of the NCS
    repository and different versions of the toolchain. Managing these differences
    is not a trivial task.
  - There is no reproducible build guarantee between the developer's machines.
    Slight differences between tool versions can manifest into hard-to-find bugs.
  - Creating GitHub releases manually takes ages as you have to run the build
    process for every combination of the board, application, build variant, etc.
    and properly rename the release binary. The release procedure gets longer with
    every addition of new hardware and build variation option.

  East automates the above tasks and tries to make the developer more productive.



  - Automated detection and installation of tooling required for NCS projects.
  - Common `west` commands used for the development, such as `build`, `flash`,
    etc.
  - Sandboxed development environment, thanks to the nRF Connect Toolchain
    Manager, every `build`, `flash`, etc. command runs inside of its toolchain
    environment.
  - Automated process of generating release artefacts for your entire project, no
    matter the number of applications, samples or boards.
  - Support for build types, which is integrated into the usual build process.
  - RTT utility commands to connect and see the RTT stream.



  `docs` directory contains several markdown documents about East:

  - [Getting stared] - Quickly setup an example project and get it building with
    East.
  - [How East works] - How East works under the hood and what to expect from it.
  - [Configuration] - How to configure build types and release procedure via
    `east.yml` file.
  - [Development guide] - How to setup development environment for working on
    East.

  [getting stared]: docs/getting_started.md
  [how east works]: docs/how_east_works.md
  [configuration]: docs/configuration.md
  [development guide]: docs/development_guide.md

rpm_license:
  MIT License  Copyright (c) [year] [fullname]  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: 4e3de4a385d72df688746c925c1ca7dda68ef493c81ccbb1d02c0f34a53d56c5
name: python-easy-commit-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for easy-commit
url: https://github.com/PraNavKumAr01/easy_commit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-commit-0.1.7-1.src.rpm
location_href: Packages/python-easy-commit-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  AI-powered Git commit message generator using Groq API.



  ```bash
  pip install easy-commit
  ```




  ```bash
  git add .
  ```
  It is neccesary to first stage all your changes. This picks up the code diffs from the staged changes.


  ```bash
  export GROQ_API_KEY=your_groq_api_key_here
  ```


  ```bash
  easy-commit --api-key your_groq_api_key_here
  ```

  Optional arguments:
  - `--trunc-diff`: Maximum length of diff to analyze (default: 2048)
  - `--commit-len`: Maximum length of commit message (default: 100)


  ```bash
  easy-commit
  ```
  Yes! Thats actually all it takes. You will be shown the commit message, and prompted to press enter to perform the commit


  ```bash
  easy-commit --trunc-diff 1024 --commit-len 50 --model-name "llama3-8b-8192"
  ```


  - Python 3.7+
  - Groq API key


pkgId: 642b84636d0bb707b3e72fe10e1c2fb92808a5c7ce9aceac7e4dd29cae6f5bfb
name: python-easy-commit-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for easy-commit
url: https://github.com/PraNavKumAr01/easy_commit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-commit-0.2.1-1.src.rpm
location_href: Packages/python-easy-commit-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  AI-powered Git commit message generator



  ```bash
  pip install easy-commit
  ```




  ```bash
  git add .
  ```
  It is neccesary to first stage all your changes. This picks up the code diffs from the staged changes.



  ```bash
  easy-commit --provider groq --api-key your-api-key --save-config
  ```

  Arguments:
  - `--diff-size` : Maximum length of diff to analyze (default: 2048)
  - `--trunc-diff`: Flag to include multiple diffs or truncate the diff (default: False)

  - `--commit-len`: Maximum length of commit message (default: 100)
  - `--provider` :  API provider to use for LLM functionality (default: groq)
  - `--api-key` : API key for the selected LLM provider
  - `--save-config` : Flag to save the provided configuration of easier accesability later (default: False)




  ```bash
  easy-commit
  ```
  Yes! Thats actually all it takes. You will be shown the commit message, and prompted to press enter to perform the commit


  ```bash
  easy-commit --diff-size 1024 --commit-len 50 --provider groq --api-key your-api-key
  ```


  - Python 3.7+
  - Groq API key


pkgId: 87f9dc8856340fcf95bc49dd7439fdc0e3b26a4ce33445f35790bd2467916698
name: python-easy-flagger-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for easy-flagger
url: https://github.com/Doneeel/easy-flagger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-flagger-1.0-1.src.rpm
location_href: Packages/python-easy-flagger-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  Simple flag processing for Python



  - [x] int
  - [x] float
  - [x] str
  - [x] bool
  - [x] list



  ```bash
  pip install simple-flagger
  ```


  ```python

  from flagger import Flagger

  if __name__ == "__main__":
      flag = Flagger()
      f_flag = flag.parse_flag("-f", float)

      print(f_flag) # >> 10.3
  ```


  ```python

  from flagger import Flagger

  if __name__ == "__main__":
      flag = Flagger()
      l_flag = flag.parse_flag("-l", list, sep=",")

      print(l_flag) # >> ['1', '2', '3']
  ```


pkgId: 98609fd82eccc65e428c2e21282b5a38df9a987bf8caf81800721487059e35ab
name: python-easy-pyoc-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for easy-pyoc
url: https://github.com/one-ccs/easy_pyoc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-pyoc-0.7.1-1.src.rpm
location_href: Packages/python-easy-pyoc-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  自定义 Python 包，封装一些功能

  注：带 `*` 的需要额外安装依赖，并使用完整路径导入



  - `ServerSocket` TCP/UDP/MULTICAST 服务端
  - `ClientSocket` TCP/UDP/MULTICAST 客户端



  - `DatetimeUtil` 日期相关工具
  - *`FlaskUtil` Flask 相关工具
  - `ObjectUtil` 对象相关工具
  - `PathUtil` 路径相关工具
  - `StringUtil` 字符串相关工具
  - `XMLUtil` xml 相关工具



  实现自定义标题栏的窗口，包含放大、缩小、关闭的基本功能，实现窗口移动，拖动改变大小。

  支持加载本地图片或网络资源为背景图片。

  配合 OcGuiIconRc 默认的 QSS 效果，可以实现较为不错的主窗口。



  * 自定义标题栏，不可单独使用.



  * 自定义窗口，内置 自定义标题栏及 qss;

  1. 实现了自定义标题栏的主窗口，包含以下功能：

     + 窗口最大化、最小化、关闭;
     + 窗口移动;
     + 拖动改变窗口大小;
  2. 基于 requests.get 实现了从互联网及本地加载背景图片.


pkgId: 6189c5102fade639cf579df0e350fa38eb05c4d961c13ddbfc33764cec6d3c43
name: python-easy-rss-help
arch: noarch
version: 1.2.6
epoch: 0
release: 1
summary: Development documents and examples for easy-rss
url: https://github.com/michaelMondoro/easy_rss
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-rss-1.2.6-1.src.rpm
location_href: Packages/python-easy-rss-help-1.2.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Generic badge](https://img.shields.io/badge/Licence-MIT-blue.svg)](https://shields.io/)
  [![Generic badge](https://img.shields.io/badge/Maintained-yes-green.svg)](https://shields.io/)
  [![Generic badge](https://img.shields.io/badge/easy_rss-1.2.6-red.svg)](https://pypi.org/project/easy-rss)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/easy_rss)](https://pypi.org/project/easy-rss)


  Simple Python package for processing data from RSS feeds

  Can parse both `Atom` and `RSS` formats


  ```python
  from easy_rss import *

  rss = EasyRSS("https://rss.nytimes.com/services/xml/rss/nyt/World.xml")
  for item in rss.get_news():
      print(f"\n{item}\n")

  ```


  ```
  Item(title='Live Updates: Russia Unleashes New Strikes as Ukraine Prepares for Cabinet Shake-Up', link='https://www.nytimes.com/live/2024/09/04/world/ukraine-russia-missile-attacks', pubDate='Sep 04, 2024 01:30PM', description='Several ministers offered to resign as President Volodymyr Zelensky laid plans for a major reshuffle of Ukraine’s government. While rescuers searched the rubble of a deadly strike on a military academy in eastern Ukraine, another Russian attack killed seven in the west.')


  Item(title='Poltava Strike Aftermath Drains Ukraine’s Seasoned Rescuers', link='https://www.nytimes.com/2024/09/04/world/europe/ukraine-poltava-strike-aftermath.html', pubDate='Sep 04, 2024 05:50AM', description='Repeated air-raid alerts have punctuated the search through the rubble in Poltava, in eastern Ukraine, after an attack that killed more than 50 people.')


  Item(title='With New Taliban Manifesto, Afghan Women Fear the Worst', link='https://www.nytimes.com/2024/09/04/world/asia/women-taliban-prohibitions-afghanistan.html', pubDate='Sep 04, 2024 12:37PM', description='Three years into its rule, the movement has codified its harsh Islamic decrees into law that now includes a ban on women’s voices in public.')


  Item(title='Cease-Fire Talks Present Tough Choices for Gazans Devastated by War', link='https://www.nytimes.com/2024/09/04/world/middleeast/gaza-war-cease-fire-israel.html', pubDate='Sep 04, 2024 05:04AM', description='Some say they will reluctantly stomach a postwar Israeli military presence in the territory if that allows them to go home. Others worry about another long-term occupation.')
  ```


pkgId: 6ac7e415e34117cee2e4014bf0b3e9ee178d9f79de6bfc85a544473cd7985454
name: python-easy-scpi-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for easy-scpi
url: https://github.com/bicarlsen/easy-scpi
rpm_license: MIT OR Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-scpi-0.1.6-1.src.rpm
location_href: Packages/python-easy-scpi-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  A simple and robust library making communication with [SCPI](https://en.wikipedia.org/wiki/Standard_Commands_for_Programmable_Instruments) (Standard Control of Programmbale Instruments) instruments easy. After creating an instrument object that connects to an actual instrument, commands are sent to the instrument using a property-like format. This class is useful for inheritance when creating a controller for a specific instrument. Communication with instruments is done with [PyVISA](https://pyvisa.readthedocs.io).

  Install with
  > `python -m pip install easy-scpi`



  Generic SCPI commands can be executed by transforming the SCPI code in to attributes via the hierarchy relationship, then calling it. Instrument properties can be queried by passing no arguments to the call (or specifying query=True). Commands with no arguments are run by passing an empty string to the call.


  ~~~python

  import easy_scpi as scpi


  inst = scpi.Instrument( <port> )


  inst.measure.voltage.dc()

  inst.meas.volt.dc()


  inst.measure.voltage.dc("MIN", query=True)


  inst.measure.voltage.dc( 1 )

  inst.source.voltage( '1' )


  inst.syst.zcor.aqc( '' )
  ~~~



  **Instrument( &lt;port&gt;, backend = '', \*\*resource_params ):** Creates an instance of a SCPI instrument. The **backend** is used to create the [VISA Resource Manager](https://pyvisa.readthedocs.io/en/latest/introduction/getting.html#backend). Upon connection, the **resource_params** are passed to the [VISA resource](https://pyvisa.readthedocs.io/en/latest/introduction/resources.html).

  **connect():** Connects the object instance to the actual instrument on the specified port.

  **disconnect():** Disconnects the instrument from the program, closing the port.

  **write( &lt;msg&gt; ):** Sends **msg** to the instrument.

  **read():** Gets the most recent response from the instrument.

  **query( &lt;msg&gt; ):** Sends **msg** to the instrument and returns its response.

  **reset():** Sets the instrument to its default state.

  **init():** Initializes the instrument for a measurement.


  **backend:** Returns the name of the VISA backend used. [Read Only]

  **inst:** Returns the resource used by the instance. [Read Only]

  **port:** The communication port.

  **handshake:** Handshake mode of the device. If a string is provided a handshake message will be read after every command or query. If the message matches the string, nothing occurs, otherwise an error is raised. If True a default message of 'OK' is used. If False no message is read. [Default: False]

  **rid:** The resource id associated with the instrument. [Read Only]

  **resource_params:** Returns the resource parameters passed on creation. [Read Only]

  **timeout:** The communication timeout of the instrument. [Read Only]

  **id:** The manufacturer id of the instrument. [Read Only]

  **value:** The current value of the instrument. [Read Only]

  **connected:** Whether the instrument is connected or not. [Read Only]

  **is_connected:** Alias for **connected**.



  ~~~python

  import easy_scpi as scpi

  class PowerSupply( scpi.Instrument ):

      def __init__( self ):
          super().__init__(
              port = None,
              timeout = 5,
              read_termination = '\n',
              write_termination = '\n'
          )

          


      


      @property
      def voltage( self ):
          """
          Returns the voltage setting
          """
          return self.source.volt.level()


      @voltage.setter
      def voltage( self, volts ):
          """
          Sets the voltage of the instrument
          """
          self.source.volt.level( volts )


      @property
      def current( self ):
          """
          Returns the current setting in Amps
          """
          return self.source.current.level()


      @current.setter
      def current( self, amps ):
          """
          Set the current of the instrument
          """
          self.source.current.level( amps )


      def on( self ):
          """
          Turns the output on
          """
          self.output.state( 'on' )


      def off( self):
          """
          Turns the output off
          """
          self.output.state( 'off' )

  ~~~


pkgId: 9f29fb22904b04948dc709dba8a4168efd93364049153df8728181b4554bdd85
name: python-easy-tree-maker-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for easy-tree-maker
url: https://github.com/MahrezBH/easy_tree_maker
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easy-tree-maker-0.1.2-1.src.rpm
location_href: Packages/python-easy-tree-maker-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A simple Python package that creates a directory and file structure from a given JSON or Python object.



  You can install the package using pip:

  ```bash
  pip install easy-tree-maker
  ```



  You can use the `TreeMaker` class to create directories and files based on a JSON or Python structure.


  ```python
  from easy_tree_maker.core import TreeMaker

  tree_structure = [
      {
          "type": "directory",
          "name": "TestProject",
          "contents": [
              {"type": "file", "name": "README.md"},
              {"type": "directory", "name": "src", "contents": [
                  {"type": "file", "name": "app.py"}
              ]}
          ]
      }
  ]

  tree_maker = TreeMaker(tree_structure, is_json=False)
  tree_maker.create_tree(root_path="./TestDirectory")
  ```


  ```python
  import json
  from tree_maker.core import TreeMaker

  tree_structure_json = json.dumps([
      {
          "type": "directory",
          "name": "TestProject",
          "contents": [
              {"type": "file", "name": "README.md"},
              {"type": "directory", "name": "src", "contents": [
                  {"type": "file", "name": "app.py"}
              ]}
          ]
      }
  ])

  tree_maker = TreeMaker(tree_structure_json, is_json=True)
  tree_maker.create_tree(root_path="./TestDirectory")
  ```


pkgId: d2d40d8b0b4439bdb0f34ce67ffbeb0364d1953316c9927e938ff9f93497879e
name: python-easyfig-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for easyfig
url: https://github.com/Jesse-tien/Easyfig
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easyfig-1.0.0-1.src.rpm
location_href: Packages/python-easyfig-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  工具安装方式：
  （1）安装Python，推荐最新版本即可。官网[https://www.python.org/](https://www.python.org/)
  （2）``Ctrl+R``，输入``cmd``打开命令窗口（黑的），然后在命令窗口内输入：
  ``pip install easyfig``
  等待安装完成即可。



  本工具独创UI界面向导，无需输入代码，即可完成仿真绘图，并自动生成规范的Python代码。启动方式：

  （1）``Ctrl+R``，输入``cmd``打开命令窗口（黑的）;
  （2）在命令窗口内输入``easyfig``回车即可。非常简单！

  ![png](https://pic2.zhimg.com/v2-1485cd2b208fb7d724935237560ffc2b_r.jpg)

  ![png](https://pic2.zhimg.com/v2-70eaa4630d67322160696b6b48792ecf_r.jpg)

  ![png](https://pic3.zhimg.com/v2-1dfa71269643a7bb22a8968f0842d1d0_r.jpg)

  ![png](https://pic2.zhimg.com/v2-9bbb00eb2a444d5e467f6b7c8afc75d3_r.jpg)




  ```python
  from easyfig import *   # 固定写法
  %config InlineBackend.figure_format = 'retina' # 在 Jupyter 中显示高清图片
  ```




  ```python

  data = {
      '景区1旅游人次': [1230, 45789, 2600, 320, 991480, 65780, 89990, 70001, 6423, 415000, 340, 102],
      '景区2旅游人次': [800, 34000, 1690, 139, 76788, 453565, 87898, 64302, 3423, 325001, 127, 13],
      '景区3旅游人次': [5230, 65789, 7600, 820, 1091480, 85780, 99995, 90001, 9423, 705000, 640, 707],
  }


  label_x = ['2020-1', '2020-2', '2020-3', '2020-4',  '2020-5', '2020-6',  '2020-7',  '2020-8',  '2020-9',
             '2020-10',  '2020-11',  '2020-12']


  x_name = '月总旅游人次'
  y_name = '月份'


  save_dir = 'data_sigle.tiff'



  location = 'best'

  ncol = 1

  fsize = 14 # 图片中字号的大小，默认值为14。
  figsize = [7, 5] # 图片的大小，写成`[宽, 高]`的形式。


  xt_rotation = 45


  xrotation = 0

  yrotation = 90


  linestyles = ['-', '-.','--']
  linewidth = 1.2 # 线粗。

  markers = ['o','s', '*'] # 线上的标记符号,关于标记符号的详细说明 https://matplotlib.org/stable/api/markers_api.html#module-matplotlib.markers
  markersize = 3.5 # 标记符号的大小，默认3.5。

  colors = ['blue','red','green']

  isgrid = False # 是否要网格。要就填True，不要就是False，默认不要。

  xpad = 3
  ypad = 3

  xlabelpad = 3
  ylabelpad = 3


  xlabelsize = 39 # 横轴字大小，默认'auto'，自动和fsize一样大
  ylabelsize = 9 # 纵轴字大小，默认'auto'，自动和fsize一样大
  legendsize = 17 # 图例字大小，默认'auto'，自动和fsize一样大



  plt = data_lines(data, label_x=label_x, x_name=x_name, y_name=y_name, save_dir=save_dir, location=location, ncol=ncol,
             fsize=fsize, figsize=figsize, xt_rotation=xt_rotation, xrotation=xrotation, yrotation=yrotation,
             linestyles=linestyles, linewidth=linewidth, markers=markers, markersize=markersize, colors=colors,
            isgrid=isgrid, xpad=xpad, ypad=ypad, xlabelpad=xlabelpad, ylabelpad=ylabelpad,
              xlabelsize=xlabelsize, ylabelsize=ylabelsize, legendsize=legendsize)
  ```


  ![png](https://pic3.zhimg.com/v2-4416be060ee29b77e00d2a573c366a16_r.jpg)





  ```python


  c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha = symbols('c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha')



  expressions = {
      r'$\pi_r^{NW}$': E*p_e+(k*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2)/(8*(k+alpha*delta*(1-alpha*delta))**2),
      r'$\pi_r^{BW}$': E*p_e + ( k*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+delta-delta**2)**2),
      r'$\pi_r^{NS}$': E*p_e + ((k+2*alpha*delta)*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2 )/( 8*(k+alpha*delta*(2-alpha*delta))**2),
      r'$\pi_r^{BS}$': E*p_e + ( (k+2*delta)*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+2*delta-delta**2)**2),
  }



  assigns = {c_n: 0.2, c_r: 0.1, delta: 0.8, e_n: 1, e_r: 0.6, p_e: 0.1, E: 2, k: 1.1, alpha:0.9}



  the_var = b
  ranges = [0, 0.08, 0.01]  # [起始值, 终止值, 间隔]。 [Starting value, ending value, interval].



  x_name = r'(a) Parameter $b$'
  y_name = r'$\pi_r$'



  save_dir = r'mutiple_line.tiff'



  location = 'best'


  ncol = 1

  fsize = 14

  figsize = [5, 4]

  xt_rotation = 0 # 横轴刻度标签旋转角度。用于刻度为年份，横着挤不下的情况，可以设成45度，错开排布。默认不旋转，即0度。

  xrotation = 0
  yrotation = 90

  linestyles = ['-','-.','--', ':'] # 线的风格，实线'-'，点横线'-.'，虚线'--'，点线':'。
  linewidth = 1.0 # 线粗。
  markers = ['o','s', '*', 'P'] # 线上的标记符号,关于标记符号的详细说明 https://matplotlib.org/stable/api/markers_api.html#module-matplotlib.markers
  markersize = 3.5 # 标记符号的大小，默认3.5。

  colors = ['black','blue','red','green']


  isgrid = False


  xpad = 3
  ypad = 3


  xlabelpad = 13
  ylabelpad = 2


  xlabelsize = 39 # 横轴字大小，默认'auto'，自动和fsize一样大
  ylabelsize = 9 # 纵轴字大小，默认'auto'，自动和fsize一样大
  legendsize = 17 # 图例字大小，默认'auto'，自动和fsize一样大




  draw_lines(expressions=expressions, assigns=assigns, the_var=the_var, ranges=ranges, x_name=x_name, y_name=y_name,
             save_dir=save_dir, location=location, ncol=ncol, fsize=fsize, figsize=figsize, xt_rotation=xt_rotation,
            xrotation=xrotation, yrotation=yrotation, linestyles=linestyles, linewidth=linewidth, markers=markers,
            markersize=markersize, colors=colors, isgrid=isgrid, xpad=xpad, ypad=ypad, xlabelpad=xlabelpad, ylabelpad=ylabelpad,
             xlabelsize=xlabelsize, ylabelsize=ylabelsize, legendsize=legendsize)
  ```




  ![png](https://picx.zhimg.com/v2-64a2347a6f7fe4499423e3653bf711cb_r.jpg)





  ```python


  c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha = symbols('c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha')



  expressions = {
      r'$\pi_r^{NW}$': E*p_e+(k*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2)/(8*(k+alpha*delta*(1-alpha*delta))**2),
      r'$\pi_r^{BW}$': E*p_e + ( k*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+delta-delta**2)**2),
      r'$\pi_r^{NS}$': E*p_e + ((k+2*alpha*delta)*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2 )/( 8*(k+alpha*delta*(2-alpha*delta))**2),
      r'$\pi_r^{BS}$': E*p_e + ( (k+2*delta)*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+2*delta-delta**2)**2),
  }



  assigns = {c_n: 0.2, c_r: 0.1, delta: 0.8, e_n: 1, e_r: 0.6, p_e: 0.1, E: 2, k: 1.1}



  the_var_x = alpha
  start_end_x = [0.7, 0.8]  # [起始值, 终止值]。 [starting value, ending value].
  the_var_y = b
  start_end_y = [0, 0.08]  # [起始值, 终止值]。 [starting value, ending value].



  x_name = r'$\alpha$'
  y_name = r'$b$'
  z_name = r'$\pi_r$'



  save_dir = r'muti_3d.tiff'


  color_alpha = 0.8



  location = 'best'

  ncol = 4

  fsize = 14

  figsize = [7, 5]

  xrotation = 0
  yrotation = 0

  zrotation = 90

  isgrid = True


  colors = ['yellow','blue','red','green']

  edgecolor = 'black'
  linestyles = ['-','-.','--', ':'] # 实线'-'，点横线'-.'，虚线'--'，点线':'。
  linewidth = 0.5 # 线粗。
  density = 50 # 曲面上画线的密度，也就是曲面横纵方向各画多少根线。默认100。


  elevation = 15

  azimuth = 45


  left_margin = 0
  bottom_margin = 0
  right_margin = 1
  top_margin = 1


  xpad = 1
  ypad = 1
  zpad = 5


  xlabelpad = 2
  ylabelpad = 2
  zlabelpad = 12


  xlabelsize = 39 # 横轴字大小，默认'auto'，自动和fsize一样大
  ylabelsize = 9 # 纵轴字大小，默认'auto'，自动和fsize一样大
  zlabelsize = 'auto' # 纵轴字大小，默认'auto'，自动和fsize一样大
  legendsize = 19 # 图例字大小，默认'auto'，自动和fsize一样大




  draw_3D(expressions=expressions, assigns=assigns, the_var_x=the_var_x, start_end_x=start_end_x, the_var_y=the_var_y,
          start_end_y=start_end_y, x_name=x_name, y_name=y_name, z_name=z_name,
          save_dir=save_dir, color_alpha=color_alpha, location=location, ncol=ncol, fsize=fsize, figsize=figsize,
          xrotation=xrotation, yrotation=yrotation, zrotation=zrotation, isgrid=isgrid, colors=colors,
          edgecolor=edgecolor, linestyles=linestyles, linewidth=linewidth, density=density, elevation=elevation, azimuth=azimuth,
          left_margin=left_margin, bottom_margin=bottom_margin, right_margin=right_margin, top_margin=top_margin,
          xpad=xpad, ypad=ypad, zpad=zpad, xlabelpad=xlabelpad, ylabelpad=ylabelpad, zlabelpad=zlabelpad,
         xlabelsize=xlabelsize, ylabelsize=ylabelsize, zlabelsize=zlabelsize, legendsize=legendsize)
  ```


  ![png](https://pic3.zhimg.com/v2-d942b6b539e387c83b601d4433d6687e_r.jpg)





  ```python


  c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha = symbols('c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha')



  expressions = {
      r'$\pi_r^{NW}$': E*p_e+(k*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2)/(8*(k+alpha*delta*(1-alpha*delta))**2),
      r'$\pi_r^{BW}$': E*p_e + ( k*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+delta-delta**2)**2),
      r'$\pi_r^{NS}$': E*p_e + ((k+2*alpha*delta)*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2 )/( 8*(k+alpha*delta*(2-alpha*delta))**2),
      r'$\pi_r^{BS}$': E*p_e + ( (k+2*delta)*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+2*delta-delta**2)**2),
  }



  assigns = {c_n: 0.2, c_r: 0.1, delta: 0.8, e_n: 1, e_r: 0.6, p_e: 0.1, E: 2, k: 1.1}



  the_var_x = alpha
  start_end_x = [0.7, 0.8]  # [起始值, 终止值]。 [starting value, ending value].
  the_var_y = b
  start_end_y = [0, 0.08]  # [起始值, 终止值]。 [starting value, ending value].



  x_name = '$\\alpha$ \n (b) With blockchain'
  y_name = r'$b$'



  save_dir = r'max_area.tiff'



  texts = [r'NW', r'BW', r'NS', r'BS']
  colors = ['#dae3f3', '#fbe5d6', '#e2f0d9', '#ededed']
  patterns = [' ', '+', '\\', '-']


  text_fsize_add = 2 # 区域标签字号增量。 Increment of regional label font size.
  figsize=[5, 4] # 图片大小：宽5高4。 icture size: width 5, height 4.
  xrotation=0 # x轴标签名旋转角度（0为不旋转）。 Rotation angle of x-axis label name (0 means no rotation).
  yrotation=0 # y轴标签名旋转角度（0为不旋转）。 Rotation angle of y-axis label name (0 means no rotation).
  linewidths=0.1 # 线粗0.1. Line thickness: 0.1.


  xlabelpad = 3
  ylabelpad = 17


  xlabelsize = 8 # 横轴字大小，默认'auto'，自动和fsize一样大
  ylabelsize = 29 # 纵轴字大小，默认'auto'，自动和fsize一样大


  pattern_colors = ['#dae3f3', 'white', 'none', 'auto']  # 分别为NW,BW,NS,BS设置标签背景色，'auto'为自动，'none'为透明
  pattern_moves = [(+0.005, +0.01), (+0, -0.005), (0, 0), (0, 0)]  # 分别为NW,BW,NS,BS设定区域标签较原来的偏移量，(x方向，y方向)




  draw_max_area(expressions=expressions, assigns=assigns,
                the_var_x=the_var_x, start_end_x=start_end_x,
                the_var_y=the_var_y, start_end_y=start_end_y,
                x_name=x_name, y_name=y_name,
                fsize=14, texts=texts, text_fsize_add=text_fsize_add,
                save_dir=save_dir, figsize=figsize, colors=colors, patterns=patterns,
                xrotation=xrotation, yrotation=yrotation, linewidths=linewidths,
               xlabelsize=xlabelsize, ylabelsize=ylabelsize, pattern_colors=pattern_colors,
                pattern_moves=pattern_moves, xlabelpad=xlabelpad, ylabelpad=ylabelpad)
  ```

      区域 0: 中心坐标 = [0.7671627089581086, 0.0634762952000335]
      区域 1: 中心坐标 = [0.74544927 0.03695231]
      区域 2: 中心坐标 = [0.7224541825812423, 0.07136930428315474]


  ![png](https://picx.zhimg.com/v2-38fa3848d5dc77e4c27e6f8ce7b89e31_r.jpg)





  ```python


  c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha = symbols('c_n, c_r, delta, e_n, e_r, p_e, E, k, b, alpha')



  expressions = {
      r'$\pi_r^{NW}$': E*p_e+(k*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2)/(8*(k+alpha*delta*(1-alpha*delta))**2),
      r'$\pi_r^{BW}$': E*p_e + ( k*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+delta-delta**2)**2),
      r'$\pi_r^{NS}$': E*p_e + ((k+2*alpha*delta)*(alpha*delta*(c_n+e_n*p_e)-(c_r+e_r*p_e))**2 )/( 8*(k+alpha*delta*(2-alpha*delta))**2),
      r'$\pi_r^{BS}$': E*p_e + ( (k+2*delta)*(delta*(c_n+e_n*p_e)-(c_r+e_r*p_e+b))**2 )/( 8*(k+2*delta-delta**2)**2),
  }



  assigns = {c_n: 0.2, c_r: 0.1, delta: 0.8, e_n: 1, e_r: 0.6, p_e: 0.1, E: 2, k: 1.1}



  the_var_x = alpha
  start_end_x = [0.7, 0.8]  # [起始值, 终止值]。 [starting value, ending value].
  the_var_y = b
  start_end_y = [0, 0.08]  # [起始值, 终止值]。 [starting value, ending value].



  x_name = '$\\alpha$ \n (b) With blockchain'
  y_name = r'$b$'



  save_dir = r'max_area_detail.tiff'



  prefix=r'Region'  # 前缀。可以是"区域"也可以是"Region"，默认"Region"。
  numbers='roman' # 序号标记风格。有三种可选："roman", "letter" 和"number"，分别表示罗马数字、大写英文字母和阿拉伯数字。Numbering style. There are three options: "roman", "letter", and "number".
  colors = ['#dae3f3', '#fbe5d6', '#e2f0d9', '#ededed', 'yellow', '#adb9ca', 'white']
  patterns = [' ', '+', '\\', '-', '//', '|', 'o']


  text_fsize_add = -2 # 区域标签字号增量。 Increment of regional label font size.
  figsize=[7, 4] # 图片大小：宽5高4。 icture size: width 5, height 4.
  xrotation=0 # x轴标签名旋转角度（0为不旋转）。 Rotation angle of x-axis label name (0 means no rotation).
  yrotation=0 # y轴标签名旋转角度（0为不旋转）。 Rotation angle of y-axis label name (0 means no rotation).
  linewidths=0.1 # 线粗0.1. Line thickness: 0.1.


  xlabelpad = 3
  ylabelpad = 17



  xlabelsize = 8 # 横轴字大小，默认'auto'，自动和fsize一样大
  ylabelsize = 29 # 纵轴字大小，默认'auto'，自动和fsize一样大
  legendsize = 9 # 图例字大小，默认'auto'，自动和fsize一样大


  pattern_colors = ['#dae3f3', 'white', 'none', 'auto']  # 分别为NW,BW,NS,BS设置标签背景色，'auto'为自动，'none'为透明
  pattern_moves = [(+0.005, +0.01), (+0, +0.005), (0, 0), (0, 0)]  # 分别为NW,BW,NS,BS设定区域标签较原来的偏移量，(x方向，y方向)




  draw_detail_area(expressions=expressions, assigns=assigns,
                  the_var_x=the_var_x, start_end_x=start_end_x,
                  the_var_y=the_var_y, start_end_y=start_end_y,
                  x_name=x_name, y_name=y_name,
                  fsize=14, text_fsize_add=text_fsize_add,
                  save_dir=save_dir, figsize=figsize, colors=colors, patterns=patterns,
                  xrotation=xrotation, yrotation=yrotation, linewidths=linewidths,
                  prefix=prefix, numbers=numbers, xlabelsize=xlabelsize, ylabelsize=ylabelsize, legendsize=legendsize,
                pattern_colors=pattern_colors, pattern_moves=pattern_moves, xlabelpad=xlabelpad, ylabelpad=ylabelpad)
  ```

      区域 $\pi_r^{BW} > \pi_r^{BS} > \pi_r^{NS} > \pi_r^{NW}$: 中心坐标 = [0.71801738 0.03542176]
      区域 $\pi_r^{BW} > \pi_r^{BS} > \pi_r^{NW} > \pi_r^{NS}$: 中心坐标 = [0.7522649316484371, 0.050000071576472446]
      区域 $\pi_r^{NW} > \pi_r^{NS} > \pi_r^{BW} > \pi_r^{BS}$: 中心坐标 = [0.75467691 0.06691737]
      区域 $\pi_r^{NS} > \pi_r^{NW} > \pi_r^{BW} > \pi_r^{BS}$: 中心坐标 = [0.72038526 0.07323454]


  ![png](https://pica.zhimg.com/v2-03574f85a5fff05ce374098723d2809c_r.jpg)


pkgId: 0b2a77fdeeb402f0679dc622f08da5fb873b8a71df8719cab7bc3475ff0c163c
name: python-easyflex-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for easyflex
url: https://github.com/zypp-io/easyflex
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easyflex-0.3.0-1.src.rpm
location_href: Packages/python-easyflex-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><img alt="logo" src="https://www.zypp.io/static/assets/img/logos/zypp/black/500px.png" width="200"></p>
  <br>

  [![Downloads](https://pepy.tech/badge/easyflex)](https://pepy.tech/project/easyflex)
  ![PyPI](https://img.shields.io/pypi/v/easyflex)
  [![Open Source](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)](https://opensource.org/)


  > Dit project bevat python scripts voor het ontsluiten van data uit de easyflex API.


  - [Introductie](#introductie)
  - [Hoe moet je dit project gebruiken?](#hoe-moet-je-dit-project-gebruiken?)
      - [Simpel voorbeeld](#simpel-voorbeeld-zonder-velden-of-parameters)
      - [Voorbeeld met parameters en velden](#voorbeeld-met-parameters-en-velden)


  Easyflex heeft een API ontwikkeld voor het ontsluiten van data. Op basis van de [Easyflex web- en dataservices documentatie](https://confluence.easyflex.net/display/WEBDATAKLNT/Web-+en+dataservice) is dit python project ontstaan.
  Het doel van het project is om snel en efficient data te ontsluiten van 1 of meerdere Easyflex administraties.


  In twee stappen is het mogelijk om data te ontsluiten. De eerste stap is het initialiseren van de class `Easyflex`. In deze class registreren worden de API keys geregistreerd die gebruikt worden bij de uitvraag.
  De tweede stap is het uitvragen van de dataservices of webservices. Hier moet een module naam worden opgegeven. Vervolgens kunnen de parameters en velden worden opgegeven, conform de [documentatie van de modules](https://confluence.easyflex.net/display/WEBDATAKLNT/1.2+ds_wm_medewerkers).


  ```python
  from easyflex import Easyflex
  api_keys = {"<YOUR_ADM_CODE>": "<YOUR_API_KEY>","<YOUR_ADM_CODE_2>": "<YOUR_API_KEY_2>"}

  ef = Easyflex(api_keys, service="dataservice")
  data = ef.query(module="ds_wm_medewerkers")
  ```


  ```python
  from easyflex import Easyflex
  api_keys = {"<YOUR_ADM_CODE>": "<YOUR_API_KEY>","<YOUR_ADM_CODE_2>": "<YOUR_API_KEY_2>"}

  ef = Easyflex(api_keys, service="dataservice")
  data = ef.query(module="ds_wm_locaties",
                  parameters={"status": 21690},
                  velden=["wm_locatie_nummer", "wm_locatie_code", "wm_locatie_naam"])
  ```



  - [Zypp](https://github.com/zypp-io)


pkgId: 5609275de527551a1c6d678d420a963b03a1f729c7a3b0f138115bfa6ac9c771
name: python-easypay-api-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for easypay-api
url: http://easypay-api.hive.pt
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easypay-api-0.3.0-1.src.rpm
location_href: Packages/python-easypay-api-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  API client for the Easypay service, conformant with the typical Python API client provided by Hive Solutions.



  - [Easypay API Docs](https://docs.easypay.pt/)
  - [Easypay Admin](https://id.easypay.pt/)
  - [Easypay Admin Test](https://id.test.easypay.pt/)



  [![Build Status](https://github.com/hivesolutions/easypay-api/workflows/Main%20Workflow/badge.svg)](https://github.com/hivesolutions/easypay-api/actions)
  [![Coverage Status](https://coveralls.io/repos/hivesolutions/easypay-api/badge.svg?branch=master)](https://coveralls.io/r/hivesolutions/easypay-api?branch=master)
  [![PyPi Status](https://img.shields.io/pypi/v/easypay-api.svg)](https://pypi.python.org/pypi/easypay-api)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://www.apache.org/licenses/)


pkgId: 5fe02116762405b8e71ac220be418896ca954c849614db98eb716ca0ed1e74fe
name: python-easyxtb-help
arch: noarch
version: 0.8.1
epoch: 0
release: 1
summary: Development documents and examples for easyxtb
url: https://github.com/matterhorn103/avo_xtb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-easyxtb-0.8.1-1.src.rpm
location_href: Packages/python-easyxtb-help-0.8.1-1.noarch.rpm
checksum_type: sha256
description:
  `easyxtb` is an unofficial API for the xtb and CREST semi-empirical quantum chemistry programs with an emphasis on intuitive and straightforward usage.

  It forms the basis for `avo_xtb`, a plugin for the 3D chemical visualization software [Avogadro 2](https://two.avogadro.cc) that provides an in-app interface to the xtb program for quick and accurate calculations, as well as the CREST program for extended functionality.

  The Python package `easyxtb` can be used independently of `avo_xtb` as an interface to launch calculations and process their results from Python.

  [`xtb`](https://github.com/grimme-lab/xtb) is developed by the Grimme group in Bonn and carries out semi-empirical quantum mechanical calculations using the group's e**x**tended **T**ight-**B**inding methods, referred to as "GFNn-xTB".

  These methods provide fast and reasonably accurate calculation of **G**eometries, **F**requencies, and **N**on-covalent interactions for molecular systems with up to roughly 1000 atoms, with broad coverage of the periodic table up to *Z* = 86 (radon).

  [`crest`](https://github.com/crest-lab/crest) (Conformer–Rotamer Ensemble Sampling Tool) adds a variety of sampling procedures for several interesting applications including conformer searches, thermochemistry, and solvation.



  Full documentation is a work in progress, but to demonstrate basic usage:

  To load a geometry (XYZ and CJSON files are supported currently):

  ```python
  >>> from pathlib import Path
  >>> import py_xtb
  >>> py_xtb.XTB_BIN = Path.home() / ".local/bin/xtb"
  >>> input_geom = py_xtb.Geometry.from_file(Path.home() / "calcs/benzoic_acid.xyz")
  >>> input_geom
  <py_xtb.geometry.Geometry object at 0x7ff91fdb15d0>
  >>> input_geom.atoms
  [Atom(element='C', x=-3.61652, y=0.64945, z=-0.0), Atom(element='C', x=-3.59105, y=-1.15881, z=-0.0), Atom(element='C', x=-0.43296, y=-1.32436, z=-1e-05), ..., Atom(element='O', x=1.54084, y=3.42551, z=-1e-05), Atom(element='O', x=2.9034, y=0.39476, z=1e-05), Atom(element='H', x=2.60455, y=-0.50701, z=2e-05)]
  >>> for atom in input_geom:
  ...     print(atom)
  ...
  Atom(element='C', x=-3.61652, y=0.64945, z=-0.0)
  Atom(element='C', x=-3.59105, y=-1.15881, z=-0.0)
  ... # Truncated for brevity
  Atom(element='O', x=2.9034, y=0.39476, z=1e-05)
  Atom(element='H', x=2.60455, y=-0.50701, z=2e-05)
  ```

  Charge and spin are picked up automatically from a CJSON file, but for XYZ files or for overriding they can be specified:

  ```python
  >>> acetate_anion = py_xtb.Geometry.from_file(Path.home() / "calcs/acetate.xyz", charge=-1)
  ```

  Note that `easyxtb` follows the convention used by `xtb` itself, where `spin` is the number of unpaired electrons.

  The package provides a function API for basic xtb calculation types (`energy`, `optimize`, `frequencies`, `opt_freq`, `orbitals`):

  ```python
  >>> optimized = py_xtb.calculate.optimize(input_geom, solvation="water", method=2, level="normal")
  >>> for atom in optimized:
  ...     print(atom)
  ...
  Atom(element='C', x=-2.94841377173243, y=0.53595421697827, z=-0.00205114575446)
  Atom(element='C', x=-2.96353116164446, y=-0.85021326429608, z=-0.00028605784754)
  ... # Truncated for brevity
  Atom(element='O', x=1.83119245847571, y=0.4663499792285, z=-0.00384872174663)
  Atom(element='H', x=1.55896002888703, y=-0.46876579604809, z=-0.00948378184114)
  ```

  For greater control and for runtypes or command line options that don't yet have support in the API the `Calculation` object can be used:

  ```python
  >>> freq_calc = py_xtb.Calculation(program="xtb", runtype="hess", options={"solvation": "water"})
  >>> freq_calc.input_geometry = input_geom
  >>> freq_calc.run()
  >>> freq_calc.energy
  -24.418716794336
  >>> freq_calc.output_geometry
  <py_xtb.geometry.Geometry object at 0x7ff91fdb15d0>
  >>> freq_calc.frequencies
  [{'mode': 1, 'symmetry': 'a', 'frequency': -816.7902, 'reduced_mass': 12.1428, 'ir_intensity': 7.2604, 'raman_scattering_activity': 0.0, 'eigenvectors': [[-0.26, -0.46, 0.0], [-0.24, 0.43, -0.0], [-0.05, -0.05, 0.0], [0.08, 0.3, -0.0], [0.42, 0.02, -0.0], [-0.02, 0.03, -0.0], [0.24, -0.09, -0.0], [0.0, -0.02, 0.0], [-0.26, 0.1, 0.0], [0.05, 0.01, -0.0], [-0.02, -0.03, 0.0], [0.0, -0.21, 0.0], [0.05, 0.0, -0.0], [-0.02, 0.01, -0.0]]}, {'mode': 2, 'symmetry': 'a', 'frequency': -759.3794, 'reduced_mass': 12.9124, 'ir_intensity': 17.3638, 'raman_scattering_activity': 0.0, 'eigenvectors': [[0.12, 0.19, -0.0], [0.15, -0.32, 0.0], [0.07, 0.18, -0.0], [0.12, 0.58, -0.0], [0.01, -0.11, 0.0], [0.01, -0.03, 0.0], [-0.29, 0.05, 0.0], [-0.02, 0.01, 0.0], [-0.32, -0.02, -0.0], [0.02, -0.03, -0.0], [0.01, 0.01, -0.0], [-0.01, -0.47, 0.0], [0.13, -0.0, -0.0], [-0.03, 0.02, 0.0]]}, ..., {'mode': 36, 'symmetry': 'a', 'frequency': 3752.5636, 'reduced_mass': 1.893, 'ir_intensity': 79.5584, 'raman_scattering_activity': 0.0, 'eigenvectors': [[-0.0, -0.0, 0.0], [0.0, -0.0, 0.0], [0.0, 0.0, -0.0], [-0.0, 0.0, 0.0], [-0.0, 0.0, -0.0], [-0.0, 0.0, -0.0], [0.0, 0.0, 0.0], [-0.0, 0.0, 0.0], [0.0, 0.0, -0.0], [0.0, 0.0, -0.0], [-0.0, 0.0, -0.0], [-0.0, -0.0, 0.0], [0.08, 0.23, -0.0], [-0.31, -0.92, 0.0]]}]
  ```

  We were returned some negative frequencies!
  The xtb team recommend generally using the `ohess` (optimization followed by a frequency calculation) as, in the case of negative frequencies, xtb will produce a distorted geometry along the imaginary mode.
  The `opt_freq()` calculation function takes advantage of this and will continue reoptimizing using these distorted geometries until a minimum is reached, so is more reliable in getting what we want:

  ```python
  >>> output_geom, output_freqs, calc = py_xtb.calculate.opt_freq(input_geom, solvation="water", return_calc=True)
  >>> output_freqs[0]
  {'mode': 1, 'symmetry': 'a', 'frequency': 70.0622, 'reduced_mass': 13.4154, 'ir_intensity': 6.422, 'raman_scattering_activity': 0.0, 'eigenvectors': [[0.0, 0.0, -0.28], [-0.0, 0.0, -0.0], [-0.0, -0.0, 0.25], [0.0, -0.0, 0.04], [0.0, -0.0, -0.24], [-0.0, 0.0, -0.0], [-0.0, 0.0, 0.29], [-0.0, 0.0, 0.15], [0.0, -0.0, 0.02], [0.0, -0.0, -0.12], [0.0, 0.0, -0.15], [0.0, -0.0, 0.55], [0.0, 0.01, -0.56], [0.0, 0.0, -0.19]]}
  ```

  The geometries can be converted back to XYZ or CJSON formats, or saved to file:

  ```python
  >>> output_geom.to_xyz()
  ['14', ' energy: -25.558538770724 gnorm: 0.000926226194 xtb: 6.7.1 (edcfbbe)', 'C        -2.94841     0.53597    -0.00204', 'C        -2.96354    -0.85020    -0.00027', 'C        -0.61077    -0.84138     0.00148', 'C         0.75088     1.26262     0.00405', 'C        -1.75577     1.23036    -0.00190', 'H        -3.89917    -1.39047     0.00050', 'C        -1.76452    -1.56433     0.00117', 'H        -1.76882    -2.64357     0.00283', 'C        -0.54492     0.52708     0.00053', 'H        -1.70901     2.30959    -0.00318', 'H        -3.88278     1.07775    -0.00326', 'O         0.84510     2.45868     0.01349', 'O         1.83119     0.46634    -0.00386', 'H         1.55896    -0.46877    -0.00949']
  >>> output_geom.to_cjson()
  {'atoms': {'coords': {'3d': [-2.94841097258746, 0.53596965124863, -0.00204178926542, -2.96353561428538, -0.85019774776951, -0.0002742292702, -0.61076575425764, -0.84137850926872, 0.00147639902781, 0.75088171422694, 1.2626220330939, 0.00405051293617, -1.75577241044775, 1.23035899741552, -0.00189846159875, -3.89916811270068, -1.39047034080804, 0.00049537269594, -1.76451828574256, -1.56433051119015, 0.00116984833688, -1.76882023929805, -2.64357304665774, 0.00283010066276, -0.54491722564374, 0.52708246765258, 0.00052577760818, -1.70901066150243, 2.30958748867245, -0.00317692528336, -3.88277644809706, 1.07774511697242, -0.00326302099431, 0.84510262816245, 2.45867627843098, 0.01348592446867, 1.83119488680479, 0.46634038440289, -0.00385592774839, 1.55895754130232, -0.46877397528872, -0.00948840548749]}, 'elements': {'number': [6, 6, 6, 6, 6, 1, 6, 1, 6, 1, 1, 8, 8, 1]}}}
  >>> output_geom.to_file(Path.home() / "calcs/optimized_benzoic_acid.xyz")
  ```





  Only tested for `xtb >= 6.7`.

  The `xtb` binary is not bundled with the package.
  Instead, it must be obtained separately.

  The location of `xtb` can be set from Python code simply by setting `easyxtb.XTB_BIN` to an appropriate `pathlib.Path` object.

  An `xtb` binary will also be picked up automatically by `easyxtb` if located in one of the following locations:
  1. The system or user PATH
  2. Within the `easyxtb` binary directory at `<user data>/easyxtb/bin/xtb` (see below for more information on where this is on your system)
  3. Within the folder it is distributed in under the `easyxtb` binary directory, which would thus currently be at `<user data>/easyxtb/bin/xtb-dist/bin/xtb`
  4. Any other location but with a link to it from `<user data>/easyxtb/bin/xtb`



  Only tested for `crest >= 3.0`.

  While `xtb` is cross-platform, `crest` is currently distributed only for Linux/UNIX systems.

  `crest` can be made visible to the plugin in the same ways as for `xtb` listed above.
  If it is not in `$PATH`, the `crest` binary, or link to it, should be located at `<user data>/easyxtb/bin/crest`.



  `easyxtb` uses a central location to run its calculations, store its configuration, and save its log file.
  This location is `<user data>/easyxtb`, where `<user data>` is OS-dependent:

  - Windows: `$USER_HOME\AppData\Local\easyxtb`
  - macOS: `~/Library/Application Support/easyxtb`
  - Linux: `~/.local/share/easyxtb`

  Additionally, if the environment variable `XDG_DATA_HOME` is set its value will be respected and takes precedence over the above paths (on all OSes).



  `xtb` and `crest` are distributed by the Grimme group under the LGPL license v3. The authors of `easyxtb`, `avo_xtb`, and Avogadro bear no responsibility for xtb or CREST or the contents of the respective repositories. Source code for the programs is available at the repositories linked above.



  General reference to `xtb` and the implemented GFN methods:
  * C. Bannwarth, E. Caldeweyher, S. Ehlert, A. Hansen, P. Pracht, J. Seibert, S. Spicher, S. Grimme
    *WIREs Comput. Mol. Sci.*, **2020**, 11, e01493.
    DOI: [10.1002/wcms.1493](https://doi.org/10.1002/wcms.1493)

  For GFN2-xTB (default method):
  * C. Bannwarth, S. Ehlert and S. Grimme., *J. Chem. Theory Comput.*, **2019**, 15, 1652-1671. DOI: [10.1021/acs.jctc.8b01176](https://dx.doi.org/10.1021/acs.jctc.8b01176)

  For CREST:
  * P. Pracht, S. Grimme, C. Bannwarth, F. Bohle, S. Ehlert, G. Feldmann, J. Gorges, M. Müller, T. Neudecker, C. Plett, S. Spicher, P. Steinbach, P. Wesołowski, F. Zeller, *J. Chem. Phys.*, **2024**, *160*, 114110. DOI: [10.1063/5.0197592](https://doi.org/10.1063/5.0197592)
  * P. Pracht, F. Bohle, S. Grimme, *Phys. Chem. Chem. Phys.*, **2020**, 22, 7169-7192. DOI: [10.1039/C9CP06869D](https://dx.doi.org/10.1039/C9CP06869D)

  See the xtb and CREST GitHub repositories for other citations.


pkgId: abc5872124f5a537f9fc54fd0da056178831a82b14a1bcd200ad68c3ded9eff5
name: python-eazy-help
arch: noarch
version: 0.8.2
epoch: 0
release: 1
summary: Development documents and examples for eazy
url: https://github.com/gbrammer/eazy-py
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eazy-0.8.2-1.src.rpm
location_href: Packages/python-eazy-help-0.8.2-1.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/gbrammer/eazy-py/actions/workflows/python-package.yml/badge.svg
     :target: https://github.com/gbrammer/eazy-py/actions

  .. image:: https://badge.fury.io/py/eazy.svg
      :target: https://badge.fury.io/py/eazy

  .. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.5012705.svg
     :target: https://doi.org/10.5281/zenodo.5012705


  eazy-py: Pythonic photometric redshift tools based on EAZY
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Under heavy construction....

  Documentation will be here: https://eazy-py.readthedocs.io/, though it's essentially just the module API for now.

  Templates and filter files still here: https://github.com/gbrammer/eazy-photoz/.

  .. note::
      Please submit any questions/comments/problems you have through the `Issues <https://github.com/gbrammer/eazy-py/issues>`_ interface.

  Installation instructions
  ~~~~~~~~~~~~~~~~~~~~~~~~~

  .. code:: bash

      $ pip install eazy
      $ pip install eazy[vistool] # for the dash visualiation tool

      
      $ pip install git+https://github.com/karllark/dust_attenuation.git

      
      $ python -c "import eazy; eazy.fetch_eazy_photoz()"

  Demo
  ~~~~

  .. image:: https://colab.research.google.com/assets/colab-badge.svg
   :target: https://colab.research.google.com/github/gbrammer/eazy-py/blob/master/docs/examples/HDFN-demo.ipynb

  .. image:: https://mybinder.org/badge_logo.svg
   :target: https://mybinder.org/v2/gh/gbrammer/eazy-py/HEAD?filepath=docs%2Fexamples%2FHDFN-demo.ipynb


  Citation
  ~~~~~~~~
  Please cite both this repository and `Brammer et al. (2008) <https://ui.adsabs.harvard.edu/abs/2008ApJ...686.1503B/abstract>`_. A BiBTeX for this repository can be generated via the *Cite this repository* link in the upper left corner of the `GitHub page <https://github.com/gbrammer/eazy-py>`_.

rpm_license:
  MIT License  Copyright (c) 2016-2022 Gabriel Brammer  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: 7cc6088526f1e368af55fe63597656821bd31fddbfb74d7ea518990193c4b46a
name: python-ebcc-help
arch: noarch
version: 1.6.1
epoch: 0
release: 1
summary: Development documents and examples for ebcc
url: https://pypi.org/project/ebcc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ebcc-1.6.1-1.src.rpm
location_href: Packages/python-ebcc-help-1.6.1-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/BoothGroup/ebcc/workflows/CI/badge.svg)](https://github.com/BoothGroup/ebcc/actions?query=workflow%3ACI+branch%3Amaster)
  [![codecov](https://codecov.io/gh/BoothGroup/ebcc/branch/master/graph/badge.svg?token=QZQZQ2ZQ2Z)](https://codecov.io/gh/BoothGroup/ebcc)
  [![PyPI version](https://badge.fury.io/py/ebcc.svg)](https://badge.fury.io/py/ebcc)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  The `ebcc` package implements various coupled cluster (CC) models for both purely electronic and coupled electron-boson models, with a focus on generality and model extensibility.

  For a summary of the implemented models, see the [FEATURES.md](FEATURES.md) file.



  From PyPI:

  ```bash
  pip install ebcc
  ```

  From source:

  ```bash
  git clone https://github.com/BoothGroup/ebcc
  pip install .
  ```



  The implemented models are built upon the mean-field objects of [`pyscf`](https://github.com/pyscf/pyscf):

  ```python
  from pyscf import gto, scf
  from ebcc import EBCC
  mol = gto.M(atom="H 0 0 0; H 0 0 1", basis="cc-pvdz")
  mf = scf.RHF(mol)
  mf.kernel()
  ccsd = EBCC(mf, ansatz="CCSD")
  ccsd.kernel()
  ```

  Many ansatzes for both fermionic and electron-boson coupled cluster calculations are available. For more details see the `tutorials` and `examples` directories.



  The models implemented are generated algorithmically from expressions over second quantized operators. The scripts for generating these models are found in the `codegen` directory on the `bootstrap` branch.
  User-inputted models should operate seamlessly with the solvers by adding files under `ebcc/codegen`, so long as they satisfy the interface.


pkgId: 5b3670ca385de95a28cedb1f9e05865f0223090ac54466b9e824ff249059acea
name: python-ebook2text-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for ebook2text
url: https://pypi.org/project/ebook2text/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ebook2text-2.0.1-1.src.rpm
location_href: Packages/python-ebook2text-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This Python script provides functionality for converting various ebook file formats (EPUB, DOCX, PDF, TXT) into a standardized text format. The script processes each file, identifying chapters, and replaces chapter headers with asterisks. It also performs OCR (Optical Character Recognition) for image-based text using GPT-4o and standardizes the text by desmartening punctuation.



  - **File Format Support**: Handles EPUB, DOCX, PDF, and TXT formats.
  - **Chapter Identification**: Detects and marks chapter breaks.
  - **OCR Capability**: Converts text from images using OCR.
  - **Text Standardization**: Replaces smart punctuation with ASCII equivalents.



  To run this script, you need Python 3.9 or above and the following packages:

  - `python-docx`
  - `openai`
  - `python-dotenv`
  - `bs4`
  - `pdfminer.six`
  - `pillow`



  1. Ensure all dependencies are installed.
  2. Set your environment variable for the OpenAI API key.
  3. Place your ebook files in a known directory.
  4. Run the script with the path to the ebook file and a metadata dictionary with keys of 'title' and 'author' as arguments.

  - set `save_file` to False, if you want a string returned.
  - provide a Path object of a file name to be written to, to use a custom output filename.



  - `convert_file(file_path: Path, metadata: dict, *, save_file: bool = True, save_path: Optional[Path] = None) -> Union[str, None]`: Main function to convert an ebook file to text.



  Contributions to this project are welcome. Please use Ruff for formatting to ensure that your code follows the existing style for consistency.



  This project is licensed by ProsePal LLC under the MIT license



  - **v0.1.0** (Release date: November 30, 2023)
    - Initial release

  - **v0.1.1** (Release date: December 2, 2023)
    - fixed false positives for is_number

  - **v0.2.0** (Release date: December 3, 2023)
    - Conversion of docx files

  - **v0.3.0** (Release date: December 8, 2023)
    - Conversion of PDF files

  - **v0.3.1** (Release date: January 23, 2024)
    - fixed concatenation of text in pdf conversion
    - updated pillow version to secure version

  - **v1.0.0** (Release date: January 23, 2024)
    - created library instead of single module

  - **v1.0.1** (Release date: March 13, 2024)
    - setup.py and requirements.txt typo fixed

  - **v1.0.2** (Release date: May 17, 2024)
    - added tests, fixed minor typos

  - **v1.1.0** (Release date: May 30, 2024)
    - Change to abstract factory pattern

  - **v1.1.1** (Release date: May 31, 2024)
    - Pull current version of ebooklib from Github and folded it into library since package repo out of date

  - **v1.1.2** (Release date: May 31, 2024)
    - FIX: Put ebooklib in correct directory.

  - **v1.1.3** (Release date: October 27, 2024)
    - FIX: Initialize logging

  - **v1.1.4** (Release date: November 7, 2024)
    - YANKED

  - **v1.1.5** (Release date: November 7, 2024)
    - FIX: Move logging to own module

  - **v1.1.6** (Release date: November 9, 2024)
    - FIX: Catch PDFSyntaxError and empty image lists, small performance improvement to run_ocr

  - **v1.1.7** (Release date November 10, 2024)
    - FIX: Line concatenation issue in PDFs

  - **v2.0.0** (Release date December 4, 2024)
    - REFACTOR: Converters are now packages with more streamlined constructors.
    - BREAKING FEATURE: ebook2text now takes Path objects instead of string filenames.
    - BREAKING FEATURE: Converters no longer have a ChapterSplit class. This is handled by the BookConversion class, with no more circular imports.
    - NEW FEATURE: `convert_file` now has optional `save_file` and `save_path` arguments to allow for custom output filenames or for a string to be returned instead.

  - **v2.0.1** (Release date December 16, 2024)
    - FIX: Re-raise errors raised by PDFConverter._readfile()


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


pkgId: ba66a92962c3c9521eb89d0e261e7bbbb7ea59e410dee3d020b536ffd712d51d
name: python-ebrow-help
arch: noarch
version: 0.1.83
epoch: 0
release: 1
summary: Development documents and examples for ebrow
url: http://www.gabb.it/echoes/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ebrow-0.1.83-1.src.rpm
location_href: Packages/python-ebrow-help-0.1.83-1.noarch.rpm
checksum_type: sha256
description:
  ![Echoes Logo](https://sourceforge.net/p/echoes/git/ci/master/tree/trunk/ebrow/edb/resources/icons/ebrow_logo.png?format=raw)



  Echoes Data Browser (Ebrow) is a data navigation and report generation tool for Echoes v.0.51++.

  Echoes is a RF spectrograph software for SDR devices designed for meteor scatter and hosted on
  SourceForge (http://www.sourceforge.net/project/echoes), both copyright (C) 2018-2023 Giuseppe Massimo Bertani
  and released under GPL v.3

  Echoes documentation can be found at: http://www.gabb.it/echoes/

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


pkgId: 947aa29170919d9cc5620325a4a0a1211b6b73bd8540512b7861069a8dbd6f66
name: python-ebyst-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for ebyst
url: https://github.com/swolix/ebyst
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ebyst-0.1.0-1.src.rpm
location_href: Packages/python-ebyst-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Boundary scan test framework for board validation


  ```python

  drv = ebyst.drivers.FT2232H(ebyst.drivers.FT2232H.list_devices()[0])
  ctl = ebyst.TapController(drv)
  ctl.detect_chain()


  dev = ebyst.Device.from_bsdl("bsdl/BSDLLCMXO2-256HCQFN32.BSM")
  ctl.add_device(dev)
  ctl.validate_chain()


  ctl.extest()


  dev.pinmap['O'].output_enable(True)
  dev.pinmap['I'].output_enable(False)
  dev.pinmap['O'].set_value(1)
  await ctl.cycle() # drive output
  await ctl.cycle() # sample input
  print(dev.pinmap['I'].get_value())
  dev.pinmap['O'].set_value(0)
  await ctl.cycle() # drive output
  await ctl.cycle() # sample input
  print(dev.pinmap['I'].get_value())


  i2c = ebyst.interfaces.I2C(ctl, dev.pinmap['PB9A'], dev.pinmap['PB4B'])
  await i2c.init()
  dev_address = 0xa0
  reg_address = 0x10
  data = 0xa5
  print(f"Writing {dev_address:02x}:{reg_address:02x} <= {data:02x}")
  await i2c.write(0xa0, 0x10, 0xa5)
  print(f"Reading {dev_address:02x}:{reg_address:02x} => ", end='')
  await x = i2c.read(0xa0, 0x10)
  print(f"{x:02x}")

  ctl.reset()
  ```

  The library uses `asyncio` to allow running multiple tests in parallel.
  When the loopback test and I2C test above are put in different tasks, they share the same boundary scan cycles,
  meaning they run completely parallel
  (Note that this only works when they are not using different pins, if pins are shared between tests, make sure to
  schedule them appropriately)

  Example;
  ```python
  async def main():
      drv = ebyst.drivers.FT2232H(ebyst.drivers.FT2232H.list_devices()[0])
      dev = ebyst.Device.from_bsdl("bsdl/BSDLLCMXO2-256HCQFN32.BSM")
      ctl = ebyst.TapController(drv)
      ctl.detect_chain()
      ctl.add_device(dev)
      ctl.validate_chain()
      ctl.extest()
      async with asyncio.TaskGroup() as tg:
          tg.create_task(loopback_test(ctl, dev.pinmap['PB2C'], dev.pinmap['PB2A']))
          tg.create_task(loopback_test(ctl, dev.pinmap['PB4C'], dev.pinmap['PB4D']))

  if __name__ == "__main__":
      logging.basicConfig()
      logging.getLogger().setLevel(logging.INFO)
      asyncio.run(main())
  ```

  see also `tests/test_async.py`


pkgId: ba0e92eb8308184aaee072e26f66f5a6e53c1f91d9c915e59d80e7b363d3ca82
name: python-ecallisto-ng-help
arch: noarch
version: 1.1.4
epoch: 0
release: 1
summary: Development documents and examples for ecallisto-ng
url: https://github.com/i4Ds/ecallisto_ng
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ecallisto-ng-1.1.4-1.src.rpm
location_href: Packages/python-ecallisto-ng-help-1.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Ecallisto NG is a comprehensive Python package tailored for interacting with Ecallisto data. It focuses on facilitating efficient data manipulation, processing, and visualization, leveraging the power of Pandas for data handling and PyTorch for advanced computations. The package is particularly optimized for dealing with large datasets, providing tools for slicing, filtering, and resampling data to make spectrogram plotting more manageable.


  - [Background](#background)
  - [Installation](#installation)
    - [PyPI](#pypi)
    - [Dev Installation](#dev-installation)
    - [Virtual Antenna Creation](#creation-of-the-virtual-antenna)
  - [Using Pandas with Ecallisto NG](#pandas)
  - [Examples and Usage](#examples-and-usage)
    - [Data Fetching](#data-fetching-deprecated)
    - [Data Processing and Visualization](#data-processing-and-visualization)
    - [Plotting](#plotting)
    - [spectrogram Editing](#spectrogram-editing)
  - [Additional Information](#additional-information)
    - [Note on .attrs and FITS Header](#note-on-attrs-and-fits-header)
    - [Contributing](#contributing)


  The package is built with Python 3.9<3.12 and primarily uses the Pandas library for data manipulation. It's core functionality is centered around efficient data processing and visualization. The data provided by e-Callisto is stored in a pandas Dataframe, where the index is the time and the column names are the observed frequencies.


  Available on PyPI: https://pypi.org/project/ecallisto-ng/


  To install this package, use pip for installation. Execute the following command in your terminal with basic functionality, such as plotting and data fetching:
  ```pip install ecallisto-ng```
  If you want to use the virtual antenna:
  ```pip install ecallisto-ng[va]```
  If you want to use the detection of flares, powered by ML:
  ```pip install ecallisto-ng[ml]```

  To use the notebook, please install the notebook dependencies.


  Of course, you can also install the package from source. To do so, clone the repository and install the package in editable mode:
  ```pip install -e .```
  ```pip install -e .[va]```
  ```pip install -e .[ml]```


  Pandas is an open-source data analysis and manipulation tool, pivotal to Ecallisto NG. Learning Pandas is essential for effectively using Ecallisto NG, as it allows for sophisticated data slicing, filtering, and aggregation. More on Pandas: https://pandas.pydata.org/docs/


  Please have a look at the jupyter notebook under `example`.




  This function fetches e-Callisto data within a specified date range and optional instrument regex pattern. It's suitable for smaller datasets. For larger datasets, consider using the `get_ecallisto_data_generator` function.


  - `start_datetime` (datetime-like): The start date for the file search.
  - `end_datetime` (datetime-like): The end date for the file search.
  - `instrument_string` (str, List[str] or None): Instrument name(s) for file URL matching. If `None`, all files are considered.
  - `freq_start` (float or None): The start frequency for filtering.
  - `freq_end` (float or None): The end frequency for filtering.
  - `base_url` (str): Base URL of the remote file directory.


  - (dict of str: pandas.DataFrame) or pandas.DataFrame: A dictionary of instrument names and their corresponding dataframes. If only one instrument is found, it returns a single dataframe.


  ```python
  from ecallisto_ng.data_download.downloader import (
      get_ecallisto_data,
  )
  from datetime import datetime

  start = datetime(2021, 5, 7, 0, 00, 0)
  end = datetime(2021, 5, 7, 23, 59, 0)
  instrument_name = "Australia-ASSA_01"

  dfs = get_ecallisto_data(start, end, instrument_name)
  df = dfs[instrument_name] # Returns a dict of pd.Dataframes because instrument_name can also be a substring, e.g. "ASSA".
  ```



  A generator function that yields e-Callisto data one file at a time within a date range. It's ideal for handling large datasets or when working with limited memory.


  - `start_datetime` (datetime-like): The start date for the file search.
  - `end_datetime` (datetime-like): The end date for the file search.
  - `instrument_name` (List[str], str, or None): Instrument name(s) for file URL matching. If `None`, all files are considered.
  - `freq_start` (float or None): The start frequency for filtering.
  - `freq_end` (float or None): The end frequency for filtering.
  - `base_url` (str): Base URL of the remote file directory.


  - (str, pandas.DataFrame): A tuple containing the instrument name and its corresponding DataFrame.


  ```python
  from ecallisto_ng.data_download.downloader import (
      get_ecallisto_data_generator,
  )
  from datetime import datetime

  start = datetime(2021, 5, 7, 0, 00, 0)
  end = datetime(2021, 5, 7, 23, 59, 0)
  instrument_name = ["Australia-ASSA_01", "Australia-ASSA_02"]

  data_generator = get_ecallisto_data_generator(start, end, instrument_name)
  for instrument_name, data_frame in data_generator:
      print(instrument_name)
      print(f"{df.shape=}")
  ```

  Ecallisto NG provides basic plotting capabilities. Here's an example of how to generate a spectrogram (make sure that df is defined):
  ```python
  from ecallisto_ng.plotting.plotting import plot_spectrogram

  plot_spectrogram(df)
  ```
  Make use of .resample to reduce the size of the data. Alternatively, you can pass a `resolution` parameter to the plot_spectrogram. Here's an example:
  ```python
  plot_spectrogram(df.resample("1min").max())
  plot_spectrogram(df, resolution=720) # Pixels
  ```
  For more documentation on resample, please refer to the [Pandas documentation](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.resample.html).

  We also provide some basic functionalities to edit the spectrogram. Here's how you can do it (make sure that df is defined):
  ```python
  from ecallisto_ng.data_processing.utils import elimwrongchannels, subtract_constant_background, subtract_low_signal_noise_background
  from datetime import datetime
  from ecallisto_ng.plotting.plotting import plot_spectrogram


  df = df.loc[:, 20:80]


  start = datetime(2021, 5, 7, 3, 39, 0)
  end = datetime(2021, 5, 7, 3, 42, 0)
  df = df.loc[start:end]


  df = elimwrongchannels(df)
  df = subtract_low_signal_noise_background(df)
  df = subtract_constant_background(df)

  plot_spectrogram(df)
  ```


  The function utilizes DataFrames with the .attrs attribute to store FITS header information. This attribute is a dictionary-like object and contains metadata about the FITS file, including header details. Accessing .attrs is essential for understanding the context of the data:

  ```python
  print(df.attrs)
  ```

  These simple commands allow you to easily manipulate spectrogram data, enabling effective use of the Ecallisto API for your needs.


  Contributions to Ecallisto NG are very welcome! If you have an idea for an improvement or have found a bug, please feel free to contribute. The preferred way to contribute is by submitting a Pull Request (PR) or creating an issue on our GitHub repository. This way, we can discuss potential changes or fixes and maintain the quality of the project.


pkgId: f8446a0ba2994b5a0d5155c77f584d13fb85b0458b1a27f446163897c2f01a5b
name: python-echemdbconverters-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for echemdbconverters
url: https://pypi.org/project/echemdbconverters/
rpm_license: GPL 3.0+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-echemdbconverters-0.2.1-1.src.rpm
location_href: Packages/python-echemdbconverters-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Convert raw data into echemdb data packages



  This package is available on [PiPY](https://pypi.org/project/echemdbconverters/) and can be installed with pip:

  ```sh .noeval
  pip install echemdbconverters
  ```


pkgId: d390510cf4cefa25c2447af8c4bafcb512ff7807951abfbd680381a67569e186
name: python-echidna-sc-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for echidna-sc
url: https://github.com/azizilab/echidna
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-echidna-sc-1.0.0-1.src.rpm
location_href: Packages/python-echidna-sc-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src=./echidna_logo.png width="100" />

   A Bayesian framework for quantifying gene dosage effect impacting phenotypic plasticity through integrating single-cell RNA sequencing (scRNA-seq) and bulk whole-genome sequencing (WGS) from a single or multiple time points.


  <img src=./echidna_concept.png width="800" />




  There are four example notebooks:

  1. 1-single-timepoint.ipynb
  2. 2-multi-timepoint.ipynb
  3. 3-infer-gene-dosage.ipynb
  4. 4-echidna-model.ipynb

  The notebooks are meant to be run sequentially, and they build off of each other.

  Notebook 1 introduces you to the package - preparing your data, setting hyperparamters, performing posterior predictive checks - with data collected from a single point in time.

  In notebook 2, we look at a multi-timepoint setting, where we have paired single-cell and WGS data collected over time.

  The saved model runs from notebook 2 will be used in notebook 3, where you will see how to infer amplifications and deletions by cluster of genes across a given genome. This notebook also shows you how to calculate and plot gene dosage effect with Echidna.

  Notebook 4 is meant to show you how to do more custom work with the model. We package together many functions for your convenience, but this notebook will show you how to work directly with the model for the experiments not covered in the package. Some [Pyro](https://pyro.ai/) knowledge is assumed.





  | Setting        | Type   | Default         | Description                               |
  |----------------|--------|-----------------|-------------------------------------------|
  | `timepoint_label` | `str`  | `"timepoint"`    | Label for timepoints in the data.         |
  | `counts_layer`    | `str`  | `"counts"`       | Name of the counts layer in the data.     |
  | `clusters`        | `str`  | `"leiden"`       | Clustering method used in the data. This can also be celltype annotations, if you have them.       |



  | Setting         | Type   | Default         | Description                                               |
  |-----------------|--------|-----------------|-----------------------------------------------------------|
  | `seed`          | `int`  | `42`            | Random seed for reproducibility.                          |
  | `n_steps`       | `int`  | `10000`         | Maximum number of steps for Stochastic Variational Inference (SVI). |
  | `learning_rate` | `float`| `0.1`           | Learning rate for the Adam optimizer.                     |
  | `val_split`     | `float`| `0.1`           | Percentage of training data to use for validation.         |
  | `patience`      | `int`  | `30`            | Early stopping patience (set to >0 to enable early stopping). |
  | `device`        | `str`  | `"cuda" if is_available() else "cpu"` | Device to use for training (GPU if available, otherwise CPU). |
  | `verbose`       | `bool` | `True`          | Whether to enable logging output.                         |



  | Setting              | Type    | Default   | Description                                                                        |
  |----------------------|---------|-----------|------------------------------------------------------------------------------------|
  | `inverse_gamma`       | `bool`  | `False`   | Whether to use inverse gamma for noisier data.                                     |
  | `lkj_concentration`   | `float` | `1.0`     | Concentration parameter of LKJ prior. Values > 1.0 result in more diagonal covariance matrices. |
  | `q_shape_rate_scaler` | `float` | `10.0`    | Scaler for the shape and rate parameters of the covariance diagonal for variational inference. |
  | `q_corr_init`         | `float` | `0.01`    | Initial scale of the variational correlation.                                      |
  | `q_cov_scaler`        | `float` | `0.01`    | Scaler for the covariance of the variational correlation.                          |
  | `eta_mean_init`       | `float` | `2.0`     | Initial mean value for the eta parameter.                                          |
  | `eps`                 | `float` | `5e-3`    | Small constant added to the diagonal to ensure positive definiteness (PD).         |


pkgId: a795383d043415b0975ae589a2f071bed6539724883ba80058a62371e1c94b34
name: python-echosms-help
arch: noarch
version: 0.6.3
epoch: 0
release: 1
summary: Development documents and examples for echosms
url: https://github.com/ices-tools-dev/echoSMs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-echosms-0.6.3-1.src.rpm
location_href: Packages/python-echosms-help-0.6.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Static badge](https://img.shields.io/pypi/v/echosms.svg)](https://pypi.org/project/echosms/)
  [![Static badge](https://img.shields.io/github/license/ices-tools-dev/echosms)](https://raw.githubusercontent.com/ices-tools-dev/echoSMs/refs/heads/main/LICENSE)
  [![python](https://img.shields.io/pypi/pyversions/echosms.svg?logo=python&logoColor=white)](https://pypi.org/project/echosms/)

  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ices-tools-dev/echoSMs/publish-to-pypi.yml)](https://github.com/ices-tools-dev/echoSMs/actions/workflows/publish-to-pypi.yml)
  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ices-tools-dev/echoSMs/build-docs.yml?label=docs)](https://github.com/ices-tools-dev/echoSMs/actions/workflows/build-docs.yml)

  > Making acoustic scattering models available to fisheries and plankton scientists via the world wide web

  EchoSMs provides acoustic scattering models for fisheries and plankton acoustic research. By providing the models in an open-access and open-source software language (e.g, Python, R) and providing morphological and anatomical data in open data formats (e.g., HDF5, relational databases), the proper and appropriate use of these models can extend to the entire fisheries and plankton acoustics’ community.



  EchoSMs is available on the python Package Index as [echosms](https://pypi.org/project/echosms/) and will be available on conda-forge in the future.



  EchoSMs documentation is available [here](https://ices-tools-dev.github.io/echoSMs/).



  We welcome all contributions to echoSMs, be it code, test cases, bug reports, discussion of models, etc. Guidance on this is available in the echoSMs [documentation](https://ices-tools-dev.github.io/echoSMs/#contributing-to-echosms).

rpm_license:
  MIT License  Copyright (c) 2024 ICES tools (development area)  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: 79360fb16e05682d8a3b874652bf09cd95e845dd7be005c5000524a7687d673a
name: python-ecidacli-help
arch: noarch
version: 0.1.12
epoch: 0
release: 1
summary: Development documents and examples for ecidacli
url: https://gitlab.com/ecida
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ecidacli-0.1.12-1.src.rpm
location_href: Packages/python-ecidacli-help-0.1.12-1.noarch.rpm
checksum_type: sha256
description:
  ```
  usage: ecidacli [-h] [-f MAIN_FILE] COMMAND ...

  options:
    -h, --help            show this help message and exit
    -f MAIN_FILE, --main-file MAIN_FILE
                          main file to process (example: main.py)

    COMMAND
      manifests           generate the kubernetes manifests
      build               build the container and push it to container registry
      version             print ecidacli version
      create              create resources e.g. module and environment
      init                Initialize the codebase
  ```

  ```
  usage: ecidacli manifests [-h] [-u USERNAME] [-s SECRET] [-d DIR]

  options:
    -h, --help            show this help message and exit
    -u USERNAME, --username USERNAME
                          username for container registry authentication
    -s SECRET, --secret SECRET
                          name of secret in the kubernetes-cluster
    -d DIR, --dir DIR     directory to put yaml files [default: manifests]
  ```

  ```
  usage: ecidacli build [-h] [-u USERNAME]

  options:
    -h, --help            show this help message and exit
    -u USERNAME, --username USERNAME
                          username for container registry authentication
  ```

  ```
  usage: ecidacli create [-h] RESOURCE [name]

  options:
    -h, --help  show this help message and exit
    [name]      Name of resource
    RESOURCE
      module    create a module
      env       create a environment
  ```

  ```
  usage: ecidacli init [-h] NAME

  positional arguments:
    NAME        Name of the first module

  options:
    -h, --help  show this help message and exit
  ```


pkgId: 59efd7ab1cb2321a974c3fc5d9a88e03f17e75f463849f88e2547a7cf7183cea
name: python-ecourts-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for ecourts
url: https://pypi.org/project/ecourts/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ecourts-0.0.8-1.src.rpm
location_href: Packages/python-ecourts-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Search for cases by Case Number   | 🚧WIP | Case Type, Case Number, Year
  Search for cases by FIR Number | 🚧WIP | Police Station, FIR Number†, Year†, Case Status (Pending/Disposed/Both)†
  Search for cases by Party Name | 🔜Planned | Petitioner/Respondent Name, Year†, Case Status (Pending/Disposed/Both)†
  Search for cases by Advocate Name | 🚫No
  Search for cases by Filing Number | 🚧WIP | Filing Number, Year
  Search for cases by Act | ✅Yes | Act Type, Status
  Search for cases by Case Type | 🚧WIP | Case Type, Year†, Pending/Disposed
  Search for Case Orders/Judgement by Case Number | 🚧WIP | Case Type, Case Number, Year
  Search for Case Orders/Judgement by Filling Number | 🚧WIP | Filing Number, Year
  Search for Case Orders/Judgement by Judge Wise | 🚫No |
  Search for Case Orders/Judgement by Party Name | 🔜Planned | Petitioner/Respondent Name, Year
  Search for Case Orders/Judgement by Order Date | ✅Yes | Date
  Get Cause List | ✅Yes | Date|
  **† - Optional**

  Each of the individual courts use their own numbering system for various case-types. So the same type of case might have different ID depending on the court. This can even vary between various benches of the same High Court. For example, HCB (Habeas Corpus Petition) is numbered the following different ways across various courts (not exhaustive):


pkgId: f47bf9e1baf7bb714724d3fdb6815b337e2852d8bf9ee58c823d11c4577b98a2
name: python-ecoviewer-help
arch: noarch
version: 1.4.9
epoch: 0
release: 1
summary: Development documents and examples for ecoviewer
url: https://pypi.org/project/ecoviewer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ecoviewer-1.4.9-1.src.rpm
location_href: Packages/python-ecoviewer-help-1.4.9-1.noarch.rpm
checksum_type: sha256
description:
  HVAC data dash app utility package


  To run Unit tests, run the following command in the terminal in the corresponding directory:
  ```bash
  python -m pytest
  ```


pkgId: f5119c33cb7b8baeba02c25b65e78f783eaafc036fba2feb2096a12f3a70152d
name: python-ecraspay-py-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for ecraspay-py
url: http://github.com/thelimeskies/ecraspay-sdk/src/python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ecraspay-py-0.1.0-1.src.rpm
location_href: Packages/python-ecraspay-py-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Direct integration with the ECRASPAY API:**
    - **Transaction Management**:
      - Fetch transaction details and status.
      - Cancel transactions.
      - Verify transactions.
    - **Card Payments**:
      - Initiate card payments.
      - Submit and resend OTPs.
      - Fetch card transaction details.
      - Verify card payments.
    - **USSD Payments**:
      - Initiate USSD payments.
      - Retrieve a list of supported banks for USSD payments.
    - **Bank Transfers**:
      - Initialize bank transfers by requesting bank account details.
  - **Checkout Payments**:
    - Initiate checkout transactions.


pkgId: 6e8e2aeadb3de7050c0871ed4641fe31de63c160bb73c09c6d874656b70e4776
name: python-edgartools-help
arch: noarch
version: 3.3.0
epoch: 0
release: 1
summary: Development documents and examples for edgartools
url: https://pypi.org/project/edgartools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edgartools-3.3.0-1.src.rpm
location_href: Packages/python-edgartools-help-3.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://github.com/dgunning/edgartools">
      <img src="docs/images/edgartools-demo.gif" alt="edgardemo" height="500">
  </a>
  </p>

  - 📁 **Access any SEC filing**: You can access any SEC filing since 1994.
  - 💰 **Company Financials**: Comprehensive company financials from 10-K and 10-Q filings
  - 👤 **Insider Transactions**: Search for and get insider transactions
  - 📅 **List filings for any date range**: List filings for **year, quarter** e.g. or date range `2024-02-29:2024-03-15`
  - 🌟 **Best looking edgar library**: Uses **[rich](https://rich.readthedocs.io/en/stable/introduction.html)** library to display SEC Edgar data in a beautiful way.
  - 🧠 **Intuitive and easy to use**: **edgartools** has a super simple API that is easy to use.
  - ��️ **Works as a library or a CLI**: You can use edgartools as a library in your code or as a CLI tool.
  - 🔄 **Page through filings**: Use `filings.next()` and `filings.previous()` to page through filings
  - 🏗️ **Build Data Pipelines**: Build data pipelines by finding, filtering, transforming and saving filings
  - ✅ **Select a filing**: You can select a filing from the list of filings.
  - 📄 **View the filing as HTML or text**: Find a filing then get the content as HTML or text.
  - 🔢 **Chunk filing text**: You can chunk the filing text into sections for vector embedding.
  - 🔍 **Preview the filing**: You can preview the filing in the terminal or a notebook.
  - 🔎 **Search through a filing**: You can search through a filing for a keyword.
  - 📊 **Parse XBRL**: Extract XBRL data into intuitive data structures.
  - 💾 **Data Objects**: Automatically downloads and parses filings into data objects.
  - 📥 **Download any attachment**: You can download any attachment from the filing.
  - 🕒 **Automatic throttling**: Automatically throttles requests to Edgar to avoid being blocked.
  - 📥 **Bulk downloads**: Faster batch processing through bulk downloads of filings and facts
  - 🔢 **Get company by Ticker or Cik**: Get a company by ticker `Company("SNOW")` or cik `Company(1640147)`
  -  **Get company filings**: You can get all the company's historical filings using `company.get_filings()`
  - 📈 **Get company facts**: You can get company facts using `company.get_facts()`
  - 🔍 **Lookup Ticker by CUSIP**: You can lookup a ticker by CUSIP
  - 📑 **Dataset of SEC entities**: You can get a dataset of SEC companies and persons
  - 📈 **Fund Reports**: Search for and get 13F-HR fund reports
  - 🛠️ **Works as a library or a CLI**: You can use edgartools as a library in your code or as a CLI tool.

  Install using pip
  ```bash
  pip install edgartools
  ```
  Import and start using
  ```python
  from edgar import *

  set_identity("Michael Mccallum mike.mccalum@indigo.com")
  filings = get_filings()
  ```


  ```python
  c = Company("AAPL")

  filing = c.latest("10-Q")

  tenq = filing.obj()

  financials = tenq.financials
  ```

  ```python
  filings = get_filings(form=['10-K', '10-Q'], year=2020)
  filing = filings[0]
  ```

  ```python
  filing = find("0001065280-23-000273")
  ```
  For a deeper dive see **[Finding things with edgartools](https://github.com/dgunning/edgartools/wiki/FindingThings)**

  |                                      | Code                                                  |
  |--------------------------------------|-------------------------------------------------------|
  | Set your EDGAR identity in Linux/Mac | `export EDGAR_IDENTITY="email@domain.com"` |
  | Set your EDGAR identity in Windows   | `set EDGAR_IDENTITY="email@domain.com"`    |
  | Set identity in Windows Powershell   | `$env:EDGAR_IDENTITY="email@domain.com"`   |
  | Set identity in Python               | `set_identity("email@domain.com")`         |
  | Importing the library                | `from edgar import *`                                 |


  |                                        | Code                                            |
  |----------------------------------------|-------------------------------------------------|
  | 📅 Get filings for the year to date    | `filings = get_filings()`                       |
  | 📊 Get only XBRL filings               | `filings = get_filings(index="xbrl")`           |
  | 📆 Get filings for a specific year     | `filings = get_filings(2020)`                   |
  | 🗓️ Get filings for a specific quarter | `filings = get_filings(2020, 1)`                |
  | 📚 Get filings for multiple years      | `filings = get_filings([2020, 2021])`           |
  | 📈 Get filings for a range of years    | `filings = get_filings(year=range(2010, 2020))` |
  | 📈 Get filings released just now       | `filings = get_latest_filings()`                |

  |                                   | Code                                                             |
  |-----------------------------------|------------------------------------------------------------------|
  | 📝 Filter by form type            | `filings.filter(form="10-K")`                                    |
  | 📑 Filter by multiple forms       | `filings.filter(form=["10-K", "10-Q"])`                          |
  | 🔄 Include form amendments        | `filings.filter(form="10-K", amendments=True)`                   |
  | 🏢 Filter by CIK                  | `filings.filter(cik="0000320193")`                               |
  | 🏙️ Filter by multiple CIKs       | `filings.filter(cik=["0000320193", "1018724"])`                  |
  | 🏷️ Filter by ticker              | `filings.filter(ticker="AAPL")`                                  |
  | 🏷️🏷️ Filter by multiple tickers | `filings.filter(ticker=["AAPL", "MSFT"])`                        |
  | 📅 Filter on a specific date      | `filings.filter(date="2020-01-01")`                              |
  | 📅↔️📅 Filter between dates       | `filings.filter(date="2020-01-01:2020-03-01")`                   |
  | 📅⬅️ Filter before a date         | `filings.filter(date=":2020-03-01")`                             |
  | 📅➡️ Filter after a date          | `filings.filter(date="2020-03-01:")`                             |
  | 🔀 Combine multiple filters       | `filings.filter(form="10-K", date="2020-01-01:", ticker="AAPL")` |

  |                                      | Code                     |
  |--------------------------------------|--------------------------|
  | ⏭️ Show the next page of filings     | `filings.next()`         |
  | ⏮️ Show the previous page of filings | `filings.prev()`       |
  | 🔝 Get the first n filings           | `filings.head(20)`       |
  | 🔚 Get the last n filings            | `filings.tail(20)`       |
  | 🕒 Get the latest n filings by date  | `filings.latest(20)`    |
  | 🎲 Get a random sample of filings    | `filings.sample(20)`     |
  | 🐼 Get filings as a pandas dataframe | `filings.to_pandas()`  |


  |                                     | Code                                                      |
  |-------------------------------------|-----------------------------------------------------------|
  | 📌 Get a single filing              | `filing = filings[3]`                                     |
  | 🔢 Get a filing by accession number | `filing = get_by_accession_number("0000320193-20-34576")` |
  | 🏠 Get the filing homepage          | `filing.homepage`                                         |
  | 🌐 Open a filing in the browser     | `filing.open()`                                           |
  | 🏠 Open homepage in the browser     | `filing.homepage.open()`                                  |
  | 💻 View the filing in the terminal  | `filing.view()`                                           |

  |                                     | Code                         |
  |-------------------------------------|-----------------------------|
  | 🌐 Get the HTML of the filing       | `filing.html()`              |
  | 📊 Get the XBRL of the filing       | `filing.xbrl()`              |
  | 📝 Get the filing as markdown       | `filing.markdown()`          |
  | 📄 Get the full submission text     | `filing.full_text_submission()` |
  | 🔢 Get and parse filing data object | `filing.obj()`               |
  | 📑 Get filing header                | `filing.header`              |

  |                             | Code                                    |
  |-----------------------------|----------------------------------------|
  | 🔍 Search within the filing | `filing.search("query")`                |
  | 🔍 Search with regex        | `filing.search("pattern", regex=True)`  |
  | 📊 Get filing sections      | `filing.sections()`                     |

  |                               | Code                               |
  |-------------------------------|-----------------------------------|
  | 📁 Get all filing attachments | `filing.attachments`              |
  | 📄 Get a single attachment    | `attachment = filing.attachments[0]` |
  | 🌐 Open attachment in browser | `attachment.open()`               |
  | ⬇️ Download an attachment     | `content = attachment.download()` |

  |                                          | Code                                                          |
  |------------------------------------------|---------------------------------------------------------------|
  | Get a company by ticker                  | `company = Company("AAPL")`                                   |
  | Get a company by CIK                     | `company = Company("0000320193")`                             |
  | Get company facts                        | `company.get_facts()`                                         |
  | Get company facts as a pandas dataframe  | `company.get_facts().to_pandas()`                             |
  | Get company filings                      | `company.get_filings()`                                       |
  | Get company filings by form              | `company.get_filings(form="10-K")`                            |
  | Get the latest 10-Q                      | `company.latest("10-Q")`                                      |
  | Get the last 5 10-Q's                    | `company.get_filings(form="10-Q", 5)`                         |
  | Get a company filing by accession_number | `company.get_filing(accession_number="0000320193-21-000139")` |
  | Get the company's financials             | `company.financials`                                          |
  | Get the company's balance sheet          | `company.financials.get_balance_sheet`                        |
  | Get the company's income statement       | `company.financials.get_income_statement`                     |
  | Get the company's cash flow statement    | `company.financials.get_cash_flow_statement`                  |

  ```console
  pip install edgartools
  ```


  Before you can access the SEC Edgar API you need to set the identity that you will use to access Edgar.
  This is usually your name and email, or a company name and email but you can also just use an email.
  ```bash
  Sample Company Name AdminContact@<sample company domain>.com
  ```
  The user identity is sent in the User-Agent string and the Edgar API will refuse to respond to your request without it.
  EdgarTools will look for an environment variable called `EDGAR_IDENTITY` and use that in each request.
  So, you need to set this environment variable before using it.

  ```bash
  export EDGAR_IDENTITY="mcalum@gmail.com"
  ```

  ```bash
   $Env:EDGAR_IDENTITY="mcalum@gmail.com"
  ```
  Alternatively, you can call `set_identity` which does the same thing.
  ```python
  from edgar import set_identity
  set_identity("mcalum@gmail.com")
  ```
  For more detail see https://www.sec.gov/os/accessing-edgar-data


  ```python
  from edgar import *
  ```

  Use the Filing API when you are not working with a specific company, but want to get a list of filings.
  For details on how to use the Filing API see **[Using the Filing API](https://github.com/dgunning/edgartools/wiki/WorkingWithFilings)**

  You can use the company ticker or CIK to get a company.
  ```python
  c = Company("AAPL") # or Company("0000320193") or Company(320193)
  ```
  ![AAPL](docs/images/company-AAPL.png)
  With the Company API you can find a company by ticker or CIK, and get the company's filings, facts and financials.
  ```python
  Company("AAPL")
          .get_filings(form="10-Q")
          .latest(1)
          .obj()
  ```
  ![expe](docs/images/aapl-10Q.png)
  See **[Using the Company API](https://github.com/dgunning/edgartools/wiki/WorkingWithCompanies)**

  Every filing has a list of attachments. You can view the attachments using `filing.attachments`
  ```python

  filing.attachments
  ```
  ![Filing attachments](docs/images/filing_attachments.png)
  You can access each attachment using the bracket operator `[]` and the index of the attachment.
  ```python

  attachment = filing.attachments[0]
  ```
  ![Filing attachment](docs/images/filing_attachment.png)
  You can download the attachment using `attachment.download()`. This will download the attachment to string or bytes in memory.

  Now the reason you may want to download attachments is to get information contained in data files.
  For example, **13F-HR** filings have attached infotable.xml files containing data from the holding report for that filing.
  Fortunately, the library handles this for you. If you call `filing.obj()` it will automatically download and parse the data files
  into a data object, for several different form types. Currently, the following forms are supported:
  | Form                       | Data Object                  | Description                           |
  |----------------------------|------------------------------|---------------------------------------|
  | 10-K                       | `TenK`                       | Annual report                         |
  | 10-Q                       | `TenQ`                       | Quarterly report                      |
  | 8-K                        | `EightK`                     | Current report                        |
  | MA-I                       | `MunicipalAdvisorForm`       | Municipal advisor initial filing      |
  | Form 144                   | `Form144`                    | Notice of proposed sale of securities |
  | C, C-U, C-AR, C-TR         | `FormC`                      | Form C Crowdfunding Offering          |
  | D                          | `FormD`                      | Form D Offering                       |
  | 3,4,5                      | `Ownership`                  | Ownership reports                     |
  | 13F-HR                     | `ThirteenF`                  | 13F Holdings Report                   |
  | NPORT-P                    | `FundReport`                 | Fund Report                           |
  | EFFECT                     | `Effect`                     | Notice of Effectiveness               |
  | Any other filing with XBRL | `XBRLData` or `XBRLInstance` | Container for XBRL data               |
  For example, to get the data object for a **13F-HR** filing you can do the following:
  ```python
  filings = get_filings(form="13F-HR")
  filing = filings[0]
  thirteenf = filing.obj()
  ```
  ![Filing attachments](docs/images/ThirteenF.png)
  If you call `obj()` on a filing that does not have a data file, then it will return `None`.

  Some filings are in **XBRL (eXtensible Business Markup Language)** format.
  These are mainly the newer filings, as the SEC has started requiring this for newer filings.
  If a filing is in XBRL format then it opens up a lot more ways to get structured data about that specific filing and also
  about the company referred to in that filing.
  The `Filing` class has an `xbrl` function that will download, parse and structure the filing's XBRL document if one exists.
  If it does not exist, then `filing.xbrl()` will return `None`.
  The function `filing.xbrl()` returns an `XBRLData` instance if the XBRL files contain presentation information or `XBRLInstance` if it a simple instance document with just the facts.
  For more details see **[Parsing XBRL](https://github.com/dgunning/edgartools/wiki/ParsingXBRL)**
  ```python
  filing_xbrl = filing.xbrl()
  ```
  ![Filing homapage](https://raw.githubusercontent.com/dgunning/edgartools/main/docs/images/10Q_xbrl.jpg)

  Some filings, notably **10-K** and **10-Q** filings contain financial statements in XBRL format.
  You can get the financials from the XBRL data using the `Financials` class.
  The Company object has a `financials` property that will return the financials for the company.
  ```python
  from edgar.financials import Financials
  company = Company("AAPL")
  financials = company.financials
  ```
  You can also get the financials through the `Tenk` and `TenQ` data objects.
  Here is an example that gets the latest Apple financials
  ```python
  tenk = Company("AAPL").get_filings(form="10-K").latest(1).obj()
  financials = tenk.financials
  financials.get_balance_sheet()                     # or financials.balance_sheet
  financials.get_income_statement()                  # or financials.income
  financials.get_cash_flow_statement()               # or financials.cashflow
  financials.get_statement_of_changes_in_equity()    # or financials.equity
  financials.get_statement_of_comprehensive_income() # or financials.comprehensive_income
  ```
  ![Balance Sheet](docs/images/balance_sheet.png)

  Each of the financial statements - `BalanceSheet`, `IncomeStatement` and `CashFlowStatement` - have a `get_dataframe()` method that will return the data as a pandas dataframe.
  ```python
  balance_sheet_df = financials.get_balance_sheet().get_dataframe()
  ```

  For 10-K filngs the 10-K Data Object allows you to access almost any data related to the filing - both text and financial data.
  ```python
  c = Company("ORCL")
  filing = c.get_filings(form="10-K").latest()
  tenk = filing.obj()
  ```
  You can also get it directly using the property `latest_tenk` on the `Company` object.
  ```python
  c = Company("ORCL")
  c.latest_tenk
  ```
  ![10K Data Object](docs/images/orcl-tenk.png)

  You can get the text of individual sections of the 10-K filing using tge bracket `[]` operator.
  ```python
  tenk['Item 1']
  ```
  There are also a few convenience methods to get the most common sections.
  ```python

  tenk.business

  tenk.risk_factors

  tenk.management_discussion

  tenk.directors_officers_and_governance
  ```

  The library is designed to make real time calls to EDGAR to get the latest data. However, you may want to download data for offline use or to build a dataset.

  You can download all the company **filings** and **facts** from Edgar using the `download_edgar_data` function.
  Note that this will store json files for each company of their facts and submissions, but it will not include the actual HTML or other attachments.
  It will however dramatically speed up loading companies by cik or ticker.
  The submissions and facts bulk data files are each over 1.GB in size, and take around a few minutes each.
  The data is stored by default in the `~/.edgar` directory. You can change this by setting the `EDGAR_LOCAL_DATA_DIR` environment variable.
  ```python
  def download_edgar_data(submissions: bool = True, facts: bool = True, reference: bool = True):
      """
      Download all the company data from Edgar
      """
  download_edgar_data()
  ```

  If you want edgartools to use the bulk data files you can call `use_local_storage()` before you start making calls using the library.
  Alternatively, set `EDGAR_USE_LOCAL_DATA` to `True` in your environment.

  - The filings downloaded for each company is limited to the last 1000
  - You will need to download the latest data every so often to keep it up to date.

  You can download attachments from a filing using the `download` method on the attachments. This will download all the attached files to a folder of your choice.
  ```python
  class Attachments:
      def download(self, path: Union[str, Path], archive: bool = False):
          """
          Download all the attachments to a specified path.
          If the path is a directory, the file is saved with its original name in that directory.
          If the path is a file, the file is saved with the given path name.
          If archive is True, the attachments are saved in a zip file.
          path: str or Path - The path to save the attachments
          archive: bool (default False) - If True, save the attachments in a zip file
          """

  filing.attachments.download(path)
  ```

  Contributions are welcome! We would love to hear your thoughts on how this library could be better at working with SEC Edgar.

  We use GitHub issues to track public bugs.
  Report a bug by [opening a new issue](https://github.com/dgunning/edgartools/issues); it's that easy!

  - Fork the repo and create your branch from master.
  - If you've added code that should be tested, add tests.
  - If you've changed APIs, update the documentation.
  - Ensure the test suite passes.
  - Make sure your code lints.
  - Issue that pull request!

  `edgartools` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

  [LinkedIn](https://www.linkedin.com/in/dwight-gunning-860124/)

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

  <picture>
  2  <source media="(prefers-color-scheme: dark)" srcset="https://polar.sh/embed/subscribe.svg?org=polarsource&label=Subscribe&darkmode">
  3  <img alt="Subscribe on Polar" src="https://polar.sh/embed/subscribe.svg?org=polarsource&label=Subscribe">
  4</picture>


pkgId: bc1f2e269b3efa47dd93b066138df7f107a7f1b7dc79947580cac4edf0daf4be
name: python-edgartools-help
arch: noarch
version: 3.3.2
epoch: 0
release: 1
summary: Development documents and examples for edgartools
url: https://pypi.org/project/edgartools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edgartools-3.3.2-1.src.rpm
location_href: Packages/python-edgartools-help-3.3.2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://github.com/dgunning/edgartools">
      <img src="docs/images/edgartools-demo.gif" alt="edgardemo" height="500">
  </a>
  </p>

  📊 Access company financials, insider trades, and SEC filings instantly with Python's most powerful EDGAR data library. 🚀 Easy to use, fast results.

  - 📁 **Access any SEC filing**: You can access any SEC filing since 1994.
  - 💰 **Company Financials**: Comprehensive company financials from 10-K and 10-Q filings
  - 👤 **Insider Transactions**: Search for and get insider transactions
  - 📅 **List filings for any date range**: List filings for **year, quarter** e.g. or date range `2024-02-29:2024-03-15`
  - 🌟 **Best looking edgar library**: Uses **[rich](https://rich.readthedocs.io/en/stable/introduction.html)** library to display SEC Edgar data in a beautiful way.
  - 🧠 **Intuitive and easy to use**: **edgartools** has a super simple API that is easy to use.
  - ��️ **Works as a library or a CLI**: You can use edgartools as a library in your code or as a CLI tool.
  - 🔄 **Page through filings**: Use `filings.next()` and `filings.previous()` to page through filings
  - 🏗️ **Build Data Pipelines**: Build data pipelines by finding, filtering, transforming and saving filings
  - ✅ **Select a filing**: You can select a filing from the list of filings.
  - 📄 **View the filing as HTML or text**: Find a filing then get the content as HTML or text.
  - 🔢 **Chunk filing text**: You can chunk the filing text into sections for vector embedding.
  - 🔍 **Preview the filing**: You can preview the filing in the terminal or a notebook.
  - 🔎 **Search through a filing**: You can search through a filing for a keyword.
  - 📊 **Parse XBRL**: Extract XBRL data into intuitive data structures.
  - 💾 **Data Objects**: Automatically downloads and parses filings into data objects.
  - 📥 **Download any attachment**: You can download any attachment from the filing.
  - 🕒 **Automatic throttling**: Automatically throttles requests to Edgar to avoid being blocked.
  - 📥 **Bulk downloads**: Faster batch processing through bulk downloads of filings and facts
  - 🔢 **Get company by Ticker or Cik**: Get a company by ticker `Company("SNOW")` or cik `Company(1640147)`
  -  **Get company filings**: You can get all the company's historical filings using `company.get_filings()`
  - 📈 **Get company facts**: You can get company facts using `company.get_facts()`
  - 🔍 **Lookup Ticker by CUSIP**: You can lookup a ticker by CUSIP
  - 📑 **Dataset of SEC entities**: You can get a dataset of SEC companies and persons
  - 📈 **Fund Reports**: Search for and get 13F-HR fund reports
  - 🛠️ **Works as a library or a CLI**: You can use edgartools as a library in your code or as a CLI tool.

  Install using pip
  ```bash
  pip install edgartools
  ```
  Import and start using
  ```python
  from edgar import *

  set_identity("Michael Mccallum mike.mccalum@indigo.com")
  filings = get_filings()
  ```


  ```python
  c = Company("AAPL")

  filing = c.latest("10-Q")

  tenq = filing.obj()

  financials = tenq.financials
  ```

  ```python
  filings = get_filings(form=['10-K', '10-Q'], year=2020)
  filing = filings[0]
  ```

  ```python
  filing = find("0001065280-23-000273")
  ```
  For a deeper dive see **[Finding things with edgartools](https://github.com/dgunning/edgartools/wiki/FindingThings)**

  |                                      | Code                                                  |
  |--------------------------------------|-------------------------------------------------------|
  | Set your EDGAR identity in Linux/Mac | `export EDGAR_IDENTITY="email@domain.com"` |
  | Set your EDGAR identity in Windows   | `set EDGAR_IDENTITY="email@domain.com"`    |
  | Set identity in Windows Powershell   | `$env:EDGAR_IDENTITY="email@domain.com"`   |
  | Set identity in Python               | `set_identity("email@domain.com")`         |
  | Importing the library                | `from edgar import *`                                 |


  |                                        | Code                                            |
  |----------------------------------------|-------------------------------------------------|
  | 📅 Get filings for the year to date    | `filings = get_filings()`                       |
  | 📊 Get only XBRL filings               | `filings = get_filings(index="xbrl")`           |
  | 📆 Get filings for a specific year     | `filings = get_filings(2020)`                   |
  | 🗓️ Get filings for a specific quarter | `filings = get_filings(2020, 1)`                |
  | 📚 Get filings for multiple years      | `filings = get_filings([2020, 2021])`           |
  | 📈 Get filings for a range of years    | `filings = get_filings(year=range(2010, 2020))` |
  | 📈 Get filings released just now       | `filings = get_latest_filings()`                |

  |                                   | Code                                                             |
  |-----------------------------------|------------------------------------------------------------------|
  | 📝 Filter by form type            | `filings.filter(form="10-K")`                                    |
  | 📑 Filter by multiple forms       | `filings.filter(form=["10-K", "10-Q"])`                          |
  | 🔄 Include form amendments        | `filings.filter(form="10-K", amendments=True)`                   |
  | 🏢 Filter by CIK                  | `filings.filter(cik="0000320193")`                               |
  | 🏙️ Filter by multiple CIKs       | `filings.filter(cik=["0000320193", "1018724"])`                  |
  | 🏷️ Filter by ticker              | `filings.filter(ticker="AAPL")`                                  |
  | 🏷️🏷️ Filter by multiple tickers | `filings.filter(ticker=["AAPL", "MSFT"])`                        |
  | 📅 Filter on a specific date      | `filings.filter(date="2020-01-01")`                              |
  | 📅↔️📅 Filter between dates       | `filings.filter(date="2020-01-01:2020-03-01")`                   |
  | 📅⬅️ Filter before a date         | `filings.filter(date=":2020-03-01")`                             |
  | 📅➡️ Filter after a date          | `filings.filter(date="2020-03-01:")`                             |
  | 🔀 Combine multiple filters       | `filings.filter(form="10-K", date="2020-01-01:", ticker="AAPL")` |

  |                                      | Code                     |
  |--------------------------------------|--------------------------|
  | ⏭️ Show the next page of filings     | `filings.next()`         |
  | ⏮️ Show the previous page of filings | `filings.prev()`       |
  | 🔝 Get the first n filings           | `filings.head(20)`       |
  | 🔚 Get the last n filings            | `filings.tail(20)`       |
  | 🕒 Get the latest n filings by date  | `filings.latest(20)`    |
  | 🎲 Get a random sample of filings    | `filings.sample(20)`     |
  | 🐼 Get filings as a pandas dataframe | `filings.to_pandas()`  |


  |                                     | Code                                                      |
  |-------------------------------------|-----------------------------------------------------------|
  | 📌 Get a single filing              | `filing = filings[3]`                                     |
  | 🔢 Get a filing by accession number | `filing = get_by_accession_number("0000320193-20-34576")` |
  | 🏠 Get the filing homepage          | `filing.homepage`                                         |
  | 🌐 Open a filing in the browser     | `filing.open()`                                           |
  | 🏠 Open homepage in the browser     | `filing.homepage.open()`                                  |
  | 💻 View the filing in the terminal  | `filing.view()`                                           |

  |                                     | Code                         |
  |-------------------------------------|-----------------------------|
  | 🌐 Get the HTML of the filing       | `filing.html()`              |
  | 📊 Get the XBRL of the filing       | `filing.xbrl()`              |
  | 📝 Get the filing as markdown       | `filing.markdown()`          |
  | 📄 Get the full submission text     | `filing.full_text_submission()` |
  | 🔢 Get and parse filing data object | `filing.obj()`               |
  | 📑 Get filing header                | `filing.header`              |

  |                             | Code                                    |
  |-----------------------------|----------------------------------------|
  | 🔍 Search within the filing | `filing.search("query")`                |
  | 🔍 Search with regex        | `filing.search("pattern", regex=True)`  |
  | 📊 Get filing sections      | `filing.sections()`                     |

  |                               | Code                               |
  |-------------------------------|-----------------------------------|
  | 📁 Get all filing attachments | `filing.attachments`              |
  | 📄 Get a single attachment    | `attachment = filing.attachments[0]` |
  | 🌐 Open attachment in browser | `attachment.open()`               |
  | ⬇️ Download an attachment     | `content = attachment.download()` |

  |                                          | Code                                                          |
  |------------------------------------------|---------------------------------------------------------------|
  | Get a company by ticker                  | `company = Company("AAPL")`                                   |
  | Get a company by CIK                     | `company = Company("0000320193")`                             |
  | Get company facts                        | `company.get_facts()`                                         |
  | Get company facts as a pandas dataframe  | `company.get_facts().to_pandas()`                             |
  | Get company filings                      | `company.get_filings()`                                       |
  | Get company filings by form              | `company.get_filings(form="10-K")`                            |
  | Get the latest 10-Q                      | `company.latest("10-Q")`                                      |
  | Get the last 5 10-Q's                    | `company.get_filings(form="10-Q", 5)`                         |
  | Get a company filing by accession_number | `company.get_filing(accession_number="0000320193-21-000139")` |
  | Get the company's financials             | `company.financials`                                          |
  | Get the company's balance sheet          | `company.financials.get_balance_sheet`                        |
  | Get the company's income statement       | `company.financials.get_income_statement`                     |
  | Get the company's cash flow statement    | `company.financials.get_cash_flow_statement`                  |

  ```console
  pip install edgartools
  ```


  Before you can access the SEC Edgar API you need to set the identity that you will use to access Edgar.
  This is usually your name and email, or a company name and email but you can also just use an email.
  ```bash
  Sample Company Name AdminContact@<sample company domain>.com
  ```
  The user identity is sent in the User-Agent string and the Edgar API will refuse to respond to your request without it.
  EdgarTools will look for an environment variable called `EDGAR_IDENTITY` and use that in each request.
  So, you need to set this environment variable before using it.

  ```bash
  export EDGAR_IDENTITY="mcalum@gmail.com"
  ```

  ```bash
   $Env:EDGAR_IDENTITY="mcalum@gmail.com"
  ```
  Alternatively, you can call `set_identity` which does the same thing.
  ```python
  from edgar import set_identity
  set_identity("mcalum@gmail.com")
  ```
  For more detail see https://www.sec.gov/os/accessing-edgar-data


  ```python
  from edgar import *
  ```

  Use the Filing API when you are not working with a specific company, but want to get a list of filings.
  For details on how to use the Filing API see **[Using the Filing API](https://github.com/dgunning/edgartools/wiki/WorkingWithFilings)**

  You can use the company ticker or CIK to get a company.
  ```python
  c = Company("AAPL") # or Company("0000320193") or Company(320193)
  ```
  ![AAPL](docs/images/company-AAPL.png)
  With the Company API you can find a company by ticker or CIK, and get the company's filings, facts and financials.
  ```python
  Company("AAPL")
          .get_filings(form="10-Q")
          .latest(1)
          .obj()
  ```
  ![expe](docs/images/aapl-10Q.png)
  See **[Using the Company API](https://github.com/dgunning/edgartools/wiki/WorkingWithCompanies)**

  Every filing has a list of attachments. You can view the attachments using `filing.attachments`
  ```python

  filing.attachments
  ```
  ![Filing attachments](docs/images/filing_attachments.png)
  You can access each attachment using the bracket operator `[]` and the index of the attachment.
  ```python

  attachment = filing.attachments[0]
  ```
  ![Filing attachment](docs/images/filing_attachment.png)
  You can download the attachment using `attachment.download()`. This will download the attachment to string or bytes in memory.

  Now the reason you may want to download attachments is to get information contained in data files.
  For example, **13F-HR** filings have attached infotable.xml files containing data from the holding report for that filing.
  Fortunately, the library handles this for you. If you call `filing.obj()` it will automatically download and parse the data files
  into a data object, for several different form types. Currently, the following forms are supported:
  | Form                       | Data Object                  | Description                           |
  |----------------------------|------------------------------|---------------------------------------|
  | 10-K                       | `TenK`                       | Annual report                         |
  | 10-Q                       | `TenQ`                       | Quarterly report                      |
  | 8-K                        | `EightK`                     | Current report                        |
  | MA-I                       | `MunicipalAdvisorForm`       | Municipal advisor initial filing      |
  | Form 144                   | `Form144`                    | Notice of proposed sale of securities |
  | C, C-U, C-AR, C-TR         | `FormC`                      | Form C Crowdfunding Offering          |
  | D                          | `FormD`                      | Form D Offering                       |
  | 3,4,5                      | `Ownership`                  | Ownership reports                     |
  | 13F-HR                     | `ThirteenF`                  | 13F Holdings Report                   |
  | NPORT-P                    | `FundReport`                 | Fund Report                           |
  | EFFECT                     | `Effect`                     | Notice of Effectiveness               |
  | Any other filing with XBRL | `XBRLData` or `XBRLInstance` | Container for XBRL data               |
  For example, to get the data object for a **13F-HR** filing you can do the following:
  ```python
  filings = get_filings(form="13F-HR")
  filing = filings[0]
  thirteenf = filing.obj()
  ```
  ![Filing attachments](docs/images/ThirteenF.png)
  If you call `obj()` on a filing that does not have a data file, then it will return `None`.

  Some filings are in **XBRL (eXtensible Business Markup Language)** format.
  These are mainly the newer filings, as the SEC has started requiring this for newer filings.
  If a filing is in XBRL format then it opens up a lot more ways to get structured data about that specific filing and also
  about the company referred to in that filing.
  The `Filing` class has an `xbrl` function that will download, parse and structure the filing's XBRL document if one exists.
  If it does not exist, then `filing.xbrl()` will return `None`.
  The function `filing.xbrl()` returns an `XBRLData` instance if the XBRL files contain presentation information or `XBRLInstance` if it a simple instance document with just the facts.
  For more details see **[Parsing XBRL](https://github.com/dgunning/edgartools/wiki/ParsingXBRL)**
  ```python
  filing_xbrl = filing.xbrl()
  ```
  ![Filing homapage](https://raw.githubusercontent.com/dgunning/edgartools/main/docs/images/10Q_xbrl.jpg)

  Some filings, notably **10-K** and **10-Q** filings contain financial statements in XBRL format.
  You can get the financials from the XBRL data using the `Financials` class.
  The Company object has a `financials` property that will return the financials for the company.
  ```python
  from edgar.financials import Financials
  company = Company("AAPL")
  financials = company.financials
  ```
  You can also get the financials through the `Tenk` and `TenQ` data objects.
  Here is an example that gets the latest Apple financials
  ```python
  tenk = Company("AAPL").get_filings(form="10-K").latest(1).obj()
  financials = tenk.financials
  financials.get_balance_sheet()                     # or financials.balance_sheet
  financials.get_income_statement()                  # or financials.income
  financials.get_cash_flow_statement()               # or financials.cashflow
  financials.get_statement_of_changes_in_equity()    # or financials.equity
  financials.get_statement_of_comprehensive_income() # or financials.comprehensive_income
  ```
  ![Balance Sheet](docs/images/balance_sheet.png)

  Each of the financial statements - `BalanceSheet`, `IncomeStatement` and `CashFlowStatement` - have a `get_dataframe()` method that will return the data as a pandas dataframe.
  ```python
  balance_sheet_df = financials.get_balance_sheet().get_dataframe()
  ```

  For 10-K filngs the 10-K Data Object allows you to access almost any data related to the filing - both text and financial data.
  ```python
  c = Company("ORCL")
  filing = c.get_filings(form="10-K").latest()
  tenk = filing.obj()
  ```
  You can also get it directly using the property `latest_tenk` on the `Company` object.
  ```python
  c = Company("ORCL")
  c.latest_tenk
  ```
  ![10K Data Object](docs/images/orcl-tenk.png)

  You can get the text of individual sections of the 10-K filing using tge bracket `[]` operator.
  ```python
  tenk['Item 1']
  ```
  There are also a few convenience methods to get the most common sections.
  ```python

  tenk.business

  tenk.risk_factors

  tenk.management_discussion

  tenk.directors_officers_and_governance
  ```

  The library is designed to make real time calls to EDGAR to get the latest data. However, you may want to download data for offline use or to build a dataset.

  You can download all the company **filings** and **facts** from Edgar using the `download_edgar_data` function.
  Note that this will store json files for each company of their facts and submissions, but it will not include the actual HTML or other attachments.
  It will however dramatically speed up loading companies by cik or ticker.
  The submissions and facts bulk data files are each over 1.GB in size, and take around a few minutes each.
  The data is stored by default in the `~/.edgar` directory. You can change this by setting the `EDGAR_LOCAL_DATA_DIR` environment variable.
  ```python
  def download_edgar_data(submissions: bool = True, facts: bool = True, reference: bool = True):
      """
      Download all the company data from Edgar
      """
  download_edgar_data()
  ```

  If you want edgartools to use the bulk data files you can call `use_local_storage()` before you start making calls using the library.
  Alternatively, set `EDGAR_USE_LOCAL_DATA` to `True` in your environment.

  - The filings downloaded for each company is limited to the last 1000
  - You will need to download the latest data every so often to keep it up to date.

  You can download attachments from a filing using the `download` method on the attachments. This will download all the attached files to a folder of your choice.
  ```python
  class Attachments:
      def download(self, path: Union[str, Path], archive: bool = False):
          """
          Download all the attachments to a specified path.
          If the path is a directory, the file is saved with its original name in that directory.
          If the path is a file, the file is saved with the given path name.
          If archive is True, the attachments are saved in a zip file.
          path: str or Path - The path to save the attachments
          archive: bool (default False) - If True, save the attachments in a zip file
          """

  filing.attachments.download(path)
  ```

  Contributions are welcome! We would love to hear your thoughts on how this library could be better at working with SEC Edgar.

  We use GitHub issues to track public bugs.
  Report a bug by [opening a new issue](https://github.com/dgunning/edgartools/issues); it's that easy!

  - Fork the repo and create your branch from master.
  - If you've added code that should be tested, add tests.
  - If you've changed APIs, update the documentation.
  - Ensure the test suite passes.
  - Make sure your code lints.
  - Issue that pull request!

  `edgartools` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

  - **[Project Documentation](https://dgunning.github.io/edgartools/)**
  - **[Edgartools Blog](https://www.edgartools.io)**
  - **[Dwight Gunning on LinkedIn](https://www.linkedin.com/in/dwight-gunning-860124/)**

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


pkgId: bd47f8e1722bbd69ba53193a3cfc4ec5121bde38ea82ce77c979d2bc53b2b9c3
name: python-edgeimpulse-api-help
arch: noarch
version: 1.63.3
epoch: 0
release: 1
summary: Development documents and examples for edgeimpulse-api
url: https://edgeimpulse.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edgeimpulse-api-1.63.3-1.src.rpm
location_href: Packages/python-edgeimpulse-api-help-1.63.3-1.noarch.rpm
checksum_type: sha256
description:
  This is the official Python API bindings for Edge Impulse. It's designed to make it easier to use the Edge Impulse API from Python.

  For a high-level SDK that automates common tasks, see the [Edge Impulse Python SDK](https://pypi.org/project/edgeimpulse/).

  The API documentation can be found [here](https://docs.edgeimpulse.com/reference/python-api-bindings/edgeimpulse_api).



  ```python
  $ pip install edgeimpulse-api

  > import edgeimpulse_api as ei_api
  ```


pkgId: 60499732dd2326178f591a3badfa3dca296b7186087bb90a4dd1c7f40fd7ea42
name: python-edgeprotecttools-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for edgeprotecttools
url: https://github.com/Infineon/edgeprotecttools
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edgeprotecttools-1.3.0-1.src.rpm
location_href: Packages/python-edgeprotecttools-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  This package contains security tools for creating keys, creating certificates, signing user applications, and provisioning Cypress/Infineon MCUs.


  - [HW/SW compatibility](#hwsw-compatibility)
  - [Prerequisites](#prerequisites)
  - [Documentation](#documentation)
  - [Standalone Executable](#standalone-executable)
  - [Installing From Sources](#installing-from-sources)
  - [Supported Devices](#supported-devices)
  - [Interface and Usage](#interface-and-usage)
  - [Logging](#logging)
  - [Known Issues](#known-issues)
  - [Error Handling](#error-handling)
  - [License and Contributions](#license-and-contributions)



  <table>
    <thead>
      <tr>
        <td>Target/Kit</td>
        <td>Silicon ID, Silicon Rev., Family ID</td>
        <td>Secure FlashBoot Version</td>
        <td>CyBootloader Version</td>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td colspan="6" style="text-align: center;">512K</td>
      </tr>
      <tr>
        <td>
          cyb06xx5<br>
          cy8cproto&#8209;064b0s3
        </td>
        <td>0xE70D, 0x12, 0x105</td>
        <td>4.0.2.1842</td>
        <td>2.0.1.6441</td>
      </tr>
      <tr>
        <td colspan="6" style="text-align: center;">2M</td>
      </tr>
      <tr>
        <td>
          cyb06xxa<br>
          cy8ckit&#8209;064b0s2&#8209;4343w
        </td>
        <td>0xE470, 0x12, 0x102</td>
        <td>4.0.3.2319</td>
        <td>2.0.2.8102</td>
      </tr>
      <tr>
        <td>
          cys06xxa<br>
          cy8ckit&#8209;064s0s2&#8209;4343w
        </td>
        <td>0xE4A0, 0x12, 0x02</td>
        <td>4.0.3.2319</td>
        <td>2.0.2.8102</td>
      </tr>
      <tr>
        <td colspan="6" style="text-align: center;">1M</td>
      </tr>
      <tr>
        <td>
          cyb06xx7<br>
          cy8cproto&#8209;064s1&#8209;sb<br>
          cy8cproto&#8209;064b0s1&#8209;ble<br>
          cy8cproto&#8209;064b0s1&#8209;ssa
        </td>
        <td>
          0xE262, 0x24, 0x100
          0xE261, 0x24, 0x100
        </td>
        <td>4.0.2.1842</td>
        <td>2.0.0.4041</td>
      </tr>
    </tbody>
  </table>


  <table>
    <thead>
      <tr>
        <td>Target/Kit</td>
        <td>Silicon ID, Silicon Rev., Family ID</td>
        <td>ROM Boot Version</td>
        <td>RAM Applications Version</td>
      </tr>
    </thead>
    <tbody>
    <tr>
      <td>cyw20829</td>
      <td>0xEB43, 0x21, 0x110</td>
      <td>1.2.0.8334</td>
      <td>1.2.0.3073</td>
    </tr>
    <tr>
      <td>cyw89829</td>
      <td>0xEB47, 0x21, 0x110</td>
      <td>1.2.0.8334</td>
      <td>1.2.0.3073</td>
    </tr>
    </tbody>
  </table>


  * Python 3.8 - 3.12
  * [Installed Infineon OpenOCD](https://github.com/Infineon/openocd/releases)
  * Ensure the KitProg3 programming mode is **CMSIS-DAP Bulk**



  * [PSoC64 Secure MCU Secure Boot SDK User Guide](https://www.cypress.com/documentation/software-and-drivers/psoc-64-secure-mcu-secure-boot-sdk-user-guide)
  * [Changelog](https://github.com/Infineon/edgeprotecttools/blob/master/CHANGELOG.md)


  Edge Protect Tools can be used as a standalone application. The executable can be found in the `tools/edgeprotecttools/bin` directory of the Edge Protect Security Suite or Early Access Pack installation.


  Alternatively Edge Protect Tools can be installed from the sources as a Python package. The source code is located in the `tools/edgeprotecttools/src` directory of the Edge Protect Security Suite or Early Access Pack installation.

  Install Python 3.12 on your computer. You can download it from https://www.python.org/downloads/. Set up the appropriate environment variable(s) for your operating system.


  Make sure that you have the latest version of pip installed, use
  the following command.
  ```bash
  $ python -m pip install --upgrade pip
  ```
  Run the following command, from the Early Access Pack or Edge Protect Security Suite directory.
  ```bash
  $ python -m pip install tools/edgeprotecttools/src
  ```


  To update the already installed package, run the following command from the Early Access Pack or Edge Protect Security Suite directory.
  ```bash
  $ python -m pip install --upgrade --force-reinstall tools/edgeprotecttools/src
  ```

  *Note*: There may be some pip dependency resolver errors. In most cases, these can be safely ignored.

  *Note*: You can use the following command to show the path to the installed package
  `$ python -m pip show edgeprotecttools`.



  Use `device-list` command for output of the supported devices list.
  ```bash
  $ edgeprotecttools device-list
  ```



  For instructions how to use common commands, see [README_GENERAL.md](https://github.com/Infineon/edgeprotecttools/blob/master/docs/README_GENERAL.md).

  For instructions how to use target-specific commands, see the corresponding readme file in the [docs](https://github.com/Infineon/edgeprotecttools/blob/master/docs) directory.



  Every time the tool is invoked, a new log file is created in the _logs_ directory of the project. By default, the console output has INFO logging severity. The log file contains the DEBUG logging severity.



  - Using the policy from CySecureTools 4.0.0 in projects created by CySecureTools 4.1.0 causes the CY_FB_INVALID_IMG_JWT_SIGNATURE error during re-provisioning on PSoC64-2M devices:
  ```
    ...
    ERROR : SFB status: CY_FB_INVALID_IMG_JWT_SIGNATURE: Invalid image certificate signature. Check the log for details
  ```
  _Workaround_:
  1. Open the policy file.
  2. Navigate to section 1 of the `boot_upgrade/firmware`.
  3. Set `boot_auth` and `bootloader_keys` as follows:
  ```
  "boot_auth": [
      3
  ],
  "bootloader_keys": [
      {
          "kid": 3,
          "key": "../keys/cy_pub_key.json"
      }
  ]
  ```
  - During the installation of the package via _pip_ on Mac OS Big Sur, the following exception is raised:
  ```
    ...
    distutils.errors.DistutilsError: Setup script exited with error: SandboxViolation:
    mkdir('/private/var/root/Library/Caches/com.apple.python/private/tmp/easy_install-y8c1npmz', 511) {}

    The package setup script has attempted to modify files on your system
    that are not within the EasyInstall build area, and has been aborted.

    This package cannot be safely installed by EasyInstall, and may not
    support alternate installation locations even if you run its setup
    script by hand.  Please inform the package's author and the EasyInstall
    maintainers to find out if a fix or workaround is available.
  ```
  _Solution:_ Upgrade the `pip` package running the following command from the terminal: `python3 -m pip install --upgrade pip`.


  Refer to the guidelines on how to [resolve errors](https://github.com/Infineon/edgeprotecttools/blob/master/docs/README_ERRORS.md).


  The software is provided under the Apache-2.0 license. Contributions to this project are accepted under the same license.
  This project contains code from other projects. The original license text is included in those source files.



  All notable changes to this project will be documented in this file.



  - X.509 certificates generation and verification
  - Device certificate generation for CYW559xx



  - Support for PSOC C3 device
  - Reading device CSR from CYW559xx



  - Support for CYW559xx device



  - Backward compatibility with the [CySecureTools 6.1.0](https://github.com/Infineon/cysecuretools) package
  - Combiner/Signer tool


pkgId: dd5373b4b951affe2593ac733ac8607d1af9741ec3d40120e93a8db098ecab13
name: python-edi-energy-scraper-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for edi-energy-scraper
url: https://github.com/Hochfrequenz/edi_energy_scraper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edi-energy-scraper-0.8.0-1.src.rpm
location_href: Packages/python-edi-energy-scraper-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  <!--- you need to replace the `organization/repo_name` in the status badge URLs --->

  ![Unittests status badge](https://github.com/Hochfrequenz/edi_energy_scraper/workflows/Unittests/badge.svg)
  ![Coverage status badge](https://github.com/Hochfrequenz/edi_energy_scraper/workflows/Coverage/badge.svg)
  ![Linting status badge](https://github.com/Hochfrequenz/edi_energy_scraper/workflows/Linting/badge.svg)
  ![Black status badge](https://github.com/Hochfrequenz/edi_energy_scraper/workflows/Black/badge.svg)
  ![PyPi Status Badge](https://img.shields.io/pypi/v/edi_energy_scraper)

  The Python package `edi_energy_scraper` provides easy to use methods to mirror the website edi-energy.de.



  If you'd like to be informed about new regulations or data formats being published on edi-energy.de you can either

  - visit the site every day and hope that you see the changes if this is your favourite hobby,
  - or automate the task.

  This repository helps you with the latter. It allows you to create an up-to-date copy of edi-energy.de on your local
  computer. Other than if you mirrored the files using `wget` or `curl`, you'll get a clean and intuitive directory
  structure.


  From there you can e.g. commit the files into a VCS (like e.g. our [edi_energy_mirror](https://github.com/Hochfrequenz/edi_energy_mirror)), scrape the PDF/Word files for later use...

  We're all hoping for the day of true digitization on which this repository will become obsolete.



  Install via pip:

  ```bash
  pip install edi_energy_scraper
  ```

  Create a directory in which you'd like to save the mirrored data:

  ```bash
  mkdir edi_energy_de
  ```

  Then import it and start the download:

  ```python
  import asyncio
  from edi_energy_scraper import EdiEnergyScraper






  async def mirror():
      scraper = EdiEnergyScraper(path_to_mirror_directory="edi_energy_de")
      await scraper.mirror()


  if __name__ == "__main__":
      loop = asyncio.new_event_loop()
      asyncio.set_event_loop(loop)
      asyncio.run(mirror())

  ```

  This creates a directory structure:

  ```
  -|-your_script_cwd.py
   |-edi_energy_de
      |- past (contains archived files)
          |- ahb.pdf
          |- ahb.docx
          |- ...
      |- current (contains files valid as of today)
          |- mig.pdf
          |- mig.docx
          |- ...
      |- future (contains files valid in the future)
          |- allgemeine_festlegungen.pdf
          |- schema.xsd
          |- ...
  ```



  Please follow the instructions in
  our [Python Template Repository](https://github.com/Hochfrequenz/python_template_repository#how-to-use-this-repository-on-your-machine)
  . And for further information, see the [Tox Repository](https://github.com/tox-dev/tox).



  You are very welcome to contribute to this template repository by opening a pull request against the main branch.


pkgId: 0a2bcb46ff36288b40a9af0bc44c7ff96ac54670f36c0bf05b67de271072dd4a
name: python-edna2-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for edna2
url: https://github.com/olofsvensson/edna2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edna2-2.0.0-1.src.rpm
location_href: Packages/python-edna2-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  The EDNA2 project is a complete rewrite of the EDNA project.
  For more info about the EDNA project see http://www.edna-site.org.
  The version of ENDA used at the ESRF is: https://github.com/olofsvensson/edna-mx.
  The EDNA2 project tries to keep the 'spirit' of the EDNA project and at the
  same time make the framework lightweight. These are the main differences with the EDNA project:
  - Not compatible with python 2.7 - requires python 3
  - No data modelling framework
  - Data persisted as json instead of XML
  - Tasks instead of plugins
  - Logging based on Python logging
  - Python unit tests
  These are the main features retained in the EDNA2 project:
  - Asynchronous execution of tasks
  - Task configuration based on sites
  - Hierarchical working directory structure handled by the framework.
  Wherever possible a link is provided in the EDNA2 source code to the
  corresponding EDNA code.


pkgId: d52a5b051a106d38bebd1a15c074c11e159f31bc509f2d37cc5d0859aa13470a
name: python-edq-canvas-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for edq-canvas
url: https://github.com/edulinq/py-canvas
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edq-canvas-0.0.7-1.src.rpm
location_href: Packages/python-edq-canvas-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  A suite of tools and Python interface for Instructure's Canvas LMS.

  This project is not affiliated with Instructure.

  Documentation Table of Contents:
   - [Installation](#installation)
   - [CLI Configuration](#cli-configuration)
   - [Usage Notes](#usage-notes)
      - [Users](#users)
      - [Assignments](#assignments)
      - [Groupings and Groups](#groupings-and-groups)
      - [Tables](#tables)
   - [CLI Tools](#cli-tools)
      - [List Course Users](#list-course-users)
      - [Fetch a Single User](#fetch-a-single-user)
      - [List Assignments](#list-assignments)
      - [Fetch a Single Assignment](#fetch-a-single-assignment)
      - [Fetch Assignment Scores](#fetch-assignment-scores)
      - [Fetch Assignment Submission Files](#fetch-assignment-submission-files)
      - [Upload Assignment Scores](#upload-assignment-scores)
      - [Upload Single Assignment Score](#upload-single-assignment-score)
      - [Fetch Gradebook](#fetch-gradebook)
      - [Upload Gradebook](#upload-gradebook)
      - [List Groupings](#list-groupings)
      - [List Groups](#list-groups)
      - [List Membership in a Grouping](#list-membership-in-a-grouping)
      - [List Members in a Group](#list-members-in-a-group)



  The project (tools and API) can be installed from PyPi with:
  ```
  pip install edq-canvas
  ```

  Standard Python requirements are listed in `pyproject.toml`.
  The project and Python dependencies can be installed from source with:
  ```
  pip3 install .
  ```



  Before discussing specific tools, you should know some general information about
  configuring and sending options to each CLI tool.

  To know who you are and what you are working on the package needs a few configuration options:
   - `server` -- The Canvas server to connect to.
   - `course` -- The Canvas ID for the course you are working with.
   - `token` -- Your Canvas API token (see the [Canvas documentation](https://community.canvaslms.com/t5/Admin-Guide/How-do-I-manage-API-access-tokens-as-an-admin/ta-p/89).
   - `assignment` -- A query for the current assignment you are working on (does not always apply).

  All these options can be set on the command line when invoking on of these tools, e.g.,:
  ```sh
  python3 -m canvas.cli.user.list --server canvas.test.com --course 12345 --token abc123
  ```
  However, it will generally be more convenient to hold these common options in a more reusable location.

  There are several other places that config options can be specified,
  with each later location overriding any earlier options.
  Here are the places options can be specified in the order that they are checked:
   1. `./edq-canvas.json` -- If a `edq-canvas.json` exists in the current directory, it is loaded.
   2. `<platform-specific user config location>/edq-canvas.json` -- A directory which is considered the "proper" place to store user-related config for the platform you are using (according to [platformdirs](https://github.com/platformdirs/platformdirs)). Use `--help` to see the exact place in your specific case. This is a great place to store login credentials.
   3. Files specified by `--config` -- These files are loaded in the order they appear on the command-line.
   4. Bare Options -- Options specified directly like `--course` or `--token`. These will override all previous options.

  Using the default config file (`edq-canvas.json`):
  ```sh

  python3 -m canvas.cli.user.list
  ```

  Using a custom config file (`my_config.json`):
  ```sh

  python3 -m canvas.cli.user.list --config my_config.json
  ```

  A sample config file is provided in this repo at [sample-edq-canvas.json](./sample-edq-canvas.json).

  For brevity, all future commands in this document will assume that all standard config options are in the default
  config files (and thus will not need to be specified).





  When a user is required, tools and API functions accept a "user query" (unless specified).
  A user query is any object that can be used to uniquely identify a user.
  Valid user queries are:
   - Canvas User ID (as an integer or string of digits)
   - Email
   - Full Name
   - "email (id)" where "email" is an email and "id" is a Canvas ID

  User queries must be unambiguous within the pool of possible users (e.g., students in a course).
  It is recommended to use an email or Canvas ID as a user query.
  Resolving a user query that is not a Canvas ID will take longer,
  because a list of users must be fetched from Canvas.



  When an assignment is required, tools and API functions accept an "assignment query" (unless specified).
  An assignment query is any object that can be used to uniquely identify an assignment.
  Valid assignment queries are:
   - Canvas Assignment ID (as an integer or string of digits)
   - Full Name
   - "name (id)" where "name" is a full assignment name and "id" is a Canvas ID

  Assignment queries must be unambiguous within the pool of possible assignments (e.g., assignments in a course).
  Resolving an assignment query that is not a Canvas ID will take longer,
  because a list of assignments must be fetched from Canvas.



  A "grouping", also called a "group set" or "group category" in Canvas,
  is a set of groups created for a specific purpose (like for a specific assignment).
  A grouping has a name and contains groups.
  A "group" is a collection of users (usually students).
  The hierarchy goes "grouping" -> "group" -> "user".

  When a group is required, tools and API functions accept a "group query" (unless specified).
  (All information about group queries also applies to grouping queries.)
  A group query is any object that can be used to uniquely identify a group.
  Valid group queries are:
   - Canvas Group ID (as an integer or string of digits)
   - Full Name
   - "name (id)" where "name" is a full group name and "id" is a Canvas ID

  Group queries must be unambiguous within the pool of possible groups (e.g., groups in a course).



  Most commands that list results can also output results into a tab-separated table (on stdout)
  using the `-t` / `--table` option.
  To skip the header row, you can use the `--skip-headers` option.



  All CLI tools can be invoked with `-h` / `--help` to see the full usage and all options.



  Course users can be listed using the `canvas.cli.user.list` tool.
  For example:
  ```
  python3 -m canvas.cli.user.list
  ```



  To fetch information about a single course user, use the `canvas.cli.user.fetch` tool.
  For example:
  ```
  python3 -m canvas.cli.user.fetch 12345


  python3 -m canvas.cli.user.fetch alice@uni.edu
  ```



  Course assignments can be listed using the `canvas.cli.assignment.list` tool.
  For example:
  ```
  python3 -m canvas.cli.assignment.list
  ```



  Fetch information about a single assignment using the `canvas.cli.assignment.fetch` tool.
  For example:
  ```
  python3 -m canvas.cli.assignment.fetch 123456


  python3 -m canvas.cli.assignment.fetch 'My Assignment'
  ```



  To fetch the scores for a specific assignment, use the `canvas.cli.assignment.fetch-scores` tool.
  For example:
  ```
  python3 -m canvas.cli.assignment.fetch-scores 123456


  python3 -m canvas.cli.assignment.fetch-scores 'My Assignment'
  ```

  The student's email and score will be written to stdout as a tab-separated row.



  To fetch the files students have submitted for an assignment, use the `canvas.cli.assignment.fetch-submission-files` tool.
  For example:
  ```
  python3 -m canvas.cli.assignment.fetch-submission-files 123456


  python3 -m canvas.cli.assignment.fetch-submission-files 'My Assignment'
  ```

  Only assignment with a submission type of "Online - Text Entry" or "Online - File Uploads" will be downloaded.

  By default, files will be written to the `out` directory.
  This can be controlled with the `--out-dir` argument.



  Uploading scores for an assignment can be done with the `canvas.cli.assignment.upload-scores` tool:
  ```
  python3 -m canvas.cli.assignment.upload-scores <assignment query> <path>
  ```

  Where `<path>` points to a tab-separated file where each row has 2-3 columns: email, score, and comment (optional).
  Each row does not need to have the same length (i.e., some rows can have comments where others do not).
  Empty comments are ignored.

  The `--skip-rows` argument can be used to skip a specified number of header rows.
  For example:
  ```
  python3 -m canvas.cli.assignment.upload-scores 'My Assignment' grades.txt --skip-rows 1
  ```

  Where `grades.txt` looks like:
  ```
  user	score	comment?
  1001	75
  alice@uni.edu	100	Great Job!
  ```



  To upload just one assignment score without a file, you can use the `canvas.cli.assignment.upload-score` tool:
  ```
  python3 -m canvas.cli.assignment.upload-score <assignment query> <user query> <score> [comment]
  ```

  Note that the comment is optional.

  For example:
  ```
  python3 -m canvas.cli.assignment.upload-score 'My Assignment' alice@uni.edu 100 'Great Job!'
  ```



  To fetch the full gradebook for a course, use the `canvas.cli.gradebook.fetch` tool.
  For example:
  ```
  python3 -m canvas.cli.gradebook.fetch
  ```

  A gradebook will be written to stdout as a tab-separated file.
  To output the gradebook to a file, you can redirect stdout to a file.
  Expect this command to take a few minutes for larger classes.

  You can limit to gradebook to only specific students by specifying their IDs on the command line.
  Any number of students can be specified.
  ```
  python3 -m canvas.cli.gradebook.fetch 12345 67890
  ```

  By default, assignments and users without submissions will be pruned.
  They can be included by using the respective `--include-empty-assignments` and `--include-empty-users` flags.

  For example, you can write a gradebook with all assignments and users to `grades.txt` using the following command:
  ```
  python3 -m canvas.cli.gradebook.fetch --include-empty-assignments --include-empty-users > grades.txt
  ```



  To upload a gradebook, use the `canvas.cli.gradebook.upload` tool:
  ```
  python3 -m canvas.cli.gradebook.upload <path>
  ```

  Where `<path>` points to a gradebook file that has the same format as the output from `canvas.cli.gradebook.fetch`:
  a tab-separated file with users down the rows and assignments along the columns.
  The first column is user queries where the first cell is ignored,
  the first row is assignment queries where the first cell is ignored,
  and the remaining cells are the associated scores.
  Any number of users and assignments can be specified as long as they exist in the course.
  Empty cells will not be uploaded.

  A gradebook file can look like:
  ```
  user	98765	Assignment 2
  1001	1	2
  alice@uni.edu	3
  ```



  Groups in a course can be listed using the `canvas.cli.group.list-groupings` tool.
  For example:
  ```
  python3 -m canvas.cli.group.list-groupings
  ```

  Note that this lists the groupings themselves,
  not groups in the groupings or the users in those groups.



  To list the groups (not groupings) in a course, use the `canvas.cli.group.list-groups` tool.
  For example:
  ```
  python3 -m canvas.cli.group.list-groups
  ```

  To limit the results based on grouping, provide a query for that grouping.
  For example:
  ```
  python3 -m canvas.cli.group.list-groups 12345


  python3 -m canvas.cli.group.list-groups 'My Grouping'
  ```



  To list the users inside each group within a grouping, use the `canvas.cli.group.list-grouping-membership` tool.
  For example:
  ```
  python3 -m canvas.cli.group.list-grouping-membership 12345


  python3 -m canvas.cli.group.list-grouping-membership 'My Grouping'
  ```



  To list the users inside a specific group (not a grouping), use the `canvas.cli.group.list-group-members` tool.
  For example:
  ```
  python3 -m canvas.cli.group.list-group-members 12345


  python3 -m canvas.cli.group.list-group-members 'My Group'
  ```

rpm_license:
  MIT License  Copyright (c) 2023 Eriq Augustine  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: 942d0b8056960b8c6c4336f32216076d9dd8fcfd20d3f69e757c9414c65de7c6
name: python-edq-quizcomp-simple-gui-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for edq-quizcomp-simple-gui
description: A simple and self-contained server and web GUI for the Quiz Generator.
url: https://github.com/edulinq/quizgen-simple-gui
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edq-quizcomp-simple-gui-0.0.3-1.src.rpm
location_href: Packages/python-edq-quizcomp-simple-gui-help-0.0.3-1.noarch.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Eriq Augustine  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: c46e1a5e92f65e3b82509db61cc95c0d40c6087bf58a9f34eaa8a94e37189c1d
name: python-edu-async-tasks-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for edu-async-tasks
url: https://pypi.org/project/edu-async-tasks/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edu-async-tasks-1.2.0-1.src.rpm
location_href: Packages/python-edu-async-tasks-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  $ python -m build && \
    twine check ./dist/* && \
    twine upload ./dist/* --repository-url=http://... -u user.name -p userpassword


  $ source deactivate
  $ pip install tox tox-docker==4.1.0
  $ tox


pkgId: b502b90233f5fca9c11ab8a0fb74a721d544263d82fd56986c16c0de2f8e580c
name: python-educhain-help
arch: noarch
version: 0.3.4
epoch: 0
release: 1
summary: Development documents and examples for educhain
url: https://github.com/satvik314/educhain
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-educhain-0.3.4-1.src.rpm
location_href: Packages/python-educhain-help-0.3.4-1.noarch.rpm
checksum_type: sha256
description:
  <img src="images/logo.svg" alt="Educhain Logo" align="right" height="80" width="80" />
  Made with ❤️ by Buildfastwithai
  [www.educhain.in](https://educhain.in)


pkgId: 3526b42aaafecaedfe078a6ae3ea8fdf88b4949a727188af96ac245f54eab174
name: python-edupsyadmin-help
arch: noarch
version: 1.0.0a0
epoch: 0
release: 1
summary: Development documents and examples for edupsyadmin
url: https://pypi.org/project/edupsyadmin/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edupsyadmin-1.0.0a0-1.src.rpm
location_href: Packages/python-edupsyadmin-help-1.0.0a0-1.noarch.rpm
checksum_type: sha256
description:
  edupsyadmin provides tools to help school psychologists with their
  documentation.



  Install with uv:

      $ uv tool install edupsyadmin

  Run the application:

      $ edupsyadmin --help



  Add a client interactively:

      $ edupsyadmin new_client

  Add a client to the database from a Webuntis csv export:

      $ edupsyadmin new_client --csv ./path/to/your/file.csv

  Change values for the database entry with `client_id=42`:

  ```
  edupsyadmin set_client 42 \
    "nachteilsausgleich=1" \
    "notenschutz=0" \
    "lrst_diagnosis_encr=iLst"
  ```

  Fill a PDF form for the database entry with `client_id=42`:

      $ edupsyadmin create_documentation 42 ./path/to/your/file.pdf



  Create the development enviroment:

      $ uv v
      $ uv pip install -e .

  Run the test suite:

      $ .venv/bin/python -m pytest -v test/

  Build documentation:

      $ .venv/bin/python -m sphinx -M html doc doc/_build



  This project is licensed under the terms of the MIT License. Portions of this
  project are derived from the python application project cookiecutter template
  by Michael Klatt, which is also licensed under the MIT license. See the
  LICENSE.txt file for details.


pkgId: 13a326140866381719ca34b9de0cba9b5266468719185e41da36272d75581723
name: python-edx-completion-help
arch: noarch
version: 4.7.8
epoch: 0
release: 1
summary: Development documents and examples for edx-completion
url: https://github.com/openedx/completion
rpm_license: AGPL 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edx-completion-4.7.8-1.src.rpm
location_href: Packages/python-edx-completion-help-4.7.8-1.noarch.rpm
checksum_type: sha256
description:
  Start by going through `the documentation`_ (generated from `/docs </docs/index.rst>`_).  If you need more help see below.
  License
  *******
  The code in this repository is licensed under version 3 of the AGPL unless
  otherwise noted.
  Please see `LICENSE <LICENSE>`_ for details.
  Contributing
  ************
  Contributions are very welcome.
  Please read `How To Contribute <https://openedx.org/r/how-to-contribute>`_ for details.
  This project is currently accepting all types of contributions, bug fixes,
  security fixes, maintenance work, or new features.  However, please make sure
  to have a discussion about your new feature idea with the maintainers prior to
  beginning development to maximize the chances of your change being accepted.
  You can start a conversation by creating a new issue on this repo summarizing
  your idea.
  The Open edX Code of Conduct
  ****************************
  All community members are expected to follow the `Open edX Code of Conduct`_.
  People
  ******
  The assigned maintainers for this component and other project details may be
  found in `Backstage`_. Backstage pulls this data from the ``catalog-info.yaml``
  file in this repo.
  Reporting Security Issues
  *************************
  Please do not report security issues in public. Please email security@openedx.org.


pkgId: 3bb7c145833f4780b9c6f2a984ab93fd9297f957d31c616d342ade6567879116
name: python-edx-enterprise-help
arch: noarch
version: 5.5.0
epoch: 0
release: 1
summary: Development documents and examples for edx-enterprise
url: https://github.com/openedx/edx-enterprise
rpm_license: AGPL 3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-edx-enterprise-5.5.0-1.src.rpm
location_href: Packages/python-edx-enterprise-help-5.5.0-1.noarch.rpm
checksum_type: sha256
description:
  The ``Open edx Enterprise Service`` app provides enterprise features to the Open
  edX platform.  The majority of these features are structured around the concept
  of an ``Enterprise Customer``, which is an organization or a group of people
  that "consumes" courses published on the Open edX platform.


pkgId: 3c2fcfea17c90c10c529f8affbea838341cb70376d928a9ac059034fd5d8b686
name: python-effectual-help
arch: noarch
version: 0.7.5
epoch: 0
release: 1
summary: Development documents and examples for effectual
url: https://github.com/effectualpy/effectual
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-effectual-0.7.5-1.src.rpm
location_href: Packages/python-effectual-help-0.7.5-1.noarch.rpm
checksum_type: sha256
description:
  */ɪˈfek.tʃu.əl/ meaning effective and successful*



  Sometimes you want a single portable python file without having to make a platform specific executable or a dependency-less .pyz! Basically me trying to make [Vite](https://vite.dev/) for python (badly) :(



  - The python package requires access to specific files like [CustomTkinter](https://github.com/TomSchimansky/CustomTkinter/wiki/Packaging#windows-pyinstaller-auto-py-to-exe) and [Pillow](https://python-pillow.org/)
  - Incredibly version specific code, for example something that won't run on a slightly different python version or operating system



  First make sure you have [uv installed](https://docs.astral.sh/uv/getting-started/installation/#installation-methods) and updated:

      uv self update

  Furthermore if you haven't already created a project run:

      uv init

  Then to install effectual run:

      uv add effectual --dev

  Finally add the following lines to your pyproject.toml and configure to your hearts desire

  ```TOML
  [tool.effectual]

  sourceDirectory = "./src/"
  outputDirectory =  "./dist/"
  outputFileName = "bundle.pyz"
  minification = true
  compressionLevel = 5
  ```

  Note you must have a \_\_main\_\_.py entrypoint for this to work



  If you want a simple minimal setup process then just use the [effectual-template](https://github.com/effectualpy/effectual-template)





  To bundle in dev mode use:

      uv run efec dev

  This is like what [esBuild](https://esbuild.github.io/) does for vite



  To build a distributable .pyz file run:

      uv run efec dist

  This is like what what [Rollup](https://rollupjs.org/) does for vite



  - [Treeshaking](https://webpack.js.org/guides/tree-shaking/)
  - Rewriting some time critical parts in Rust 🚀🦀
  - Cross platform compatibility
  - Plugin and loader system



  All contributions are welcome, I'm not the best in the world at project management but if you think you can add or improve anything please send over a pull request


pkgId: 10215e4ac14a5185e6ae5183ebe750130f2a4c8a15568881c0aa8972e97800b6
name: python-egamma-tnp-help
arch: noarch
version: 0.4.2
epoch: 0
release: 1
summary: Development documents and examples for egamma-tnp
url: https://github.com/iasonkrom/egamma-tnp
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-egamma-tnp-0.4.2-1.src.rpm
location_href: Packages/python-egamma-tnp-help-0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  [![ci](https://github.com/ikrommyd/egamma-tnp/actions/workflows/ci.yml/badge.svg)](https://github.com/ikrommyd/egamma-tnp/actions?query=workflow%3ACI%2FCD+event%3Aschedule+branch%3Amaster)
  [![PyPI Version](https://badge.fury.io/py/egamma-tnp.svg)](https://badge.fury.io/py/egamma-tnp)
  ![Downloads](https://img.shields.io/pypi/dm/egamma-tnp.svg)

  E/Gamma Tag & Probe framework using [coffea](https://github.com/CoffeaTeam/coffea).


pkgId: b18bbaa615d743a37dc0e76a22512f629bd79b909d8e69c0409ada99d4aa8183
name: python-egauge-python-help
arch: noarch
version: 0.9.3
epoch: 0
release: 1
summary: Development documents and examples for egauge-python
url: https://bitbucket.org/egauge/python/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-egauge-python-0.9.3-1.src.rpm
location_href: Packages/python-egauge-python-help-0.9.3-1.noarch.rpm
checksum_type: sha256
description:
  This repository is a collection of Python packages that have been
  released by eGauge Systems LLC as open source (MIT license).  These
  are released in the hope that they may be useful for other developers.
  Please see LICENSE for details.  eGauge Systems LLC reserves the
  rights to add, modify, or remove code from this repository or the
  entire repository without notice.



  To use module `egauge.pyside.terminal`, be sure to install the package
  with the `pyside` extra dependencies:

  ```sh
  pip install egauge-python[pyside]
  ```



  Example programs can be found in the `egauge.examples` module.  If you
  want to run these programs, ensure that all dependencies are installed
  by running the command:

  ```sh
  pip install egauge-python[examples]
  ```

  The following examples are available:

   * `test_capture`: Illustrates the use of the
     `egauge.webapi.device.Capture` class to capture waveform data.

   * `test_ctid_decoder`: Illustrates how the `egauge.ctid.Decoder` can be
     used to decode CTid information from a waveform.

   * `test_ctid`: Illustrates how the `egauge.webapi.device.CTidInfo`
      class can be used to control a meter to scan CTid information from
      a sensor, make the sensor blink the indicator LED, and so on.

   * `test_local`: Illustrates how the `egauge.webapi.device.Local`
     class can be used to fetch and display the locally acquired
     measurements of a meter.

   * `test_register`: Illustrates how the `egauge.webapi.device.Register`
     class can be used to fetch and display the register data of a
     meter.

  Before running these programs, set the following environment variables
  for your preferred test device:

   * `EGDEV`: URL of the test device (e.g., "http://eGaugeXXXXX.local" or
     "http://eGaugeXXXX.d.egauge.net")
   * `EGUSR`: Username to authenticate with (e.g., "owner")
   * `EGPWD`: Password to authenticate with (e.g., "super-secret-pw")

  For example, the test program that illustrates the use of the register
  data interface can be run with the command:

  ```
      python -m egauge.examples.test_register
  ```





  The classes in this module provide access to eGauge web services.  The
  APIs may be available on eGauge devices and/or as cloud-based web
  services.



  The classes in this module provide access to APIs implemented on
  eGauge devices.



  The classes in this module provide access to APIs implemented by
  eGauge cloud services.



  The classes in this module support manufacturing CTid® sensors.  CTid®
  is patented technology and shall be used in accordance with the
  licensing agreements governing its use.



  The classes in this module support QT6-based graphical
  user-interfaces.



  Source code should be formatted with `ruff format` using a maximum
  line-length of 79 characters.  The formatter can be installed with
  `pip install ruff`.

  Source code should be validated with `ruff check` and `pyright`.  The
  latter can be installed with `pip install pyright`.

  To do these things automatically before committing a change, install
  the pre-commit hooks with:

  ```sh
      pip install pre-commit
      pre-commit install
  ```


pkgId: f8142d391abb6e947397d098b75659d20d674d448eea704230b9df7e6cc84513
name: python-eggai-help
arch: noarch
version: 0.1.11
epoch: 0
release: 1
summary: Development documents and examples for eggai
url: https://eggai-tech.github.io/EggAI/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eggai-0.1.11-1.src.rpm
location_href: Packages/python-eggai-help-0.1.11-1.noarch.rpm
checksum_type: sha256
description:
  [![Python 3.x](https://img.shields.io/badge/python-3.x-blue?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/downloads/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green?style=for-the-badge&logo=opensourceinitiative&logoColor=white)](https://opensource.org/licenses/MIT)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen?style=for-the-badge&logo=github&logoColor=white)](https://github.com/eggai-tech/eggai/pulls)
  [![GitHub Issues](https://img.shields.io/github/issues/eggai-tech/eggai?style=for-the-badge&logo=github&logoColor=white)](https://github.com/eggai-tech/eggai/issues)
  [![GitHub Stars](https://img.shields.io/github/stars/eggai-tech/eggai?style=for-the-badge&logo=github&logoColor=white)](https://github.com/eggai-tech/eggai/stargazers)

  `EggAI Multi-Agent Framework` is an async-first framework for building, deploying, and scaling multi-agent systems for modern enterprise environments.



  [Features](#-features) •
  [Overview](#-overview) •
  [System Architecture](#-system-architecture) •
  [Installation](#-installation) •
  [Getting Started](#-getting-started) •
  [Core Concepts](#-core-concepts) •
  [Examples](#-examples) •
  [Contribution](#-contribution) •
  [License](#-license)

  <!--start-->


  - 🤖 **Agent Management**: Simplify the orchestration and execution of multi-agent systems.
  - 🚀 **Async-First**: Push-based APIs designed for high-concurrency, long-running and real-time processes.
  - ⚡ **Event-Driven**: Enable adaptive and responsive system behaviors triggered by real-time events.
  - 📈 **Horizontally Scalable**: Scale agent execution seamlessly to meet growing demands.
  - 🚇 **Kafka Integration**: Native support for Kafka topics ensures seamless streaming and messaging.
  - 🛠 **Flexible Architecture**: Easily adapt or extend components without disrupting workflows.
  - 🔄 **Resilient by Design**: Built-in retry mechanisms and fault tolerance for production-grade robustness.



  `EggAI Multi-Agent Framework` provides the `eggai` Python library that simplifies the development of multi-agent systems.
  It allows developers to focus on business logic while handling the complexities of distributed systems.



  ![System Architecture](./docs/assets/system-architecture.svg)

  1. **Human Interaction**:

     - Users interact with the system via various **Human Channels**, such as chat interfaces or APIs, which are routed through the **Gateway**.

  2. **Gateway**:

     - The Gateway acts as the entry point for all human communications and interfaces with the system to ensure secure and consistent message delivery.

  3. **Coordinator**:

     - The **Coordinator** is the central component that manages the communication between humans and specialized agents.
     - It determines which agent(s) to involve and facilitates the interaction through the **Agent Channels**.

  4. **Agents**:

     - The system is composed of multiple specialized agents (Agent 1, Agent 2, Agent 3), each responsible for handling specific types of tasks or functions.
     - Agents communicate with the Coordinator through their respective **Agent Channels**, ensuring scalability and modularity.

  5. **Agent and Human Channels**:
     - **Human Channels** connect the Gateway to humans for interaction.
     - **Agent Channels** connect the Coordinator to agents, enabling task-specific processing and delegation.



  Install `eggai` via pip:

  ```bash
  pip install eggai
  ```



  Here's how you can quickly set up an agent to handle events in an event-driven system:

  ```python
  import asyncio

  from eggai import Agent, Channel

  agent = Agent("OrderAgent")
  channel = Channel()

  @agent.subscribe(event_name="order_requested")
  async def handle_order_requested(event):
      print(f"[ORDER AGENT]: Received order request. Event: {event}")
      await channel.publish({"event_name": "order_created", "payload": event})

  @agent.subscribe(event_name="order_created")
  async def handle_order_created(event):
      print(f"[ORDER AGENT]: Order created. Event: {event}")

  async def main():
      await agent.run()
      await channel.publish({
          "event_name": "order_requested",
          "payload": {
              "product": "Laptop",
              "quantity": 1
          }
      })

      try:
          print("Agent is running. Press Ctrl+C to stop.")
          await asyncio.Event().wait()
      except asyncio.exceptions.CancelledError:
          print("Task was cancelled. Cleaning up...")
      finally:
          
          await agent.stop()
          await channel.stop()

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

  This code demonstrates how to define an `Agent` and use it to process events from Kafka topics.





  An `Agent` is an isolated unit of business logic designed to orchestrate workflows, process events, and communicate with external systems such as LLMs and APIs.
  It reduces boilerplate while supporting complex and long-running workflows. Key features include:

  - **Event Handling**: Use the `subscribe` decorator to bind user-defined handlers to specific events.
  - **Workflow Orchestration**: Manage long-running workflows and tasks efficiently.
  - **External System Communication**: Seamlessly interact with Large Language Models (LLMs), external APIs, and other systems.
  - **Lifecycle Management**: Automatically handle the lifecycle of Kafka consumers, producers, and other connected components.
  - **Boilerplate Reduction**: Focus on core business logic while leveraging built-in integrations for messaging and workflows.



  A `Channel` is the foundational communication layer that facilitates both event publishing and subscription.
  It abstracts Kafka producers and consumers, enabling efficient and flexible event-driven operations. Key features include:

  - **Event Communication**: Publish events to Kafka topics with ease.
  - **Event Subscription**: Subscribe to Kafka topics and process events directly through the `Channel`.
  - **Shared Resources**: Optimize resource usage by managing singleton Kafka producers and consumers across multiple agents or channels.
  - **Seamless Integration**: Act as a communication hub, supporting both Agents and other system components.
  - **Flexibility**: Allow Agents to leverage Channels for both publishing and subscribing, reducing complexity and duplication.


  <!--end-->


  For detailed examples, please refer to [examples](examples).



  `EggAI Multi-Agent Framework` is open-source and we welcome contributions. If you're looking to contribute, please refer to [CONTRIBUTING.md](CONTRIBUTING.md).



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


pkgId: 32aba06f718c9e74aa1618c74e5824623efa4f05e73421df3c5ceb61af180930
name: python-eh-tabular-deepchecks-help
arch: noarch
version: 0.0.4b0
epoch: 0
release: 1
summary: Development documents and examples for eh-tabular-deepchecks
url: https://github.com/DanielAvdar/deepchecks
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eh-tabular-deepchecks-0.0.4b0-1.src.rpm
location_href: Packages/python-eh-tabular-deepchecks-help-0.0.4b0-1.noarch.rpm
checksum_type: sha256
description:
  <!--
     ~ ----------------------------------------------------------------------------
     ~ Copyright (C) 2021-2023 Deepchecks (https://www.deepchecks.com)
     ~
     ~ This file is part of Deepchecks.
     ~ Deepchecks is distributed under the terms of the GNU Affero General
     ~ Public License (version 3 or later).
     ~ You should have received a copy of the GNU Affero General Public License
     ~ along with Deepchecks.  If not, see <http://www.gnu.org/licenses/>.
     ~ ----------------------------------------------------------------------------
     ~
  -->
  this is modified version of deepchecks.
  the purpose of this version is to maintain & distribute limited version of deepchecks for tabular data.
  (https://www.deepchecks.com)


pkgId: 1b613940cd4e4666aa0fbbdd24dad18ffe460264c09d709c942e2e0707344f54
name: python-ehtim-help
arch: noarch
version: 1.2.9
epoch: 0
release: 1
summary: Development documents and examples for ehtim
url: https://github.com/achael/eht-imaging
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ehtim-1.2.9-1.src.rpm
location_href: Packages/python-ehtim-help-1.2.9-1.noarch.rpm
checksum_type: sha256
description:
  Python modules for simulating and manipulating VLBI data and producing images with regularized maximum likelihood methods. This version is an early release so please raise an issue, submit a pull request, or email achael@princeton.edu if you have trouble or need help for your application.
  The package contains several primary classes for loading, simulating, and manipulating VLBI data. The main classes are the ``Image``, ``Movie``, ``Array``, ``Obsdata``, ``Imager``, and ``Caltable`` classes, which provide tools for loading images and data, producing simulated data from realistic u-v tracks,  calibrating, inspecting, and  plotting data, and producing images from data sets in various polarizations using various data terms and regularizing functions.


pkgId: 4fcdf4a1d45291cb14c8f9fa9e098148c2d75c310dcf93deed411376ba3f7fc2
name: python-eia-bulk-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for eia-bulk
url: https://github.com/CasFre4/EIA-bulk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eia-bulk-0.1.1-1.src.rpm
location_href: Packages/python-eia-bulk-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  **EIA Bulk Data Collector** is a Python library designed to interact with the U.S. Energy Information Administration (EIA) API to collect bulk energy-related data for analysis and research purposes. This library simplifies the process of fetching, organizing, and processing large datasets from the EIA API.



  - Collect bulk data from the EIA API
  - Automatically handle API requests and rate limits
  - Parse and store data in JSON(limited), DataFrames, Databases.
  - Support for all publicly available EIA data. More information about the EIA API found here: [https://www.eia.gov](https://www.eia.gov/opendata/).
  - Easy-to-use interface for querying and downloading data
  - Extensive error catching for ease of use.



  You can install the `eia-bulk` package using `pip`:

  ```bash
  pip install eia-bulk
  ```



  To interact with the EIA API, you will need an API key. You can obtain an API key from the EIA website.

  Once you have your API key, store it in a .env file in your project directory:
  ```make
  EIA_KEY=your_api_key_here
  HOST=db_host_here
  DBNAME=db_name_here
  USERNAME=db_username_here
  PASSWORD=db_password_here
  TABLENAME=db_tablename_here
  ```

  ```python
  from eia import EIABulk as ebulk
  ```


  Example with
  ```python
    eia = ebulk(write2db=False, route='electricity/rto/fuel-type-data', from_api=True, verbose=2)
    print(eia)
  ```
  <details>
  <summary>Click to view output.</summary>

  ```json
  {
    "response": {
      "id": "fuel-type-data",
      "name": "Hourly Generation by Energy Source",
      "description": "Hourly net generation by balancing authority and energy source.
      Source: Form EIA-930
      Product: Hourly Electric Grid Monitor",
      "frequency": [
        {
          "id": "hourly",
          "alias": "hourly (UTC)",
          "description": "One data point for each hour in UTC time.",
          "query": "H",
          "format": "YYYY-MM-DD\"T\"HH24"
        },
        {
          "id": "local-hourly",
          "alias": "hourly (Local Time Zone)",
          "description": "One data point for each hour in local time.",
          "query": "LH",
          "format": "YYYY-MM-DD\"T\"HH24TZH"
        }
      ],
      "facets": [
        {
          "id": "respondent",
          "description": "Balancing Authority / Region"
        },
        {
          "id": "fueltype",
          "description": "Energy Source"
        }
      ],
      "data": {
        "value": {
          "aggregation-method": "SUM",
          "alias": "Net Generation",
          "units": "megawatthours"
        }
      },
      "startPeriod": "2019-01-01T00",
      "endPeriod": "2024-12-16T06",
      "defaultDateFormat": "YYYY-MM-DD\"T\"HH24",
      "defaultFrequency": "hourly"
    },
    "request": {
      "command": "/v2/electricity/rto/fuel-type-data/",
      "params": {
        "api_key": "api_key_here_1234567890"
      }
    },
    "apiVersion": "2.1.8",
    "ExcelAddInVersion": "2.1.0"
  }
  ```
  </details>

  ```python
    eia = ebulk(write2db=False, route='electricity/rto', facet_types=[('respondent', 'US48')], frequency='hourly', data_types=['value'], override=True, verbose=2, from_api=False)
    print(eia)
   ```
  <details>
  <summary>Click to view output.</summary>

  ```json
  {
    "region-data": {
      "facets": {
        "respondent": [
          "GWA",
          "TEX",
          "BANC",
          "GVL",
          "FPL",
          "..."
        ],
        "type": [
          "CO2.IMPR",
          "CO2.EM",
          "TI",
          "CO2.EXPR",
          "NG",
          "..."
        ]
      },
      "frequency": [
        "hourly",
        "local-hourly"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "respondent",
        "type",
        "value"
      ]
    },
    "fuel-type-data": {
      "facets": {
        "respondent": [
          "CAR",
          "CAL",
          "NYIS",
          "NWMT",
          "PSEI",
          "..."
        ],
        "fueltype": [
          "UES",
          "PS",
          "NG",
          "OTH",
          "WND",
          "..."
        ]
      },
      "frequency": [
        "hourly",
        "local-hourly"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "respondent",
        "fueltype",
        "value"
      ]
    },
    "region-sub-ba-data": {
      "facets": {
        "subba": [
          "SPRM",
          "VEA",
          "PS",
          "4001",
          "4007",
          "..."
        ],
        "parent": [
          "PJM",
          "NYIS",
          "MISO",
          "SWPP",
          "CISO",
          "..."
        ]
      },
      "frequency": [
        "hourly",
        "local-hourly"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "subba",
        "parent",
        "value"
      ]
    },
    "interchange-data": {
      "facets": {
        "fromba": [
          "CAL",
          "GVL",
          "FPL",
          "TEX",
          "PJM",
          "..."
        ],
        "toba": [
          "IESO",
          "FPL",
          "GVL",
          "TEX",
          "PJM",
          "..."
        ]
      },
      "frequency": [
        "hourly",
        "local-hourly"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "fromba",
        "toba",
        "value"
      ]
    },
    "daily-region-data": {
      "facets": {
        "respondent": [
          "PJM",
          "FPL",
          "NY",
          "TEX",
          "EPE",
          "..."
        ],
        "type": [
          "NG",
          "CO2.IMPR",
          "CO2.CON",
          "CO2.EM",
          "CO2.GER",
          "..."
        ],
        "timezone": [
          "Eastern",
          "Mountain",
          "Central",
          "Pacific",
          "Arizona"
        ]
      },
      "frequency": [
        "daily"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "respondent",
        "type",
        "timezone",
        "value"
      ]
    },
    "daily-region-sub-ba-data": {
      "facets": {
        "subba": [
          "4001",
          "4003",
          "4005",
          "4006",
          "4008",
          "..."
        ],
        "parent": [
          "PJM",
          "MISO",
          "SWPP",
          "ISNE",
          "ERCO",
          "..."
        ],
        "timezone": [
          "Pacific",
          "Central",
          "Mountain",
          "Eastern",
          "Arizona"
        ]
      },
      "frequency": [
        "daily"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "subba",
        "parent",
        "timezone",
        "value"
      ]
    },
    "daily-fuel-type-data": {
      "facets": {
        "respondent": [
          "BANC",
          "FPL",
          "CAL",
          "PJM",
          "WWA",
          "..."
        ],
        "fueltype": [
          "UES",
          "PS",
          "NG",
          "NUC",
          "OTH",
          "..."
        ],
        "timezone": [
          "Mountain",
          "Central",
          "Arizona",
          "Eastern",
          "Pacific"
        ]
      },
      "frequency": [
        "daily"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "respondent",
        "fueltype",
        "timezone",
        "value"
      ]
    },
    "daily-interchange-data": {
      "facets": {
        "fromba": [
          "FPL",
          "GVL",
          "GWA",
          "TEX",
          "PJM",
          "..."
        ],
        "toba": [
          "CEN",
          "BANC",
          "FPL",
          "GVL",
          "GWA",
          "..."
        ],
        "timezone": [
          "Central",
          "Pacific",
          "Arizona",
          "Mountain",
          "Eastern"
        ]
      },
      "frequency": [
        "daily"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "fromba",
        "toba",
        "timezone",
        "value"
      ]
    },
    "emissions-data-by-fuel-type": {
      "facets": {
        "respondent": [
          "SPA",
          "IPCO",
          "NW",
          "MISO",
          "SOCO",
          "..."
        ],
        "datatype": [
          "CO2.EM"
        ],
        "fueltype": [
          "OTH",
          "OIL",
          "NG",
          "COL"
        ]
      },
      "frequency": [
        "hourly",
        "local-hourly"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "respondent",
        "datatype",
        "fueltype",
        "value"
      ]
    },
    "daily-emissions-by-fuel-type-data": {
      "facets": {
        "respondent": [
          "GVL",
          "FMPP",
          "CENT",
          "SWPP",
          "IPCO",
          "..."
        ],
        "datatype": [
          "CO2.EM"
        ],
        "fueltype": [
          "COL",
          "OTH",
          "OIL",
          "NG"
        ],
        "timezone": [
          "Central",
          "Eastern",
          "Pacific",
          "Mountain",
          "Arizona"
        ]
      },
      "frequency": [
        "daily"
      ],
      "data": [
        "value"
      ],
      "sort_by": [
        "period",
        "respondent",
        "datatype",
        "fueltype",
        "timezone",
        "..."
      ]
    }
  }
  ```

  </details>

  ```python
  response = ebulk(write2db=False, route='electricity/rto/fuel-type-data', facet_types=[('respondent', 'US48')], frequency='hourly', data_types=['value'], override=True, verbose=2, from_api=False).route_endpoints()
  print(response)
  ```
  <details>
  <summary>Click to view output.</summary>

  ```json
  The following are the potential routes/features one can pick from given endpoint: electricity/rto/fuel-type-data
  {
    "frequency": [
      "hourly",
      "local-hourly"
    ],
    "data": [
      "value"
    ],
    "facets": {
      "respondent": [
        "CAR",
        "CAL",
        "NYIS",
        "NWMT",
        "PSEI",
        "NY",
        "FMPP",
        "MIDA",
        "GVL",
        "TEPC",
        "LDWP",
        "SCEG",
        "CISO",
        "NEVP",
        "DUK",
        "SC",
        "WAUW",
        "GCPD",
        "IID",
        "PSCO",
        "SW",
        "JEA",
        "PNM",
        "PACE",
        "TVA",
        "FPL",
        "US48",
        "TIDC",
        "MISO",
        "CENT",
        "ERCO",
        "NE",
        "TEC",
        "PGE",
        "HST",
        "BANC",
        "TPWR",
        "PJM",
        "WALC",
        "PACW",
        "CHPD",
        "YAD",
        "EPE",
        "SEC",
        "DEAA",
        "FPC",
        "AVRN",
        "ISNE",
        "NW",
        "SWPP",
        "WWA",
        "FLA",
        "WACM",
        "CPLE",
        "MIDW",
        "GRID",
        "AECI",
        "SEPA",
        "TEN",
        "AVA",
        "TEX",
        "AZPS",
        "IPCO",
        "SPA",
        "AEC",
        "SE",
        "CPLW",
        "TAL",
        "GRIF",
        "SCL",
        "HGMA",
        "EEI",
        "GLHB",
        "SRP",
        "DOPD",
        "BPAT",
        "LGEE",
        "GWA",
        "NSB",
        "SOCO"
      ],
      "fueltype": [
        "UES",
        "PS",
        "NG",
        "OTH",
        "WND",
        "NUC",
        "BAT",
        "SUN",
        "OIL",
        "UES",
        "SNB",
        "WAT",
        "BAT",
        "COL",
        "UNK",
        "SNB",
        "PS"
      ]
    },
    "sort_by": [
      "period",
      "respondent",
      "fueltype",
      "value"
    ]
  }
  ```
  </details>


  ```python
  eia = ebulk(write2db=False, route='electricity/rto/fuel-type-data', frequency='hourly', facet_types = ('respondent', 'US48'), data_types='value', override=True, verbose=2, multiplier=1/2)
  for df in eia.collect_months_data(2019, [1,2]):
      print(df.head(25).to_string(index=False))
  ```
  <details>
  <summary>Click to view output.</summary>

  ```json
  Collecting from 2019-01-01 to 2019-01-16
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-01-01T00&end=2019-01-16T00&offset=0&length=5000&api_key=api_key_here_1234567890
  Collecting from 2019-01-16 to 2019-02-01
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-01-16T00&end=2019-02-01T00&offset=0&length=5000&api_key=api_key_here_1234567890
  Collecting from 2019-02-01 to 2019-02-15
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-02-01T00&end=2019-02-15T00&offset=0&length=5000&api_key=api_key_here_1234567890
  Collecting from 2019-02-15 to 2019-03-01
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-02-15T00&end=2019-03-01T00&offset=0&length=5000&api_key=api_key_here_1234567890
  ```
  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>period</th>
        <th>respondent</th>
        <th>respondent-name</th>
        <th>fueltype</th>
        <th>type-name</th>
        <th>value</th>
        <th>value-units</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>151102</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>171401</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NUC</td>
        <td>Nuclear</td>
        <td>103615</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OIL</td>
        <td>Petroleum</td>
        <td>363</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OTH</td>
        <td>Other</td>
        <td>9439</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>1424</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WAT</td>
        <td>Hydro</td>
        <td>41590</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WND</td>
        <td>Wind</td>
        <td>24323</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>146397</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>165141</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NUC</td>
        <td>Nuclear</td>
        <td>103696</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OIL</td>
        <td>Petroleum</td>
        <td>370</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OTH</td>
        <td>Other</td>
        <td>9250</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>3577</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WAT</td>
        <td>Hydro</td>
        <td>37472</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WND</td>
        <td>Wind</td>
        <td>23474</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>141832</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>158337</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NUC</td>
        <td>Nuclear</td>
        <td>103679</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OIL</td>
        <td>Petroleum</td>
        <td>362</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OTH</td>
        <td>Other</td>
        <td>9119</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>5945</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WAT</td>
        <td>Hydro</td>
        <td>35440</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WND</td>
        <td>Wind</td>
        <td>23511</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T21</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>140873</td>
        <td>megawatthours</td>
      </tr>
    </tbody>
  </table>
  </details>

  ```python
  eia = ebulk(write2db=False, route='electricity/operating-generator-capacity', facet_types=[('balancing_authority_code', 'CPLE'),('balancing_authority_code', 'AEC')], data_types=['nameplate-capacity-mw'], override=True, verbose=0, multiplier=4)

  for df in eia.collect_years_data(start_year=2019, end_year=2020):
      print(df.head(25).to_string(index=False))
  ```
  <details>
  <summary>Click to view output.</summary>

  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>period</th>
        <th>stateid</th>
        <th>stateName</th>
        <th>sector</th>
        <th>sectorName</th>
        <th>entityid</th>
        <th>entityName</th>
        <th>plantid</th>
        <th>plantName</th>
        <th>generatorid</th>
        <th>technology</th>
        <th>energy_source_code</th>
        <th>energy-source-desc</th>
        <th>prime_mover_code</th>
        <th>balancing_authority_code</th>
        <th>balancing-authority-name</th>
        <th>status</th>
        <th>statusDescription</th>
        <th>nameplate-capacity-mw</th>
        <th>unit</th>
        <th>nameplate-capacity-mw-units</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-non-chp</td>
        <td>IPP Non-CHP</td>
        <td>58921</td>
        <td>Bailey Farm LLC</td>
        <td>59127</td>
        <td>Bailey Farm LLC</td>
        <td>1</td>
        <td>Solar Photovoltaic</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>PV</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>58536</td>
        <td>Smithfield Packaged Meats Corp</td>
        <td>58575</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>4</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>2.3</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-chp</td>
        <td>IPP CHP</td>
        <td>18065</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>56035</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>1</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.4</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-chp</td>
        <td>IPP CHP</td>
        <td>18065</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>56035</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>2</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.4</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-non-chp</td>
        <td>IPP Non-CHP</td>
        <td>58927</td>
        <td>Snow Hill Solar 2 LLC</td>
        <td>59106</td>
        <td>Snow Hill Solar 2 LLC</td>
        <td>1</td>
        <td>Solar Photovoltaic</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>PV</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>2</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN2</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN3</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN4</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN5</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN6</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN7</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN8</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN9</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN10</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN11</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-04</td>
        <td>SC</td>
        <td>South Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>50006</td>
        <td>Invista</td>
        <td>10795</td>
        <td>Camden South Carolina</td>
        <td>GEN1</td>
        <td>Natural Gas Steam Turbine</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>5.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GEN8</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GEN9</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GN10</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GN11</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN12</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN13</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN14</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN15</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN16</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
    </tbody>
  </table>
  </details>


  ```python
  eia = ebulk(write2db=True, route='electricity/rto/fuel-type-data', frequency='hourly', facet_types = ('respondent', 'US48'), data_types='value', override=True, verbose=2, multiplier=1/2)
  for df in eia.collect_months_data(2019, [1,2]):
      print(df.head(25).to_string(index=False))
  ```
  <details>
  <summary>Click to view output.</summary>

  ```json
  Collecting from 2019-01-01 to 2019-01-16
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-01-01T00&end=2019-01-16T00&offset=0&length=5000&api_key=api_key_here_1234567890
  Collecting from 2019-01-16 to 2019-02-01
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-01-16T00&end=2019-02-01T00&offset=0&length=5000&api_key=api_key_here_1234567890
  Collecting from 2019-02-01 to 2019-02-15
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-02-01T00&end=2019-02-15T00&offset=0&length=5000&api_key=api_key_here_1234567890
  Collecting from 2019-02-15 to 2019-03-01
  API URL:https://api.eia.gov/v2/electricity/rto/fuel-type-data/data/?frequency=hourly&data[0]=value&facets[respondent][]=US48&start=2019-02-15T00&end=2019-03-01T00&offset=0&length=5000&api_key=api_key_here_1234567890
  ```
  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>period</th>
        <th>respondent</th>
        <th>respondent-name</th>
        <th>fueltype</th>
        <th>type-name</th>
        <th>value</th>
        <th>value-units</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>151102</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>171401</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NUC</td>
        <td>Nuclear</td>
        <td>103615</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OIL</td>
        <td>Petroleum</td>
        <td>363</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OTH</td>
        <td>Other</td>
        <td>9439</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>1424</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WAT</td>
        <td>Hydro</td>
        <td>41590</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-16T00</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WND</td>
        <td>Wind</td>
        <td>24323</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>146397</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>165141</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NUC</td>
        <td>Nuclear</td>
        <td>103696</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OIL</td>
        <td>Petroleum</td>
        <td>370</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OTH</td>
        <td>Other</td>
        <td>9250</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>3577</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WAT</td>
        <td>Hydro</td>
        <td>37472</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T23</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WND</td>
        <td>Wind</td>
        <td>23474</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>141832</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>158337</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>NUC</td>
        <td>Nuclear</td>
        <td>103679</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OIL</td>
        <td>Petroleum</td>
        <td>362</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>OTH</td>
        <td>Other</td>
        <td>9119</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>5945</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WAT</td>
        <td>Hydro</td>
        <td>35440</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T22</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>WND</td>
        <td>Wind</td>
        <td>23511</td>
        <td>megawatthours</td>
      </tr>
      <tr>
        <td>2019-01-15T21</td>
        <td>US48</td>
        <td>United States Lower 48</td>
        <td>COL</td>
        <td>Coal</td>
        <td>140873</td>
        <td>megawatthours</td>
      </tr>
    </tbody>
  </table>
  </details>

  ```python
  eia = ebulk(route='electricity/operating-generator-capacity', facet_types=[('balancing_authority_code', 'CPLE'),('balancing_authority_code', 'AEC')], data_types=['nameplate-capacity-mw'], override=True, verbose=0, multiplier=4)

  for df in eia.collect_years_data(start_year=2019, end_year=2020):
      print(df.head(25).to_string(index=False))
  ```
  <details>
  <summary>Click to view output.</summary>

  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th>period</th>
        <th>stateid</th>
        <th>stateName</th>
        <th>sector</th>
        <th>sectorName</th>
        <th>entityid</th>
        <th>entityName</th>
        <th>plantid</th>
        <th>plantName</th>
        <th>generatorid</th>
        <th>technology</th>
        <th>energy_source_code</th>
        <th>energy-source-desc</th>
        <th>prime_mover_code</th>
        <th>balancing_authority_code</th>
        <th>balancing-authority-name</th>
        <th>status</th>
        <th>statusDescription</th>
        <th>nameplate-capacity-mw</th>
        <th>unit</th>
        <th>nameplate-capacity-mw-units</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-non-chp</td>
        <td>IPP Non-CHP</td>
        <td>58921</td>
        <td>Bailey Farm LLC</td>
        <td>59127</td>
        <td>Bailey Farm LLC</td>
        <td>1</td>
        <td>Solar Photovoltaic</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>PV</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>58536</td>
        <td>Smithfield Packaged Meats Corp</td>
        <td>58575</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>4</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>2.3</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-chp</td>
        <td>IPP CHP</td>
        <td>18065</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>56035</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>1</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.4</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-chp</td>
        <td>IPP CHP</td>
        <td>18065</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>56035</td>
        <td>Smithfield Packaged Meats Corp.</td>
        <td>2</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.4</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-01</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>ipp-non-chp</td>
        <td>IPP Non-CHP</td>
        <td>58927</td>
        <td>Snow Hill Solar 2 LLC</td>
        <td>59106</td>
        <td>Snow Hill Solar 2 LLC</td>
        <td>1</td>
        <td>Solar Photovoltaic</td>
        <td>SUN</td>
        <td>Solar</td>
        <td>PV</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>2</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN2</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN3</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN4</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN5</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN6</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN7</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN8</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GEN9</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN10</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN11</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-04</td>
        <td>SC</td>
        <td>South Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>50006</td>
        <td>Invista</td>
        <td>10795</td>
        <td>Camden South Carolina</td>
        <td>GEN1</td>
        <td>Natural Gas Steam Turbine</td>
        <td>NG</td>
        <td>Natural Gas</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>5.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GEN8</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GEN9</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GN10</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-02</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-chp</td>
        <td>Industrial CHP</td>
        <td>23815</td>
        <td>Blue Ridge Paper Products Inc</td>
        <td>50244</td>
        <td>Canton North Carolina</td>
        <td>GN11</td>
        <td>Conventional Steam Coal</td>
        <td>BIT</td>
        <td>Bituminous Coal</td>
        <td>ST</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>OP</td>
        <td>Operating</td>
        <td>7.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN12</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN13</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN14</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN15</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
      <tr>
        <td>2019-05</td>
        <td>NC</td>
        <td>North Carolina</td>
        <td>industrial-non-chp</td>
        <td>Industrial Non-CHP</td>
        <td>17449</td>
        <td>Smithfield Fresh Meats Corp.</td>
        <td>54823</td>
        <td>Smithfield Farmland Corp Bladen</td>
        <td>GN16</td>
        <td>Petroleum Liquids</td>
        <td>DFO</td>
        <td>Disillate Fuel Oil</td>
        <td>IC</td>
        <td>CPLE</td>
        <td>Duke Energy Progress East</td>
        <td>SB</td>
        <td>Standby/Backup: available for service but not normally used</td>
        <td>1.5</td>
        <td>None</td>
        <td>MW</td>
      </tr>
    </tbody>
  </table>

  </details>



  api_key: Stores the EIA API authentication key
  route: Constructed API route for data retrieval
  facets: Filtered categories or facets
  data: Specific data types to retrieve
  frequency: Data frequency (hourly, daily, monthly, etc.)
  write2db: Boolean to determine if data should be written to database
  verbose: Controls the level of logging and output
  multiplier: Adjusts time range for data retrieval based on frequency




  Provides information about available routes, facets, and data types
  Can fetch information from API or from local route tree
  Purpose: Explore and understand available API endpoints

  Other Relevant Variables:

  from_api(Default True): If True retrieves infromation from the API, if false retrieves data from one of the tree json files.




  Retrieves data from the EIA API for a specified date range
  Parameters:

  start: Start date for data retrieval
  end: End date for data retrieval
  as_df: Whether to return data as a pandas DataFrame

  Purpose: Fetch data from EIA API with flexible output options




  Collects data for a specific year, typically for hourly or daily frequencies
  Parameters:

  year: Year to collect data for
  engine: Database connection engine
  months(Optional): specific months to collect

  Purpose: Retrieve and optionally store small-granularity time series data




  Collects data for larger time frequencies (monthly, quarterly, yearly)
  Parameters:
  the_range: Range of years to collect
  engine: Database connection engine

  Purpose: Retrieve and store data for less frequent time series




  Flexible method to collect data across multiple years
  Can specify exact years or a range
  Handles different data frequencies
  Purpose: Comprehensive data collection across multiple years




  Updates the internal route and API structure information
  Builds a comprehensive dictionary of available API routes, facets, and data types
  Purpose: Maintain an up-to-date understanding of the EIA API structure




  Builds the URL for API data retrieval
  Incorporates route, frequency, data types, facets, and date range
  Purpose: Construct precise API request URLs



  Purpose: Collects the data for exactly one month generally with smaller time frequencies.



  Parameters:

  dates: list or touple that contains two date strings

  Purpose: Collects larger time frequency data within the given date range.


