# packages

pkgId: 4a0bab7ed9f8e7a1681b6777826601fcaca165ce8bd347983f2a44ce9fe1fec3
name: python-eitprocessing-help
arch: noarch
version: 1.4.8
epoch: 0
release: 1
summary: Development documents and examples for eitprocessing
url: https://pypi.org/project/eitprocessing/
rpm_license: Apache-2.0 license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eitprocessing-1.4.8-1.src.rpm
location_href: Packages/python-eitprocessing-help-1.4.8-1.noarch.rpm
checksum_type: sha256
description:
  | Badges         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
  | :------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | Registry       | [![RSD](https://img.shields.io/badge/rsd-eitprocessing-00a3e3.svg)](https://www.research-software.nl/software/eitprocessing) [![workflow pypi badge](https://img.shields.io/pypi/v/eitprocessing.svg?colorB=blue)](https://pypi.python.org/project/eitprocessing/) [![github repo badge](https://img.shields.io/badge/github-repo-000.svg?logo=github&labelColor=gray&color=blue)](git@github.com:EIT-ALIVE/eitprocessing)                                                                                                                                                 |
  | License        | [![github license badge](https://img.shields.io/github/license/EIT-ALIVE/eitprocessing)](git@github.com:EIT-ALIVE/eitprocessing)                                                                                                                                                                                                                                                                                                                                                                                                                                           |
  | Citation       | [![DOI](https://zenodo.org/badge/617944717.svg)](https://zenodo.org/badge/latestdoi/617944717)                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | Fairness       | [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/9147/badge)](https://www.bestpractices.dev/projects/9147) [![fair-software badge](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B-yellow)](https://fair-software.eu)                                                                                                                                                                                                                                                                |
  | GitHub Actions | ![build](https://github.com/EIT-ALIVE/eitprocessing/actions/workflows/build.yml/badge.svg) ![lint](https://github.com/EIT-ALIVE/eitprocessing/actions/workflows/lint.yml/badge.svg) ![documentation](https://github.com/EIT-ALIVE/eitprocessing/actions/workflows/documentation.yml/badge.svg) ![cffconvert](https://github.com/EIT-ALIVE/eitprocessing/actions/workflows/cffconvert.yml/badge.svg) [![Coverage Status](https://coveralls.io/repos/github/EIT-ALIVE/eitprocessing/badge.svg?branch=main)](https://coveralls.io/github/EIT-ALIVE/eitprocessing?branch=main) |
  | Python         | ![Python](https://img.shields.io/badge/python-3.10-blue.svg) ![Python](https://img.shields.io/badge/python-3.11-blue.svg) ![Python](https://img.shields.io/badge/python-3.12-blue.svg) ![Python](https://img.shields.io/badge/python-3.13-blue.svg)                                                                                                                                                                                                                                                                                                                        |



  - [Introduction](#introduction)
  - [Installation](#installation)
    - [Install from PyPi](#install-from-pypi)
      - [Developer install](#developer-install)
  - [Documentation](#documentation)
  - [Contributing](#contributing)
  - [Credits](#credits)



  [Electrical Impedance Tomography](https://en.wikipedia.org/wiki/Electrical_impedance_tomography) (EIT) is a noninvasive
  and radiation-free continuous imaging tool for monitoring respiratory mechanics. eitprocessing aims to provide a
  versatile, user-friendly, reproducible and reliable workflow for the processing and analysis of EIT data and related
  waveform data, like pressures and flow.

  eitprocessing includes tools to load data exported from EIT-devices from several manufacturers, including Dräger, SenTec
  and Timpel, as well as data from other sources. Several pre-processing tools and analysis tools are provided.

  <!-- TODO when available, add summarisation and reporting -->
  <!-- TODO extend with short list of available tools when applicable -->

  [eit_dash](https://github.com/EIT-ALIVE/eit_dash) provides an accompanying GUI.



  It is advised to install eitprocessing in a dedicated virtual environment. See e.g. [Install packages in a virtual
  environment using pip and
  venv](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/) or [Getting started
  with conda](https://docs.conda.io/projects/conda/en/stable/user-guide/getting-started.html).



  eitprocessing can be installed from PyPi as follows:

  ```
  pip install eitprocessing
  ```



  For full developer options (testing, etc):

  ```
  git clone git@github.com:EIT-ALIVE/eitprocessing.git
  cd eitprocessing
  pip install -e ".[dev]"
  ```



  Please see our [user documentation](https://eit-alive.github.io/eitprocessing/) for a detailed explanation of the package.



  We welcome any contributions or suggestions. If you want to contribute to the development of eitprocessing,
  have a look at the [contribution guidelines](CONTRIBUTING.md) and the [developer documentation](README.dev.md).



  This package was created with [Cookiecutter](https://github.com/audreyr/cookiecutter) and the [NLeSC/python-template](https://github.com/NLeSC/python-template).


pkgId: 8626be7c3260d310b120f065ab976c49e158c1119777f211f2fdf2bb94563e3d
name: python-ekogram-help
arch: noarch
version: 0.10
epoch: 0
release: 1
summary: Development documents and examples for ekogram
url: https://github.com/SiriRSST/Ekogram
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ekogram-0.10-1.src.rpm
location_href: Packages/python-ekogram-help-0.10-1.noarch.rpm
checksum_type: sha256
description:
  **Ekogram** - это легкая библиотека для работы с Telegram Bot API версии 7.10. Она предоставляет простой и понятный интерфейс для отправки различных типов сообщений и обработки обновлений.

  __Библиотека похожа на telebot, но она более простая и подходит для разработки достаточно сложных проектов__


  ```bash
  pip install ekogram
  ```


  ```python
  from ekogram import Bot, Markup, GPT
  import time

  gpt = GPT()
  bot = Bot('You_Bot_Token')

  @bot.message_handler(content_types=['new_chat_member'])
  def hello_mention(message):
      new_member = message.new_chat_member.first_name
      new_id = message.new_chat_member.id
      chat_id = message.chat.id
      privet = gpt.gpt4o("Привет")
      if new_id == bot.get_me().id:
          bot.reply_message(text=f"{privet}", mode="Markdown")
      else:
          bot.reply_message(chat_id, text=f"Привет [{str(new_member).replace('[', '').replace(']', '')}](tg://user?id={new_id})!", mode="Markdown")


  @bot.message_handler(content_types=['left_chat_member'])
  def godbye_mention(message):
      tot_name = message.left_chat_member.first_name
      tot_id = message.left_chat_member.id
      chat_id = message.chat.id
      bot.reply_message(chat_id, f"[{str(tot_name).replace('[', '').replace(']', '')}](tg://user?id={tot_id}) покинул(а) беседу", mode="Markdown")


  @bot.message_handler(commands=['start'])
  def start(message):
      buttons = [{'text': 'Кнопка 1', 'callback_data': '1'}, {'text': 'Кнопка 2', 'callback_data': '2'}, {'text': 'Кнопка 3', 'callback_data': '3'}]
      reply_markup = Markup.create_inline_keyboard(buttons, row_width=2)
      p = bot.reply_message(message.chat.id, f"Выберите кнопку {message.from_user.first_name}:", reply_markup=reply_markup)
      bot.edit_message_text(p.chat.id, message_id=p.message_id, text="Окей, шучу")
      bot.edit_message_reply_markup(p.chat.id, message_id=p.message_id, reply_markup=reply_markup)


  @bot.message_handler(commands=['help'])
  def help(message):
      buttonss = [{'text': 'Кнопка 1'}, {'text': 'Кнопка 2'}, {'text': 'Кнопка 3'}]
      reply_markup = Markup.create_reply_keyboard(buttonss, row_width=1)
      bot.reply_message(message.chat.id, "Кнопки:", reply_markup=reply_markup)


  @bot.callback_query_handler(func=lambda call: True)
  def handle_button_1(call):
      if call.data == '1':
          bot.answer_callback_query(call.id, text="Вы нажали кнопку 1!")
      elif call.data == '2':
          bot.answer_callback_query(call.id, text="Вы нажали кнопку 2!")
      elif call.data == '3':
          bot.answer_callback_query(call.id, text="Вы нажали кнопку 3!")

  @bot.message_handler(content_types=['text'])
  def ms_obrabotka(ms):
      chat_id = ms.chat.id
      message_id = ms.message_id
      if ms.text == 'Кнопка 1':
          bot.reply_message(chat_id, 'Вы нажали кнопку 1!', reply_to_message_id=message_id)
      if ms.text == 'Кнопка 2':
          bot.reply_message(chat_id, 'Вы нажали кнопку 2!', reply_to_message_id=message_id)
      if ms.text == 'Кнопка 3':
          bot.reply_message(chat_id, 'Вы нажали кнопку 3!', reply_to_message_id=message_id)
      if ms.text == 'Привет':
          bot.reply_message(chat_id, 'Привет, я бот!', reply_to_message_id=message_id)


  @bot.message_handler(content_types=['photo'])
  def handle_photo_message(message):
      chat_id = message.chat.id
      photo_id = message.photo[-1].file_id
      p = bot.get_file(photo_id)
      bot.download_file(p, p.file_path)
      bot.reply_photo(chat_id, photo=photo_id, reply_to_message_id=message.message_id, caption=f"`{photo_id}`", mode="Markdown")
      bot.delete_chat_photo(chat_id)


  @bot.message_handler(content_types=['voice'])
  def handle_voice_message(message):
      chat_id = message.chat.id
      voice = message.voice.file_id
      bot.reply_voice(chat_id, voice=voice, reply_to_message_id=message.message_id, caption=f"`{voice}`", mode="Markdown")


  @bot.message_handler(content_types=['document'])
  def handle_document_message(message):
      chat_id = message.chat.id
      document = message.document.file_id
      p = bot.get_file(document)
      bot.download_file(p, './document.txt')
      bot.reply_document(chat_id, document=open('./document.txt', 'rb'), reply_to_message_id=message.message_id, caption=f"`{document}`", mode="Markdown")

  @bot.message_handler(content_types=['video'])
  def handle_video_message(message):
      chat_id = message.chat.id
      video = message.video.file_id
      p = bot.get_file(video)
      bot.download_file(p, './video.mp4')
      bot.reply_video(chat_id, video=open('./video.mp4', 'rb'), reply_to_message_id=message.message_id, caption=f"`{video}`", mode="Markdown")


  @bot.message_handler(content_types=['audio'])
  def handle_audio_message(message):
      chat_id = message.chat.id
      audio = message.audio.file_id
      p = bot.get_file(audio)
      bot.download_file(p, './audio.mp3')
      bot.reply_audio(chat_id, audio=open('./audio.mp3', 'rb'), reply_to_message_id=message.message_id, caption=f"`{audio}`", mode="Markdown")


  @bot.message_handler(content_types=['video_note'])
  def handle_video_note_message(message):
      chat_id = message.chat.id
      video_note = message.video_note.file_id
      p = bot.get_file(video_note)
      bot.download_file(p, './video_note.mp4')
      bot.reply_video_note(chat_id, video_note=open('./video_note.mp4', 'rb'), reply_to_message_id=message.message_id, caption=f"`{video_note}`", mode="Markdown")


  @bot.message_handler(content_types=['sticker'])
  def handle_sticker_message(message):
      chat_id = message.chat.id
      sticker = message.sticker.file_id
      p = bot.get_file(sticker)
      bot.download_file(p, './sticker.webp')
      bot.reply_sticker(chat_id, sticker=open('./sticker.webp', 'rb'), reply_to_message_id=message.message_id)


  @bot.message_handler(content_types=['animation'])
  def handle_animation_message(message):
      chat_id = message.chat.id
      animation = message.animation.file_id
      p = bot.get_file(animation)
      bot.download_file(p, './animation.mp4')
      bot.reply_animation(chat_id, animation=open('./animation.mp4', 'rb'), reply_to_message_id=message.message_id)


  bot.polling()
  ```

  Использование ChatGPT
  ```python
  from ekogram import GPT


  while True:
      p = input("Введите текст: ")
      otvet = GPT().gpt3(p)
      print(otvet)


  while True
      p = input("Введите текст: ")
      otvet = GPT().gpt4o(p)
      print(otvet)
  ```


  Ekogram распространяется под лицензией MIT.


  Если у вас есть вопросы или предложения, пожалуйста, напишите нам: siriteamrs@gmail.com


  **Если у вас есть еще вопросы, пожалуйста, дайте мне знать!**


pkgId: a8d3458b217a59807d0f3b9eb5e89b4e4683cec0bf17975598bbb21a713e17b7
name: python-elasticai.creator-help
arch: noarch
version: 0.60.0
epoch: 0
release: 1
summary: Development documents and examples for elasticai.creator
url: https://github.com/es-ude/elastic-ai.creator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elasticai.creator-0.60.0-1.src.rpm
location_href: Packages/python-elasticai.creator-help-0.60.0-1.noarch.rpm
checksum_type: sha256
description:
  Design, train and compile neural networks optimized specifically for FPGAs.
  Obtaining a final model is typically a three stage process.
  * design and train it using the layers provided in the `elasticai.creator.nn` package.
  * translate the model to a target representation, e.g. VHDL
  * compile the intermediate representation with a third party tool, e.g. Xilinx Vivado (TM)

  This version currently only supports parts of VHDL as target representations.

  The project is part of the elastic ai ecosystem developed by the Embedded Systems Department of the University Duisburg-Essen. For more details checkout the slides at [researchgate](https://www.researchgate.net/publication/356372207_In-Situ_Artificial_Intelligence_for_Self-_Devices_The_Elastic_AI_Ecosystem_Tutorial).





  - [Users Guide](#users-guide)
    - [Install](#install)
    - [Minimal Example](#minimal-example)
    - [General Limitations](#general-limitations)
  - [Structure of the Project](#structure-of-the-project)
  - [Developers Guide](#developers-guide)
    - [Install Dev Dependencies](#install-dev-dependencies)
    - [Conventional Commit Rules](#conventional-commit-rules)
    - [Adding new translation targets](#adding-new-translation-targets)
    - [Syntax Checking](#syntax-checking)
    - [Tests](#tests)
      - [Test Style Guidelines](#test-style-guidelines)
        - [File IO](#file-io)
        - [Directory structure and file names](#directory-structure-and-file-names)
        - [Unit tests](#unit-tests)
        - [Integration tests](#integration-tests)
        - [System tests](#system-tests)
        - [Adding new functionalities and tests required](#adding-new-functionalities-and-tests-required)
        - [Updating tests](#updating-tests)







  You can install the ElasticAI.creator as a dependency using pip:
  ```bash
  python3 -m pip install elasticai-creator
  ```




  The following example shows how to use the ElasticAI.creator to define and translate a machine learning model to VHDL. It will save the generated VHDL code to a directory called `build_dir`.

  ```python
  from elasticai.creator.nn import Sequential
  from elasticai.creator.nn.fixed_point import Linear, HardSigmoid
  from elasticai.creator.file_generation.on_disk_path import OnDiskPath


  def main() -> None:
      
      model = Sequential(
          Linear(in_features=10, out_features=2, bias=True, total_bits=16, frac_bits=8),
          HardSigmoid(total_bits=16, frac_bits=8),
      )

      
      run_training(model)

      
      destination = OnDiskPath("build_dir")
      design = model.create_design("my_model")
      design.save_to(destination)


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




  By now we only support Sequential models for our translations.





  The structure of the project is as follows.
  The [creator](elasticai/creator) folder includes all main concepts of our project, especially the qtorch implementation which is our implementation of quantized PyTorch layer.
  It also includes the supported target representations, like the subfolder [nn](elasticai/creator/nn) is for the translation to vhdl.
  Additionally, we have unit and integration tests in the [tests](tests) folder.







  - [poetry](https://python-poetry.org/)
  - recommended:
    - [pre-commit](https://pre-commit.com/)
    - [commitlint](https://github.com/conventional-changelog/commitlint) to help following our [conventional commit](https://www.conventionalcommits.org/en/v1.0.0-beta.2/#summary) guidelines
  poetry can be installed in the following way:
  ```bash
  pip install poetry
  poetry install
  poetry shell
  pre-commit install
  npm install --save-dev @commitlint/{config-conventional,cli}


  sudo apt install ghdl
  ```



  All packages and modules fall into one of five main categories and can thus be found in the corresponding package

   - `nn`: trainable modules that can be translated to vhdl to build a hardware accelerator
   - `base_modules`: (non-public) shared functionality and data structures, that we use to create our neural network software modules
   - `vhdl`: (non-public) shared code that we use to represent and generate vhdl code
   - `file_generation`: provide a very restricted api to generate files or file subtrees under a given root node and defines a basic template api and datastructure, compatible with `file_generation`




   - **fxp/Fxp**: prefix for fixed point
   - **flp/Flp**: prefix for floating point
   - **x**: parameter input tensor for layer with single input tensor
   - **y**: output value/tensor for layer with single output
   - **_bits**: suffix to denote the number of bits, e.g. `total_bits`, `frac_bits`, in python context
   - **_width**: suffix to denote the number of bits used for a data bus in vhdl, e.g. `total_width`, `frac_width`
   - **MathOperations/operations**: definition of how to perform mathematical operations (quantization, addition, matrix multiplication, ...)




  We use conventional commits (see [here](https://www.conventionalcommits.org/en/v1.0.0-beta.2/#summary)). The following commit types are allowed. The message scope is optional.

  | Commit Types |
  |--------------|
  | feat         |
  | fix          |
  | docs         |
  | style        |
  | refactor     |
  | revert       |
  | chore        |
  | wip          |
  | perf         |




  Our implementation is tested with unit and integration.
  You can run one explicit test with the following statement:

  ```bash
  python3 -m pytest ./tests/path/to/specific/test.py
  ```

  If you want to run all tests, give the path to the tests:

  ```bash
  python3 -m pytest ./tests
  ```

  If you want to add more tests please refer to the Test Guidelines in the following.






  In general try to avoid interaction with the filesystem. In most cases instead of writing to or reading from a file you can use a StringIO object or a StringReader.
  If you absolutely have to create files, be sure to use pythons [tempfile](https://docs.python.org/3.9/library/tempfile.html) module and cleanup after the tests.
  In most cases you can use the [`InMemoryPath`](elasticai/creator/file_generation/in_memory_path.py) class to write files to the RAM instead of writing them to the hard disc (especially for testing the generated VHDL files of a certain layer).




  Files containing tests for a python module should be located in a test directory for the sake of separation of concerns.
  Each file in the test directory should contain tests for one and only one class/function defined in the module.
  Files containing tests should be named according to the rubric
  `test_<class_name>.py`.
  Next, if needed for more specific tests define a class. Then subclass it.
  It avoids introducing the category of bugs associated with copying and pasting code for reuse.
  This class should be named similarly to the file name.
  There's a category of bugs that appear if  the initialization parameters defined at the top of the test file are directly used: some tests require the initialization parameters to be changed slightly.
  Its possible to define a parameter and have it change in memory as a result of a test.
  Subsequent tests will therefore throw errors.
  Each class contains methods that implement a test.
  These methods are named according to the rubric
  `test_<name>_<condition>`




  In those tests each functionality of each function in the module is tested, it is the entry point  when adding new functions.
  It assures that the function behaves correctly independently of others.
  Each test has to be fast, so use of heavier libraries is discouraged.
  The input used is the minimal one needed to obtain a reproducible output.
  Dependencies should be replaced with mocks as needed.



  Here the functions' behaviour with other modules is tested.
  In this repository each integration function is in the correspondent folder.
  Then the integration with a single class of the target, or the minimum amount of classes for a functionality, is tested in each separated file.



  Those tests will use every component of the system, comprising multiple classes.
  Those tests include expected use cases and unexpected or stress tests.



  When adding new functions to an existing module, add unit tests in the correspondent file in the same order of the module, if a new module is created a new file should be created.
  When a bug is solved created the respective regression test to ensure that it will not return.
  Proceed similarly with integration tests.
  Creating a new file if a functionality completely different from the others is created e.g. support for a new layer.
  System tests are added if support for a new library is added.



  If new functionalities are changed or removed the tests are expected to reflect that, generally the ordering is unit tests -> integration tests-> system tests.
  Also, unit tests that change the dependencies should be checked, since this system is fairly small the internal dependencies are not always mocked.

  references: https://jrsmith3.github.io/python-testing-style-guidelines.html


pkgId: 3ccae88d0cc30a2797edab9159209c9aefc311f6ebc0d21ac741bebfeb81beb8
name: python-elasticipy-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for elasticipy
url: https://pypi.org/project/Elasticipy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elasticipy-2.4.0-1.src.rpm
location_href: Packages/python-elasticipy-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/Elasticipy?link=https%3A%2F%2Fpypi.org%2Fproject%2FElasticipy%2F)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/Elasticipy?link=https%3A%2F%2Fpypi.org%2Fproject%2FElasticipy%2F)
  ![PyPI - License](https://img.shields.io/pypi/l/Elasticipy)
  ![ReadTheDoc](https://readthedocs.org/projects/elasticipy/badge/?version=latest)

  A python toolkit to manipulate strain and strain tensors, and other linear elasticity-related tensors (e.g. stiffness).
  This package also provides a collection of easy-to-use and very fast tools to work on stress and strain tensors.


  Among other features, this package implements:

  - Computation of elasticity tensors,
  - Analysis of elastic anisotropy and wave propagation,
  - Working with multidimensional arrays of strain and stress tensors,
  - Thermal expansion tensors,
  - Rotation of tensors,
  - Integration with crystal symmetry groups,
  - Visualization and tutorials for ease of use,
  - A graphical user interface to plot the spatial dependence of engineering constants,
  - Compatibility with the [Materials Project](https://next-gen.materialsproject.org/) API.


  Elasticipy can be installed with PIP:
  ````
  pip install Elasticipy
  ````


  Tutorials and full documentation are available on [ReadTheDoc](https://elasticipy.readthedocs.io/).


  The source code is available on [GitHub](https://github.com/DorianDepriester/Elasticipy) under the [MIT licence](https://github.com/DorianDepriester/Elasticipy/blob/c6c3d441a2d290ab8f4939992d5d753a1ad3bdb0/LICENSE).


pkgId: 67b27da64638babc1438df721bf8838d7c34605d6c70a6865a8555c9bfd67999
name: python-elasticsearch-dsl-help
arch: noarch
version: 8.17.0
epoch: 0
release: 1
summary: Development documents and examples for elasticsearch-dsl
url: https://github.com/elasticsearch/elasticsearch-dsl-py
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elasticsearch-dsl-8.17.0-1.src.rpm
location_href: Packages/python-elasticsearch-dsl-help-8.17.0-1.noarch.rpm
checksum_type: sha256
description:
  Elasticsearch DSL is a high-level library whose aim is to help with writing and
  running queries against Elasticsearch. It is built on top of the official
  low-level client (`elasticsearch-py <https://github.com/elastic/elasticsearch-py>`_).
  It provides a more convenient and idiomatic way to write and manipulate
  queries. It stays close to the Elasticsearch JSON DSL, mirroring its
  terminology and structure. It exposes the whole range of the DSL from Python
  either directly using defined classes or a queryset-like expressions.
  It also provides an optional wrapper for working with documents as Python
  objects: defining mappings, retrieving and saving documents, wrapping the
  document data in user-defined classes.
  To use the other Elasticsearch APIs (eg. cluster health) just use the
  underlying client.


pkgId: 759c287d4f63bc9fa6864325a31a49f947a56aa8e2e22c055a1b7054ab6faad5
name: python-elasticsearch-help
arch: noarch
version: 8.17.0
epoch: 0
release: 1
summary: Development documents and examples for elasticsearch
url: https://github.com/elastic/elasticsearch-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elasticsearch-8.17.0-1.src.rpm
location_href: Packages/python-elasticsearch-help-8.17.0-1.noarch.rpm
checksum_type: sha256
description:
  * [Creating an index](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_creating_an_index)
  * [Indexing a document](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_indexing_documents)
  * [Getting documents](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_getting_documents)
  * [Searching documents](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_searching_documents)
  * [Updating documents](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_updating_documents)
  * [Deleting documents](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_deleting_documents)
  * [Deleting an index](https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/getting-started-python.html#_deleting_an_index)

  Language clients are forward compatible; meaning that the clients support
  communicating with greater or equal minor versions of Elasticsearch without
  breaking. It does not mean that the clients automatically support new features
  of newer Elasticsearch versions; it is only possible after a release of a new
  client version. For example, a 8.12 client version won't automatically support
  the new features of the 8.13 version of Elasticsearch, the 8.13 client version
  is required for that. Elasticsearch language clients are only backwards
  compatible with default distributions and without guarantees made.
  | Elasticsearch Version | Elasticsearch-Python Branch | Supported |
  | --------------------- | ------------------------ | --------- |
  | main                  | main                     |           |
  | 8.x                   | 8.x                      | 8.x       |
  | 7.x                   | 7.x                      | 7.17      |
  If you have a need to have multiple versions installed at the same time older
  versions are also released as ``elasticsearch7`` and ``elasticsearch8``.

  Documentation for the client is [available on elastic.co] and [Read the Docs].
  [available on elastic.co]: https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/index.html
  [Read the Docs]: https://elasticsearch-py.readthedocs.io

  The engineering team here at Elastic is looking for developers to participate in
  research and feedback sessions to learn more about how you use our Python client and
  what improvements we can make to their design and your workflow. If you're interested in
  sharing your insights into developer experience and language client design, please fill
  out this [short form]. Depending on the number of responses we get, we may either
  contact you for a 1:1 conversation or a focus group with other developers who use the
  same client. Thank you in advance - your feedback is crucial to improving the user
  experience for all Elasticsearch developers!
  [short form]: https://forms.gle/bYZwDQXijfhfwshn9

  This software is licensed under the [Apache License 2.0](./LICENSE). See [NOTICE](./NOTICE).


pkgId: 5f6704a10750ee7ac4a8f56e3fa7a87df55c85bddb77aac9cf2edb5251c0dce1
name: python-elektra-help
arch: noarch
version: 0.0.31
epoch: 0
release: 1
summary: Development documents and examples for elektra
url: https://github.com/wearemolecule/elektra
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elektra-0.0.31-1.src.rpm
location_href: Packages/python-elektra-help-0.0.31-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/elektra.svg)](https://badge.fury.io/py/elektra)



  Elektra is Molecule's core framework for block logic (i.e., how to compute mwh from 5x16, 2x16, etc. blocks). It's derived from a set of logic internal to the Molecule application, and we're happy to share it with the world -- because nobody should ever have to fight with North American power blocks _ever_ again.

  Elektra is in pre-release, which means that signatures may change over time as we evolve the project to 1.0. Submissions are welcome; just submit a pull request with your change.



  Either clone this repo, or use pip:

  > pip3 install elektra
  >


  In your python project, `import elektra` and use away. Usage examples are in `examples/examples.py`. A sample input CSV is there too. For the examples below, we will use that CSV. You can also use the table of data at the end of this file.




  Internally, Elektra uses enums for ISO, Block, and Frequency. String inputs for these fields are converted to the enum when Elektra runs, and so must be provided in the exact format the Enum expects.

  1. `iso`: permitted values are `miso`, `isone`, `ercot`, `pjm`, `spp`, `aeso`, `nyiso`, `caiso`
  2. `block`: permitted values are `7x8`, `5x16`, `2x16`, `7x24`, `7x16`, `1x1`, `wrap`, `6x16`
  3. `frequency`: permitted values are `daily`, `monthly`, `hourly`



  These are the primary methods available in Elektra. Other methods are available, but are undocumented.
  * [create_prices](#create_prices): Creates block prices from raw LMP input
  * [scrub_hourly_prices](#scrub_hourly_prices): Verifies that enough hourly LMPs are present
  * [convert](#convert): Converts hours in one block, to equivalent hours in another
  * [translate_blocks](#translate_blocks): Wraps [convert](#convert), and adds MW and/or MWh conversions
  * [is_dst_transition](#is_dst_transition): Determines if a date is a DST changeover day



  This method creates block prices, given hourly prices for a period of time and a handful of other parameters. A key function of this method is that it validates whether enough prices have been submitted to do the calculation. So, if the `block` is 5x16, but a price is missing for a Wednesday at 11 AM, an exception will be thrown. Daylight Savings Time is also contemplated.

  The *create_prices* method takes the following parameters:

  * `flow_date` - *date* | The as of date for the power prices (i.e., the settlement/reporting date needed)
  * `ticker` - *string* | The ticker symbol for the power product (Molecule ticker; used for identification, not calculation)
  * `node` - *string* | The node on the power grid (used for identification, not calculation)
  * `iso` - *string* | The name of the Independent System Operator (ISO). CAISO is not currently supported.
  * `block` - *string* | The desired power block for the output prices
  * `frequency` *string* | The desired frequency for the output prices (either `daily` or `monthly`)
  * `prices` *DataFrame* | A Pandas dataframe of prices consisting of `flow_date`, `hour_ending`, and `price`

  The response from the method is a single floating-point price.


  ``` python
  import elektra
  import pandas as pd
  import filecmp
  import datetime as dt

  flow_date = dt.datetime(2020, 10, 17)
  prices = pd.read_csv('lmps.csv')

  result = elektra.create_prices(flow_date, 'M.XXXX', 'INDIANA.HUB', 'miso', '2x16', 'daily', prices)
  print(result)

  ```


  This method validates that a submitted dataframe contains all the necessary hourly prices for a flow date, and returns a DataFrame with these prices. Daylight Savings Time (long-day and short-day) is contemplated.

  The *scrub_hourly_prices* method takes the following parameters:

  * `flow_date` - *date* | The as of date for the power prices (i.e., the settlement/reporting date needed)
  * `ticker` - *string* | The ticker symbol for the power product (Molecule ticker; used for identification, not calculation)
  * `node` - *string* | The node on the power grid (used for identification, not calculation)
  * `iso` - *string* | The name of the Independent System Operator (ISO). CAISO is not currently supported.
  * `prices` *DataFrame* | A Pandas dataframe of prices consisting of `flow_date`, `hour_ending`, and `price`

  The response from the method is a Pandas dataframe with the following columns of data:

  * Hour Beginning
  * Hour Ending
  * Required
  * Special
  * Value


  ``` python
  import elektra
  import pandas as pd
  import filecmp
  import datetime as dt

  flow_date = dt.datetime(2020, 10, 17)
  prices = pd.read_csv('lmps.csv')

  result = elektra.scrub_hourly_prices(flow_date, 'M.XXXX', '116013753', 'pjm', prices)
  print(result)

  ```



  Given a flow date and an input block (i.e., 5x16), this method returns the number of hours in another block.

  For example, if today is Wednesday, November 4, 2020, and I have a 7x24 block (24 hours), but I want to see how many 5x16 hours that implies -- I'll get 16. On the other hand, if today is Saturday, October 31, 2020, and I have a Wrap block (24 hours that day), that only implies 8 hours of 7x8. This is useful when trying to convert a position purchased in one block, to a volume of another block. It works in tandem with the TranslateBlocks method.

  The *convert* method takes the following parameters:

  * `flow_date` - *date* | The as of date for the power prices (i.e., the settlement/reporting date needed)
  * `input_block` -- (text: Wrap, 5x16, 2x16, 7x8, 7x16, 1x1) | The input block.
  * `output_block` -- (text: Wrap, 5x16, 2x16, 7x8, 7x16, 1x1) | The block for which we want to see hours.

  The response from this method is an integer, representing the number of hours in the output block.


  ``` python
  import elektra
  import datetime as dt

  flow_date = dt.datetime(2020, 10, 17)

  result = elektra.convert(flow_date, '7x24', '2x16') # 16: (October 17 2020 is a Saturday, and has 16 peak hours)
  result = elektra.convert(flow_date, '7x24', '5x16') # 0: (October 17 2020 is a Saturday, and has 0 weekday peak hours)
  result = elektra.convert(flow_date, '5x16', '2x16') # 0: (October 17 2020 is a Saturday, and there could not be a 5x16 input block)

  ```


  Wrapper for `convert`, which adds the ability to convert a MW position for a term block (i.e., 7x24 monthly) to another block (or blocks) for that same term (i.e., 5x16, 2x16).

  The *translateBlocks* method takes the following parameters:
  * `iso` - *string* | The short name of the Independent System Operator (Elektra.Iso). This is not currently used, so beware when using for CAISO.
  * `mw` - *decimal* | The number of megawatts on the input block to be used for mw/mwh computation
  * `frequency` - *string* | monthly, daily, or hourly. Currently only monthly is implemented.
  * `contract_start` *date* | The first flow date of the block. This method will compute the last flow date.
  * `in_block` - *string* | 7x24, 5x16, Wrap, 2x16, 7x8
  * `out_blocks` - *string array* | accepted values include 7x24, 5x16, Wrap, 2x16, 7x8
  * `out_uom` - *string* | Set to `MW` for a megawatt number. Default is `mwh`.

  The response from this method is a DataFrame with the following columns:
  * date (i.e., flow date)
  * one column for each `out_block`, representing the number of MW or MWh for each date


  ``` python
  import elektra
  import datetime as dt

  flow_date = dt.datetime(2020, 10, 1)
  result = elektra.translateBlocks('pjm', 20, 'monthly', flow_date, '7x24', ['5x16', '2x16'], 'mwh')
  print(result)
  ```


  Responds with variables that indicate whether the input date is a DST transition day, and whether it is the _short day_ of the year (i.e., spring DST transition day) or the _long day_ of the year (fall). If the date is not the transition day, the short- and long- day returns are False.

  The method takes the following parameter:
  * `as_of` - *date* | The date to test

  The method returns the following parameters:
  * `is_tx` - *boolean* | True, if the supplied date is one of the two yearly transition days
  * `short_day` - *boolean* | True, if the supplied date is the short day
  * `long_day` - *boolean* | True, if the supplied date is the long day


  ``` python
  import elektra
  import datetime as dt
  flow_date = dt.datetime(2021, 3, 14)

  is_tx, short_day, long_day = elektra.is_dst_transition(flow_date)
  print(is_tx) # True; this is one of the transition dates
  print(short_day) # True; this is the spring DST transition date
  print(long_day) # False; that would be the "fall back" date
  ```


  This data is suitable for inputs to the hourly and block price converters:

  | flow_date  | hour_ending | price |
  |------------|-------------|-------|
  | 2020-10-17 | 1.0         | 26.48 |
  | 2020-10-17 | 2.0         | 20.35 |
  | 2020-10-17 | 3.0         | 17.19 |
  | 2020-10-17 | 4.0         | 17.16 |
  | 2020-10-17 | 5.0         | 20.28 |
  | 2020-10-17 | 6.0         | 34.25 |
  | 2020-10-17 | 7.0         | 21.24 |
  | 2020-10-17 | 8.0         | 23.67 |
  | 2020-10-17 | 9.0         | 22.37 |
  | 2020-10-17 | 10.0        | 20.81 |
  | 2020-10-17 | 11.0        | 21.10 |
  | 2020-10-17 | 12.0        | 19.28 |
  | 2020-10-17 | 13.0        | 18.94 |
  | 2020-10-17 | 14.0        | 18.07 |
  | 2020-10-17 | 15.0        | 19.43 |
  | 2020-10-17 | 16.0        | 18.94 |
  | 2020-10-17 | 17.0        | 18.85 |
  | 2020-10-17 | 18.0        | 22.40 |
  | 2020-10-17 | 19.0        | 60.50 |
  | 2020-10-17 | 20.0        | 19.12 |
  | 2020-10-17 | 21.0        | 20.36 |
  | 2020-10-17 | 22.0        | 19.39 |
  | 2020-10-17 | 23.0        | 17.67 |
  | 2020-10-17 | 24.0        | 17.55 |


pkgId: 8f2e9d6880eec4d0475ff4bfb4bd51ff7d49088b12c01ca739077a7a75ada872
name: python-elevenlabs-help
arch: noarch
version: 1.50.0
epoch: 0
release: 1
summary: Development documents and examples for elevenlabs
url: https://pypi.org/project/elevenlabs/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elevenlabs-1.50.0-1.src.rpm
location_href: Packages/python-elevenlabs-help-1.50.0-1.noarch.rpm
checksum_type: sha256
description:
  ![LOGO](https://github.com/elevenlabs/elevenlabs-python/assets/12028621/21267d89-5e82-4e7e-9c81-caf30b237683)

  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://buildwithfern.com/?utm_source=fern-elevenlabs/elevenlabs-python/readme)
  [![Discord](https://badgen.net/badge/black/ElevenLabs/icon?icon=discord&label)](https://discord.gg/elevenlabs)
  [![Twitter](https://badgen.net/badge/black/elevenlabsio/icon?icon=twitter&label)](https://twitter.com/elevenlabsio)
  [![PyPI - Python Version](https://img.shields.io/pypi/v/elevenlabs?style=flat&colorA=black&colorB=black)](https://pypi.org/project/elevenlabs/)
  [![Downloads](https://static.pepy.tech/personalized-badge/elevenlabs?period=total&units=international_system&left_color=black&right_color=black&left_text=Downloads)](https://pepy.tech/project/elevenlabs)

  The official Python API for [ElevenLabs](https://elevenlabs.io/) [text-to-speech software.](https://elevenlabs.io/text-to-speech) Eleven brings the most compelling, rich and lifelike voices to creators and developers in just a few lines of code.



  Check out the [HTTP API documentation](https://elevenlabs.io/docs/api-reference).



  ```bash
  pip install elevenlabs
  ```



  [![Open in Spaces](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue.svg)](https://huggingface.co/spaces/elevenlabs/tts)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/gist/flavioschneider/49468d728a816c6538fd2f56b3b50b96/elevenlabs-python.ipynb)



  1. **Eleven Multilingual v2** (`eleven_multilingual_v2`)

     - Excels in stability, language diversity, and accent accuracy
     - Supports 29 languages
     - Recommended for most use cases

  2. **Eleven Turbo v2.5** (`eleven_turbo_v2_5`)
     - High quality, lowest latency
     - Ideal for developer use cases where speed is crucial
     - Supports 32 languages

  For more detailed information about these models and others, visit the [ElevenLabs Models documentation](https://elevenlabs.io/docs/speech-synthesis/models).

  ```py
  from elevenlabs import play
  from elevenlabs.client import ElevenLabs

  client = ElevenLabs(
    api_key="YOUR_API_KEY", # Defaults to ELEVEN_API_KEY
  )

  audio = client.generate(
    text="Hello! 你好! Hola! नमस्ते! Bonjour! こんにちは! مرحبا! 안녕하세요! Ciao! Cześć! Привіт! வணக்கம்!",
    voice="Brian",
    model="eleven_multilingual_v2"
  )
  play(audio)
  ```

  <details> <summary> Play </summary>

  🎧 **Try it out!** Want to hear our voices in action? Visit the [ElevenLabs Voice Lab](https://elevenlabs.io/voice-lab) to experiment with different voices, languages, and settings.

  </details>



  List all your available voices with `voices()`.

  ```py
  from elevenlabs.client import ElevenLabs

  client = ElevenLabs(
    api_key="YOUR_API_KEY", # Defaults to ELEVEN_API_KEY
  )

  response = client.voices.get_all()
  audio = client.generate(text="Hello there!", voice=response.voices[0])
  print(response.voices)
  ```

  For information about the structure of the voices output, please refer to the [official ElevenLabs API documentation for Get Voices](https://elevenlabs.io/docs/api-reference/get-voices).

  Build a voice object with custom settings to personalize the voice style, or call
  `client.voices.get_settings("your-voice-id")` to get the default settings for the voice.

  ```py
  from elevenlabs import Voice, VoiceSettings, play
  from elevenlabs.client import ElevenLabs

  client = ElevenLabs(
    api_key="YOUR_API_KEY", # Defaults to ELEVEN_API_KEY
  )

  audio = client.generate(
      text="Hello! My name is Brian.",
      voice=Voice(
          voice_id='nPczCjzI2devNBz1zQrb',
          settings=VoiceSettings(stability=0.71, similarity_boost=0.5, style=0.0, use_speaker_boost=True)
      )
  )

  play(audio)
  ```

  </details>



  Clone your voice in an instant. Note that voice cloning requires an API key, see below.

  ```py
  from elevenlabs.client import ElevenLabs
  from elevenlabs import play

  client = ElevenLabs(
    api_key="YOUR_API_KEY", # Defaults to ELEVEN_API_KEY
  )

  voice = client.clone(
      name="Alex",
      description="An old American male voice with a slight hoarseness in his throat. Perfect for news", # Optional
      files=["./sample_0.mp3", "./sample_1.mp3", "./sample_2.mp3"],
  )

  audio = client.generate(text="Hi! I'm a cloned voice!", voice=voice)

  play(audio)
  ```



  Stream audio in real-time, as it's being generated.

  ```py
  from elevenlabs.client import ElevenLabs
  from elevenlabs import stream

  client = ElevenLabs(
    api_key="YOUR_API_KEY", # Defaults to ELEVEN_API_KEY
  )

  audio_stream = client.generate(
    text="This is a... streaming voice!!",
    stream=True
  )

  stream(audio_stream)
  ```

  Note that `generate` is a helper function. If you'd like to access
  the raw method, simply use `client.text_to_speech.convert_as_stream`.



  Stream text chunks into audio as it's being generated, with <1s latency. Note: if chunks don't end with space or punctuation (" ", ".", "?", "!"), the stream will wait for more text.

  ```py
  from elevenlabs.client import ElevenLabs
  from elevenlabs import stream

  client = ElevenLabs(
    api_key="YOUR_API_KEY", # Defaults to ELEVEN_API_KEY
  )

  def text_stream():
      yield "Hi there, I'm Eleven "
      yield "I'm a text to speech API "

  audio_stream = client.generate(
      text=text_stream(),
      voice="Brian",
      model="eleven_multilingual_v2",
      stream=True
  )

  stream(audio_stream)
  ```

  Note that `generate` is a helper function. If you'd like to access
  the raw method, simply use `client.text_to_speech.convert_realtime`.



  Use `AsyncElevenLabs` if you want to make API calls asynchronously.

  ```python
  import asyncio

  from elevenlabs.client import AsyncElevenLabs

  eleven = AsyncElevenLabs(
    api_key="MY_API_KEY" # Defaults to ELEVEN_API_KEY
  )

  async def print_models() -> None:
      models = await eleven.models.get_all()
      print(models)

  asyncio.run(print_models())
  ```



  We support 32 languages and 100+ accents. Explore [all languages](https://elevenlabs.io/languages).

  <img src="https://github.com/elevenlabs/elevenlabs-js/blob/main/assets/languages.png" width="900">



  While we value open-source contributions to this SDK, this library is generated programmatically. Additions made directly to this library would have to be moved over to our generation code, otherwise they would be overwritten upon the next generated release. Feel free to open a PR as a proof of concept, but know that we will not be able to merge it as-is. We suggest opening an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 2763d84c185c4e3f6a2008b253023bf09905d71a024bc62d938f21476e5a4536
name: python-elfinCodeUtils-help
arch: noarch
version: 0.1.8.2
epoch: 0
release: 1
summary: Development documents and examples for elfinCodeUtils
url: https://pypi.org/project/elfinCodeUtils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elfinCodeUtils-0.1.8.2-1.src.rpm
location_href: Packages/python-elfinCodeUtils-help-0.1.8.2-1.noarch.rpm
checksum_type: sha256
description:
  代码工具箱，记录关键代码防止重复开发, Github地址: [codeUtils](https://github.com/firstelfin/codeTools)



  ```shell
  pip install --index-url https://pypi.org/simple elfinCodeUtils
  ```



  ```shell
  python3 -m pip install --upgrade build
  python -m build -sw -nx
  twine upload dist/*
  ```

  > build 库是一个编译库，参考PYPI官网：https://pypi.org/project/build/



  - [X] 完成taskManage模块的编写: 参考[文档](./docs/taskManage.md)





  - [X] 完成labelme2yolo的开发：使用 `elfin labelme2yolo -h`查看帮助;
  - [ ] 完成labelme2coco的开发：使用 `elfin labelme2coco -h`查看帮助;
  - [ ] 完成labelme2voc的开发：使用 `elfin labelme2voc -h`查看帮助;
  - [ ] 完成yolo2labelme的开发：使用 `elfin yolo2labelme -h`查看帮助;
  - [ ] 完成yolo2coco的开发：使用 `elfin yolo2coco -h`查看帮助;
  - [ ] 完成yolo2voc的开发：使用 `elfin yolo2voc -h`查看帮助;
  - [ ] 完成coco2yolo的开发：使用 `elfin coco2yolo -h`查看帮助;
  - [ ] 完成coco2labelme的开发：使用 `elfin coco2labelme -h`查看帮助;
  - [ ] 完成coco2voc的开发：使用 `elfin coco2voc -h`查看帮助;
  - [X] 完成voc2yolo的开发：使用 `elfin voc2yolo -h`查看帮助;
  - [ ] 完成voc2labelme的开发：使用 `elfin voc2labelme -h`查看帮助;
  - [ ] 完成voc2coco的开发：使用 `elfin voc2coco -h`查看帮助;



  - [X] 完成yoloLabelExclude的开发：使用 `elfin yoloLabelExclude -h`查看帮助;



  - [X] 完成vocGenNames2Id的开发：使用 `elfin vocGenNames2Id -h`查看帮助;


pkgId: 32d938f9cba783966f123bd609108e13b8e7074cbb77e59ddd5f8795126394ff
name: python-elias-help
arch: noarch
version: 0.4.11
epoch: 0
release: 1
summary: Development documents and examples for elias
url: https://github.com/tobias-kirschstein/elias
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elias-0.4.11-1.src.rpm
location_href: Packages/python-elias-help-0.4.11-1.noarch.rpm
checksum_type: sha256
description:
  Data Preprocessing | <ul><li>Processing Configuration</li> <li>Raw Data</li></ul> | <ul><li>Preprocessed Data (.p, .p.gz, .json, .npy, ...)</li> <li>Data Statistics (stats.json)</li> <li>Preprocessing Config (config.json)</li></ul> | DataFolder -> DataManager
  Training/Fitting | <ul><li>Preprocessed Data</li> <li>Hyperparameters</li></ul> | <ul><li>Model checkpoints</li> <li>Hyperparameter configs</li></ul> | ModelManager -> RunManager
  Evaluation | <ul><li>Trained model</li><li>Evaluation Config</li></ul> | <ul><li>Evaluation Config</li> <li>Evaluation Results</li></ul> | RunManager -> EvaluationManager
  Manual Analysis | Any model/data | Plots, statistics, images | AnalysisFolder -> AnalysisManager


pkgId: 507b2190bfa665e61a446b7cfe6125b45095c0317bb25a45a85c45ee0eb2d80f
name: python-elkoep-mqtt-help
arch: noarch
version: 0.2.32
epoch: 0
release: 1
summary: Development documents and examples for elkoep-mqtt
url: https://github.com/epdevlab/elkoep-mqtt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elkoep-mqtt-0.2.32-1.src.rpm
location_href: Packages/python-elkoep-mqtt-help-0.2.32-1.noarch.rpm
checksum_type: sha256
description:
  A Python library that handles communication with inels over mqtt
  [iNELS](https://www.inels.com/) by ElkoEP company.

  [Pypi](https://pypi.org/project/elkoep-mqtt/)



  For smooth using you need to have Python 3.9 or higher.



  Use PyPI repository

  ```
  pip install elkoep-mqtt
  ```



  I use [tox](https://tox.readthedocs.io) for testing.

  ```
  $ pip install tox

  ```



  Supported RF devices

  - Switches (01, 02)
  - Shutters (03, 21)
  - Light dimmers (04, 05)
  - RGB light (06)
  - Switches with external temperature sensors (07)
  - Wireless thermovalves (09)
  - Temperature sensors (10)
  - Thermostats (12)
  - Flood detectors (15)
  - Generic detector (16)
  - Motion detector (17)
  - Controllers/buttons (18, 19)
  - Temperature and humidity sensors (29)

  Supported bus devices

  - SA3-01B (100)
  - DA3-22M (101)
  - GRT3-50 (102)
  - GSB3-90Sx (103)
  - SA3-02B (104)
  - SA3-02M (105)
  - SA3-04M (106)
  - SA3-06M (107)
  - SA3-012M (108)
  - SA3-022M (109)
  - FA3-612M (111)
  - RC3-610DALI (114)
  - IM3_20B (115)
  - IM3_40B (116)
  - IM3_80B (117)
  - DMD3-1 (120)
  - IM3-140M (121)
  - WSB3-20 (122)
  - WSB3-40 (123)
  - WSB3-20H (124)
  - WSB3-40H (125)
  - GCR3-11 (128)
  - GCH3-31 (129)
  - GSP3-100 (136)
  - GDB3-10 (137)
  - GSB3-40SX (138)
  - GSB3-60SX (139)
  - GSB3-20SX (140)
  - GBP3-60 (141)
  - GSB3-40-V2 (143)
  - GSB3-60-V2 (144)
  - GSB3-90-V2 (146)
  - DAC3-04B (147)
  - DAC3-04M (148)
  - DCDA-33M (150)
  - DA3-66M (151)
  - ADC3-60M (156)
  - TI3-10B (157)
  - TI3-40B (158)
  - TI3-60M (159)
  - IDRT3-1 (160)
  - JA3-018M (163)
  - Virtual heating regulator (167)
  - Virtual cooling regulator (168)
  - SA3_014M (169)
  - JA3_014M (170)
  - GSB3-40Sx-V2 (174)
  - GSB3-60Sx-V2 (175)
  - GSB3-90Sx-V2 (176)
  - MSB3-40 (177)
  - MSB3-60 (178)
  - MSB3-90 (179)
  - BITS (bits)
  - INTEGETS (integers)


pkgId: 2b7253e2feca9af180297159e5eff18ec55eaddb6693e387fd08b7475c1b2dbf
name: python-elkpy-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for elkpy
url: https://github.com/elkaudio/elkpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elkpy-1.2.2-1.src.rpm
location_href: Packages/python-elkpy-help-1.2.2-1.noarch.rpm
checksum_type: sha256
description:
  The `examples` subdirectory contains examples of how elkpy can be used.

  This demonstrates instantiating 3 processors onto Sushi started with an “empty” config, subscribing to notifications to wait for their instantiation, and then setting their parameters once they're available.
  To run:
  1. Ensure you have a Python environment set up where the packages described in requirements.txt are available, globally or in a `venv`.
  2. Start Sushi with the provided "sushi_control_example_config.json", and the '--base-plugin-path' set to point to where `mda-vst.vst3` plugins are available:
  ```commandline
  $ ./sushi --portaudio \
            --config-file /path/to/elkpy/examples/sushi_control_example_config.json \
            --base-plugin-path=/path/to/sushi/build/debug/VST3/Debug/
  ```
  If you've built Sushi from source, the plugins are built and accessible in the above path relative to the sushi binary.
  3. Start `sushi_control_example.py`:
  ```commandline
  $ python3 ./sushi_control_example.py --protofile "/path/to/sushi/rpc_interface/protos/sushi_rpc.proto"
  ```
  The `--protofile` argument points elkpy to the protocol buffer file used by Sushi.
  You should hear Sushi play a familiar theme tune.

  An example passive monitor app using elkpy.
  It connects to a sushi instance, subscribes to notifications and displays all the parameter, transport and audio graph changes that Sushi broadcasts.

  Ensure there is a Sushi instance running on the same computer.
  Then run:
  ```
  $ export SUSHI_GRPC_ELKPY_PROTO=./sushi_rpc.proto
  $ python3 examples/sushi_monitor.py
  ```

  Before running unit tests with the unittest command-line interface, you need to export the environment variable `SUSHI_GRPC_ELKPY_PROTO`, pointing to the Sushi's `.proto` definition file.
  Example:
  ```
  $ export SUSHI_GRPC_ELKPY_PROTO=./sushi_rpc.proto
  $ python3 -m unittest discover -s tests -p '*_test.py'
  ```


pkgId: f2c5d66fb8c20b7642bdaae82d16cbee8184367d40d080a5598fa4e4e72446c3
name: python-ellipsis-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for ellipsis
url: https://github.com/ellipsis-drive-internal/python-package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ellipsis-3.2.0-1.src.rpm
location_href: Packages/python-ellipsis-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This package is meant to help you interact with the Ellipsis API.

  You can install this package using

  `pip install ellipsis`

  For documentation see https://ellipsis-package.readthedocs.io

  This package is meant to ease the use of the Ellipsis Drive API in your Python projects.



  Below are some code examples.

      import ellipsis as el

      
      token = el.account.logIn("username", "password")

      
      maps = el.account.listRoot("myDrive", pathType='layer',
      token=token)

  Another example

      import ellipsis as el

      folderId = '46e1e919-8b73-42a3-a575-25c6d45fd93b'

      token = el.account.logIn("username", "password")

      info = el.path.get(folderId, token)
      layers = el.path.listPath(folderId, pathType='layer', token = token, listAll = True)
      folders = el.path.listPath(folderId, pathType='folder', token = token, listAll = True)


pkgId: fede6010530ed6ef2987c4a2a501b86ed2c2ba36f21d365a6b00dd1d93e580a9
name: python-elmclient-help
arch: noarch
version: 0.28.0
epoch: 0
release: 1
summary: Development documents and examples for elmclient
url: https://github.com/IBM/ELM-Python-Client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elmclient-0.28.0-1.src.rpm
location_href: Packages/python-elmclient-help-0.28.0-1.noarch.rpm
checksum_type: sha256
description:
  16-Dec-2024
  * Authentication using Application passwords now works - for OIDC and SAML-backed authentication providers (OP) - but note below how this has been implemented to perhaps work around the fact that application passwords only work with a single app, os if you want to talk to more than one app, e.g. rm and gc, you have to acquire and specify a password per app. Not extensively tested, please let me know if it works/doesn't work for you!.
  02-Dec-2024
  * Added examples dncompare, validate, trsreader (this is VERY UNFINISHED!) - see the code in the examples folder
  * Fixed oslcquery working from a specific config using -F
  * Fixed oslcquery when trying to select a scoped attribute like `oslc:rm:uses{dcterms:identifier}` wasn't working - note that DN doesn't appear to support retreiving primary text of all artifacts in a module using `oslc:rm:uses{jazz_rm:primaryText}` - text isn't returned
  * Some (unfinished!) internal preparation for demonstrator of the new in 7.1 type query capability https://jazz.net/wiki/bin/view/Main/DNGTypeAPI
  11-Dec-2023
  * Added _validate.py to provide the Validate API, available on all apps (may need to restrict this to just ccm/gc/qm/rm?)
  * Added examples/validate.py as an example of using the validate API - for most options refer to oslcquery readme
  16-Aug-2023
  * tested with Python 3.11.4 - worked OOTB. Now developing using 3.11.4 - won't be back-tested with older Pythons but should work back to 3.9 at least.
  4-May-2023
  * Deprecated RM load_folders() - use find_folder() instead.
  * Added RM create_folder() - this doesn't require doing a forced reload of all folders, because it inserts the new folder into the internal info about folders
  * Added example dn_simple_createfolderpath.py - allows exercising the create_folders() function
  * Added rm-only implementation of create/deliver changeset NOTE these aren't fully finished, specifically hte delivery result may not be obvious(!)
  * Added example dn_simple_typesystemimport_cs.py which shows creating/delivering a changeset around typesystem import


pkgId: 058fcd49a293a2ecf66b897355ce1633054bc76187bed31eee226898ad304dff
name: python-elog-cli-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for elog-cli
url: https://pypi.org/project/elog-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elog-cli-0.1-1.src.rpm
location_href: Packages/python-elog-cli-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  wget http://elog:8080/v1/mock/users-auth -O user.json
  ~/.local/bin/openapi-python-client generate --url http://elog:8080/api-docs --output-path elog_management_backend_client --overwrite


pkgId: 6e5193ed29223f132b7ff2b2061cfa35d724aaa2eb9afc63a225bde7a29130ef
name: python-elroy-help
arch: noarch
version: 0.0.52
epoch: 0
release: 1
summary: Development documents and examples for elroy
url: https://pypi.org/project/elroy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elroy-0.0.52-1.src.rpm
location_href: Packages/python-elroy-help-0.0.52-1.noarch.rpm
checksum_type: sha256
description:
  Elroy is a CLI AI personal assistant with long term memory and goal tracking capabilities. It features:

  - **Long-term Memory**: Elroy maintains memories across conversations
  - **Goal Tracking**: Track and manage personal/professional goals
  - **Memory Panel**: Shows relevant memories during conversations

  ![Goals Demo](images/goals_demo.gif)







  - Docker and Docker Compose
  - Relevant API keys (for simplest setup, set OPENAI_API_KEY)

  This option automatically sets up everything you need, including the required PostgreSQL database with pgvector extension.

  1. Download the docker-compose.yml:
  ```bash
  curl -O https://raw.githubusercontent.com/elroy-bot/elroy/main/docker-compose.yml
  ```

  2. Run Elroy:
  ```bash
  docker compose run --rm elroy
  ```

  The Docker image is publicly available at `ghcr.io/elroy-bot/elroy`.




  - Python 3.9 or higher
  - Relevant API keys (for simplest setup, set OPENAI_API_KEY)
  - PostgreSQL database with pgvector extension

  ```bash
  pip install elroy
  ```

  For the database, either:
  - Let Elroy manage PostgreSQL via Docker (default) (requires Docker)
  - Provide a PostgreSQL connection string, either by setting the `ELROY_POSTGRES_URL` environment variable, or by using the `--postgres_url` flag.




  - Python 3.11 or higher
  - Poetry package manager
  - Relevant API keys (for simplest setup, set OPENAI_API_KEY)
  - PostgreSQL database with pgvector extension

  ```bash

  git clone https://github.com/elroy-bot/elroy.git
  cd elroy


  poetry install


  poetry run elroy
  ```

  For the database, you have the same options as with pip installation:
  - Let Elroy manage PostgreSQL via Docker (default)
  - Provide your own PostgreSQL connection string



  Once installed locally you can:
  ```bash

  elroy chat


  elroy


  echo "Say hello world" | elroy
  ```


  ![Remember command](images/remember_command.gif)

  Elroy provides both CLI commands and in-chat commands (which can be used by both users and the assistant). For full schema information, see [tools schema reference](docs/tools_schema.md).



  Elroy supports both OpenAI and Anthropic language models:


  - OpenAI Models: GPT-4 and variants (gpt-4o, gpt-4o-mini, o1-preview, o1-mini)
  - Anthropic Models: Claude models (sonnet, opus)
  - OpenAI-Compatible APIs: Any provider offering an OpenAI-compatible API endpoint (via --openai-api-base)

  The default model is gpt-4o. Use `elroy --list-models` to see all supported chat models. Model shortcuts are available:
  - `--sonnet`: Use Anthropic's Sonnet model
  - `--opus`: Use Anthropic's Opus model
  - `--4o`: Use OpenAI's GPT-4o model
  - `--4o-mini`: Use OpenAI's GPT-4o-mini model
  - `--o1`: Use OpenAI's o1-preview model
  - `--o1-mini`: Use OpenAI's o1-mini model


  - OpenAI Models: text-embedding-3-small (default, 1536 dimensions)
  - OpenAI-Compatible APIs: Any provider offering OpenAI-compatible embedding endpoints (via --openai-embedding-api-base)



  These commands can be run directly from your terminal:

  - `elroy` - Opens an interactive chat session, or generates a response to stdin input (default command)
  - `elroy --chat` - Equivalent to `elroy`
  - `elroy --remember [-r]` - Create a new memory from stdin or interactively
  - `elroy --list-models` - Lists supported chat models and exits
  - `elroy --show-config` - Shows current configuration and exits
  - `elroy --version` - Show version and exit
  - `elroy --set-persona TEXT` - Path to a persona file to use for the assistant
  - `elroy --reset-persona` - Removes any custom persona, reverting to the default
  - `elroy --show-persona` - Print the system persona and exit
  - `elroy --help` - Show help information and all available options

  Note: Running just `elroy` without any command will default to `elroy chat`.

  The chat interface accepts input from stdin, so you can pipe text to Elroy:
  ```bash
  echo "What is 2+2?" | elroy chat
  ```


  While chatting with Elroy, commands can be used by typing a forward slash (/) followed by the command name. Commands are divided into two categories:


  These commands can only be used by human users:

  - `/print_available_commands` - Show all available commands
  - `/print_system_instruction` - View current system instructions
  - `/refresh_system_instructions` - Refresh system instructions
  - `/reset_system_context` - Reset conversation context
  - `/print_context_messages` - View current conversation context
  - `/add_internal_thought` - Insert an internal thought for the assistant
  - `/exit` - Exit the chat


  These commands can be used by both users and Elroy:


  - `/create_goal` - Create a new goal
  - `/rename_goal` - Rename an existing goal
  - `/print_goal` - View details of a specific goal
  - `/add_goal_to_current_context` - Add a goal to current conversation
  - `/drop_goal_from_current_context` - Remove goal from current conversation
  - `/add_goal_status_update` - Update goal progress
  - `/mark_goal_completed` - Mark a goal as complete
  - `/delete_goal_permanently` - Delete a goal
  - `/get_active_goal_names` - List all active goals


  - `/create_memory` - Create a new memory from text
  - `/print_memory` - View a specific memory
  - `/add_memory_to_current_context` - Add a memory to current conversation
  - `/drop_memory_from_current_context` - Remove memory from current conversation


  - `/contemplate [prompt]` - Ask Elroy to reflect on the conversation or a specific topic


  - `/get_user_full_name` - Get your full name
  - `/set_user_full_name` - Set your full name
  - `/get_user_preferred_name` - Get your preferred name
  - `/set_user_preferred_name` - Set your preferred name


  - `/tail_elroy_logs` - View Elroy's log output
  - `/print_elroy_config` - Display current configuration
  - `/create_bug_report` - Create a bug report with current context
  - `/make_coding_edit` - Make changes to code files in the current repository

  Note: All these commands can be used with a leading slash (/) in the chat interface. The assistant uses these commands without the slash when helping you.




  You can customize Elroy's appearance with these options:

  - `--system-message-color TEXT` - Color for system messages
  - `--user-input-color TEXT` - Color for user input
  - `--assistant-color TEXT` - Color for assistant output
  - `--warning-color TEXT` - Color for warning messages






  * `--config TEXT`: Path to YAML configuration file. Values override defaults but are overridden by explicit flags or environment variables.
  * `--debug / --no-debug`: Whether to fail fast when errors occur, and emit more verbose logging. [env var: ELROY_DEBUG]


  * `--postgres-url TEXT`: Postgres URL to use for Elroy. [env var: ELROY_POSTGRES_URL]


  * `--openai-api-key TEXT`: OpenAI API key, required for OpenAI (or OpenAI compatible) models. [env var: OPENAI_API_KEY]
  * `--openai-api-base TEXT`: OpenAI API (or OpenAI compatible) base URL. [env var: OPENAI_API_BASE]
  * `--openai-embedding-api-base TEXT`: OpenAI API (or OpenAI compatible) base URL for embeddings. [env var: OPENAI_API_BASE]
  * `--openai-organization TEXT`: OpenAI (or OpenAI compatible) organization ID. [env var: OPENAI_ORGANIZATION]
  * `--anthropic-api-key TEXT`: Anthropic API key, required for Anthropic models. [env var: ANTHROPIC_API_KEY]


  * `--chat-model TEXT`: The model to use for chat completions. [env var: ELROY_CHAT_MODEL] [default: gpt-4o]
  * `--embedding-model TEXT`: The model to use for text embeddings. [default: text-embedding-3-small]
  * `--embedding-model-size INTEGER`: The size of the embedding model. [default: 1536]
  * `--enable-caching / --no-enable-caching`: Whether to enable caching for the LLM, both for embeddings and completions. [default: True]
  * `--sonnet`: Use Anthropic's Sonnet model
  * `--opus`: Use Anthropic's Opus model
  * `--4o`: Use OpenAI's GPT-4o model
  * `--4o-mini`: Use OpenAI's GPT-4o-mini model
  * `--o1`: Use OpenAI's o1 model
  * `--o1-mini`: Use OpenAI's o1-mini model


  * `--context-refresh-trigger-tokens INTEGER`: Number of tokens that triggers a context refresh and compression of messages in the context window. [default: 3300]
  * `--context-refresh-target-tokens INTEGER`: Target number of tokens after context refresh / compression, how many tokens to aim to keep in context. [default: 1650]
  * `--max-context-age-minutes FLOAT`: Maximum age in minutes to keep. Messages older than this will be dropped from context, regardless of token limits. [default: 120.0]
  * `--context-refresh-interval-minutes FLOAT`: How often in minutes to refresh system message and compress context. [default: 10.0]
  * `--min-convo-age-for-greeting-minutes FLOAT`: Minimum age in minutes of conversation before the assistant will offer a greeting on login. [default: 10.0]


  * `--l2-memory-relevance-distance-threshold FLOAT`: L2 distance threshold for memory relevance. [env var: ELROY_L2_MEMORY_RELEVANCE_DISTANCE_THRESHOLD] [default: 1.24]
  * `--l2-memory-consolidation-distance-threshold FLOAT`: L2 distance threshold for memory consolidation. [env var: ELROY_L2_MEMORY_CONSOLIDATION_DISTANCE_THRESHOLD] [default: 0.65]
  * `--initial-context-refresh-wait-seconds INTEGER`: Initial wait time in seconds after login before the initial context refresh and compression. [env var: ELROY_INITIAL_CONTEXT_REFRESH_WAIT_SECONDS] [default: 30]


  * `--show-internal-thought`: Show the assistant's internal thought monologue. [default: False]
  * `--system-message-color TEXT`: Color for system messages. [default: #9ACD32]
  * `--user-input-color TEXT`: Color for user input. [default: #FFE377]
  * `--assistant-color TEXT`: Color for assistant output. [default: #77DFD8]
  * `--warning-color TEXT`: Color for warning messages. [default: yellow]
  * `--internal-thought-color TEXT`: Color for internal thought messages. [default: #708090]


  * `--log-file-path TEXT`: Where to write logs. [env var: ELROY_LOG_FILE_PATH]


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




  Distributed under the GPL 3.0.1 License. See `LICENSE` for more information.


pkgId: b3d258eba2dd00bcb67b74443f0a48088d1458ac8686b19609e3456bb18fe697
name: python-elroy-help
arch: noarch
version: 0.0.53
epoch: 0
release: 1
summary: Development documents and examples for elroy
url: https://pypi.org/project/elroy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elroy-0.0.53-1.src.rpm
location_href: Packages/python-elroy-help-0.0.53-1.noarch.rpm
checksum_type: sha256
description:
  [![Discord](https://img.shields.io/discord/1200684659277832293?color=7289DA&label=Discord&logo=discord&logoColor=white)](https://discord.gg/5PJUY4eMce)

  Elroy is a CLI AI personal assistant with long term memory and goal tracking capabilities. It features:

  - **Long-term Memory**: Elroy maintains memories across conversations
  - **Goal Tracking**: Track and manage personal/professional goals
  - **Memory Panel**: Shows relevant memories during conversations

  ![Goals Demo](images/goals_demo.gif)







  - Docker and Docker Compose
  - Relevant API keys (for simplest setup, set OPENAI_API_KEY)

  This option automatically sets up everything you need, including the required PostgreSQL database with pgvector extension.

  1. Download the docker-compose.yml:
  ```bash
  curl -O https://raw.githubusercontent.com/elroy-bot/elroy/main/docker-compose.yml
  ```

  2. Run Elroy:
  ```bash

  docker compose build --no-cache
  docker compose run --rm elroy


  docker compose run --rm elroy --sonnet
  ```

  The Docker image is publicly available at `ghcr.io/elroy-bot/elroy`.




  - Python 3.9 or higher
  - Relevant API keys (for simplest setup, set OPENAI_API_KEY)
  - PostgreSQL database with pgvector extension

  ```bash
  pip install elroy
  ```

  For the database, either:
  - Let Elroy manage PostgreSQL via Docker (default) (requires Docker)
  - Provide a PostgreSQL connection string, either by setting the `ELROY_POSTGRES_URL` environment variable, or by using the `--postgres_url` flag.




  - Python 3.11 or higher
  - Poetry package manager
  - Relevant API keys (for simplest setup, set OPENAI_API_KEY)
  - PostgreSQL database with pgvector extension

  ```bash

  git clone https://github.com/elroy-bot/elroy.git
  cd elroy


  poetry install


  poetry run elroy
  ```

  For the database, you have the same options as with pip installation:
  - Let Elroy manage PostgreSQL via Docker (default)
  - Provide your own PostgreSQL connection string



  Once installed locally you can:
  ```bash

  elroy chat


  elroy


  elroy --message "Say hello world"


  elroy --message "Create a goal" --tool create_goal


  echo "Say hello world" | elroy
  ```


  ![Remember command](images/remember_command.gif)

  Elroy provides both CLI commands and in-chat commands (which can be used by both users and the assistant). For full schema information, see [tools schema reference](docs/tools_schema.md).



  - OpenAI Models: text-embedding-3-small (default, 1536 dimensions)
  - OpenAI-Compatible APIs: Any provider offering OpenAI-compatible embedding endpoints (via --openai-embedding-api-base)



  These commands can be run directly from your terminal:

  - `elroy` - Opens an interactive chat session, or generates a response to stdin input (default command)
  - `elroy --chat` - Equivalent to `elroy`
  - `elroy --remember [-r]` - Create a new memory from stdin or interactively
  - `elroy --list-models` - Lists supported chat models and exits
  - `elroy --show-config` - Shows current configuration and exits
  - `elroy --version` - Show version and exit
  - `elroy --set-persona TEXT` - Path to a persona file to use for the assistant
  - `elroy --reset-persona` - Removes any custom persona, reverting to the default
  - `elroy --show-persona` - Print the system persona and exit
  - `elroy --help` - Show help information and all available options

  Note: Running just `elroy` without any command will default to `elroy chat`.

  The chat interface accepts input from stdin, so you can pipe text to Elroy:
  ```bash
  echo "What is 2+2?" | elroy chat
  ```


  While chatting with Elroy, commands can be used by typing a forward slash (/) followed by the command name. Commands are divided into two categories:


  These commands can only be used by human users:

  - `/print_available_commands` - Show all available commands
  - `/print_system_instruction` - View current system instructions
  - `/refresh_system_instructions` - Refresh system instructions
  - `/reset_system_context` - Reset conversation context
  - `/print_context_messages` - View current conversation context
  - `/add_internal_thought` - Insert an internal thought for the assistant
  - `/exit` - Exit the chat


  These commands can be used by both users and Elroy:


  - `/create_goal` - Create a new goal
  - `/rename_goal` - Rename an existing goal
  - `/print_goal` - View details of a specific goal
  - `/add_goal_to_current_context` - Add a goal to current conversation
  - `/drop_goal_from_current_context` - Remove goal from current conversation
  - `/add_goal_status_update` - Update goal progress
  - `/mark_goal_completed` - Mark a goal as complete
  - `/delete_goal_permanently` - Delete a goal
  - `/get_active_goal_names` - List all active goals


  - `/create_memory` - Create a new memory from text
  - `/print_memory` - View a specific memory
  - `/add_memory_to_current_context` - Add a memory to current conversation
  - `/drop_memory_from_current_context` - Remove memory from current conversation


  - `/contemplate [prompt]` - Ask Elroy to reflect on the conversation or a specific topic


  - `/get_user_full_name` - Get your full name
  - `/set_user_full_name` - Set your full name
  - `/get_user_preferred_name` - Get your preferred name
  - `/set_user_preferred_name` - Set your preferred name


  - `/tail_elroy_logs` - View Elroy's log output
  - `/print_elroy_config` - Display current configuration
  - `/create_bug_report` - Create a bug report with current context
  - `/make_coding_edit` - Make changes to code files in the current repository

  Note: All these commands can be used with a leading slash (/) in the chat interface. The assistant uses these commands without the slash when helping you.




  You can customize Elroy's appearance with these options:

  - `--system-message-color TEXT` - Color for system messages
  - `--user-input-color TEXT` - Color for user input
  - `--assistant-color TEXT` - Color for assistant output
  - `--warning-color TEXT` - Color for warning messages






  * `--config TEXT`: Path to YAML configuration file. Values override defaults but are overridden by explicit flags or environment variables.
  * `--default-persona TEXT`: Default persona to use for assistants. [env var: ELROY_DEFAULT_PERSONA]
  * `--debug / --no-debug`: Whether to fail fast when errors occur, and emit more verbose logging. [env var: ELROY_DEBUG]
  * `--user-token TEXT`: User token to use for Elroy [env var: ELROY_USER_TOKEN]


  * `--postgres-url TEXT`: Postgres URL to use for Elroy. [env var: ELROY_POSTGRES_URL]


  * `--openai-api-key TEXT`: OpenAI API key, required for OpenAI (or OpenAI compatible) models. [env var: OPENAI_API_KEY]
  * `--openai-api-base TEXT`: OpenAI API (or OpenAI compatible) base URL. [env var: OPENAI_API_BASE]
  * `--openai-embedding-api-base TEXT`: OpenAI API (or OpenAI compatible) base URL for embeddings. [env var: OPENAI_API_BASE]
  * `--openai-organization TEXT`: OpenAI (or OpenAI compatible) organization ID. [env var: OPENAI_ORGANIZATION]
  * `--anthropic-api-key TEXT`: Anthropic API key, required for Anthropic models. [env var: ANTHROPIC_API_KEY]


  * `--chat-model TEXT`: The model to use for chat completions. [env var: ELROY_CHAT_MODEL] [default: gpt-4o]
  * `--embedding-model TEXT`: The model to use for text embeddings. [default: text-embedding-3-small]
  * `--embedding-model-size INTEGER`: The size of the embedding model. [default: 1536]
  * `--enable-caching / --no-enable-caching`: Whether to enable caching for the LLM, both for embeddings and completions. [default: True]
  * `--sonnet`: Use Anthropic's Sonnet model
  * `--opus`: Use Anthropic's Opus model
  * `--4o`: Use OpenAI's GPT-4o model
  * `--4o-mini`: Use OpenAI's GPT-4o-mini model
  * `--o1`: Use OpenAI's o1 model
  * `--o1-mini`: Use OpenAI's o1-mini model


  * `--context-refresh-trigger-tokens INTEGER`: Number of tokens that triggers a context refresh and compression of messages in the context window. [default: 3300]
  * `--context-refresh-target-tokens INTEGER`: Target number of tokens after context refresh / compression, how many tokens to aim to keep in context. [default: 1650]
  * `--max-context-age-minutes FLOAT`: Maximum age in minutes to keep. Messages older than this will be dropped from context, regardless of token limits. [default: 120.0]
  * `--context-refresh-interval-minutes FLOAT`: How often in minutes to refresh system message and compress context. [default: 10.0]
  * `--min-convo-age-for-greeting-minutes FLOAT`: Minimum age in minutes of conversation before the assistant will offer a greeting on login. [default: 10.0]
  * `--enable-assistant-greeting / --no-enable-assistant-greeting`: Whether to allow the assistant to send the first message [default: True]


  * `--l2-memory-relevance-distance-threshold FLOAT`: L2 distance threshold for memory relevance. [env var: ELROY_L2_MEMORY_RELEVANCE_DISTANCE_THRESHOLD] [default: 1.24]
  * `--l2-memory-consolidation-distance-threshold FLOAT`: L2 distance threshold for memory consolidation. [env var: ELROY_L2_MEMORY_CONSOLIDATION_DISTANCE_THRESHOLD] [default: 0.65]
  * `--initial-context-refresh-wait-seconds INTEGER`: Initial wait time in seconds after login before the initial context refresh and compression. [env var: ELROY_INITIAL_CONTEXT_REFRESH_WAIT_SECONDS] [default: 30]


  * `--show-internal-thought`: Show the assistant's internal thought monologue. [default: False]
  * `--system-message-color TEXT`: Color for system messages. [default: #9ACD32]
  * `--user-input-color TEXT`: Color for user input. [default: #FFE377]
  * `--assistant-color TEXT`: Color for assistant output. [default: #77DFD8]
  * `--warning-color TEXT`: Color for warning messages. [default: yellow]
  * `--internal-thought-color TEXT`: Color for internal thought messages. [default: #708090]


  * `--log-file-path TEXT`: Where to write logs. [env var: ELROY_LOG_FILE_PATH]


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




  Distributed under the GPL 3.0.1 License. See `LICENSE` for more information.


pkgId: d505d2e68fc9a67970cc07d83b9136baeba3011044d6ea8389da820fc2c49a54
name: python-elsci-peaksel-sdk-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for elsci-peaksel-sdk
url: https://github.com/elsci-io/peaksel-sdk
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-elsci-peaksel-sdk-0.0.1-1.src.rpm
location_href: Packages/python-elsci-peaksel-sdk-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A library to manage chromatography data in Peaksel: upload raw data, fetch the results of parsing (spectra, traces, peaks, injection info, etc).
  Print some spectra info in console:
  ```python
  from peakselsdk.Peaksel import Peaksel
  org = "YOUR ORG NAME"  # or your username if you want to work with your personal data
  auth_header = {"Cookie": "JSESSIONID=YOUR SESSION ID"}  # either cookie or Basic Auth
  raw_data = "/path/to/zip/with/raw-data.zip"
  base_url = "https://peaksel.elsci.io"

  peaksel = Peaksel(base_url, org_name=org, default_headers=auth_header)
  injection_ids = peaksel.injections().upload(raw_data)  # upload your sample
  j = peaksel.injections().get(injection_ids[0])  # fetch Injection info
  for detectorRun in j.detectorRuns:
      spectra = peaksel.blobs().get_spectra(detectorRun.blobs.spectra)  # fetch spectra
      for spectrum in spectra:
          print(f"{spectrum.rt}: {spectrum.x}")
  ```
  Before running this:
  1. You need to [register at Peaksel Hub](https://peaksel.elsci.io), [get a private SaaS](https://elsci.io/peaksel/buy.html) or [install Peaksel](https://elsci.io/docs/peaksel/installation.html) on your machines.
  2. Determine how you want to authenticate (service account or SessionID)

  Service accounts can have their Basic Auth credentials specified in [Peaksel configs](https://elsci.io/docs/peaksel/security/users.html#inmemory-users). This option is available in Private SaaS and on-prem installations. For Peaksel Hub you need to request it explicitly (support@elsci.io). If this option is chosen, then in the code you set up auth headers this way:
  ```python
  from peakselsdk.util.api_util import peaksel_basic_auth_header
  auth_header = {"Authorization": peaksel_basic_auth_header("your username", "your password")}
  ```

  If you're just playing, you can run the code on behalf of your own account. For this copy the cookie from your browser:
  1. In Chrome: open Peaksel -> authenticate -> Press F12
  2. Go to Application tab -> Cookies -> click on the website URL -> copy the Value of the JSESSIONID cookie
  Now in the code you set up Peaksel this way:
  ```python
  auth_header = {"Cookie": "JSESSIONID=YOUR SESSION ID"}
  ```

  All the necessary functionality is exposed from `peakselsdk.Peaksel` class - just use its methods to work with Injections, Batches, Substances (analytes), Peaks, etc.
  * `XxxClient` are classes to communicate with the app API, they are created and returned by `Peaksel` entrypoint
  * Classes like `User`, `Org`, `Injection` capture the actual requests and responses
     * Fields are `camelCased` to match the JSON structure
     * The JSON's `id` is actually stored in `eid` (aka entity id) in the classes. Because `id` has special meaning in Python.
     * Every `__init__()` has `**kwargs` param that is ignored. This is needed to simplify parsing of response JSONs,
       as we always keep the names in the classes and JSONs the same, so when passing those as dict into the constructor,
       the corresponding fields are set. But it's possible that in Peaksel we add a new param, and this would break
       dict->DTO conversion as the param will be unknown. So to be forward-compatible, we add `**kwargs` to capture
       all the unknown fields.

  1. Install [uv](https://github.com/astral-sh/uv) build tool and run `uv build`
  2. In PyCharm mark `src` as Sources Root and `test` as Test Sources Root
  3. To run the tests `./test.sh`


pkgId: 1316ec407b60d44f0a9ec453fc425ac8960f030533e295e3f96abc3e14b62344
name: python-email-smtp-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for email-smtp
url: https://github.com/ouroboroscoding/email-smtp-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-email-smtp-1.0.1-1.src.rpm
location_href: Packages/python-email-smtp-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Handles sending emails using SMTP


  ```
  pip install email-smtp
  ```


  email-smtp requires python 3.10 or higher



  ```python
  from em import send, valid

  def send_email(to, subject, text, html):

  	if valid(to):
  		send(to, subject, {
  			'text': text,
  			'html': html
  		})
  ```



  | Name | Type | Description |
  | ---- | ---- | ----------- |
  | `attachments` | str[] \| {'body': str, 'filename'}[] | A list of attachments to add to the email |
  | `bcc` | str \| str[] | One or more e-mail addresses to send a blind carbon copy to |
  | `cc` | str \| str[] | One or more e-mail addresses to send a carbo copy to |
  | `from` | str | The e-mail address to show as having sent the e-mail |
  | `html` | str | The HTML version of the e-mail to send, this or `text` must be set |
  | `reply-to` | str | The e-mail address to mark as receiving any replies |
  | `text` | str | The text version of the e-mail to send, this or `html` must be set |
  | `unsubscribe` | str | The URL to add to the header for the receiver to be able to unsubscribe |


pkgId: b52e9204c31a02c1f19439f25cedaa86b986779f6a1c58296ce23f7802ad2a48
name: python-embyclient-help
arch: noarch
version: 4.9.0.33
epoch: 0
release: 1
summary: Development documents and examples for embyclient
url: https://emby.media
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-embyclient-4.9.0.33-1.src.rpm
location_href: Packages/python-embyclient-help-4.9.0.33-1.noarch.rpm
checksum_type: sha256
description:
  A Python client for Emby Media Server's API.

  **NOTE**: The [original source code](https://github.com/MediaBrowser/Emby.SDK/tree/master/SampleCode/RestApi/Clients/Python) for this client is auto-generated by Emby's OpenAPI spec.
  This specific client is an automated release of the source code with some minor modifications.
  Any bugs or issues with the client should be reported to the [Emby SDK repository](https://github.com/MediaBrowser/Emby.SDK)



  Python 2.7 (deprecated) or 3.4+



  Install via [pip](https://pypi.org/project/embyclient/):

  ```sh
  pip install embyclient
  ```



  Import the package:

  ```python
  import embyclient
  ```

  Configure a client instance:

  ```python
  import embyclient
  from embyclient.rest import ApiException


  configuration = embyclient.Configuration()
  configuration.api_key['api_key'] = 'YOUR_API_KEY'




  client = embyclient.ApiClient(configuration)
  ```

  Then use the client to interact via specific API services:

  ```python
  activity_log_service = embyclient.ActivityLogServiceApi(client)

  try:
      
      api_response = activity_log_service.get_activity_log_entries(start_index=56, limit=56, min_date='min_date_example')
      print(api_response)
  except ApiException as e:
      print("Exception when calling ActivityLogServiceApi->get_activity_log_entries: %s\n" % e)
  ```



  For more information, please visit [Emby's API documentation](https://swagger.emby.media/?staticview=true).


pkgId: a8530041b40dff3bde7c8aaa990c1e41e60384e1ad7439dd5c7800cec8b7e0f5
name: python-eminus-help
arch: noarch
version: 3.0.1
epoch: 0
release: 1
summary: Development documents and examples for eminus
url: https://pypi.org/project/eminus/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eminus-3.0.1-1.src.rpm
location_href: Packages/python-eminus-help-3.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <!--
  SPDX-FileCopyrightText: 2021 The eminus developers
  SPDX-License-Identifier: Apache-2.0
  -->
  ![eminus logo](https://gitlab.com/wangenau/eminus/-/raw/main/docs/_static/logo/eminus_logo.png)


  [![Version](https://img.shields.io/pypi/v/eminus?color=1a962b&logo=python&logoColor=a0dba2&label=Version)](https://pypi.org/project/eminus)
  [![Python](https://img.shields.io/pypi/pyversions/eminus?color=1a962b&logo=python&logoColor=a0dba2&label=Python)](https://wangenau.gitlab.io/eminus/installation.html)
  [![License](https://img.shields.io/badge/license-Apache2.0-1a962b?logo=python&logoColor=a0dba2&label=License)](https://wangenau.gitlab.io/eminus/license.html)
  [![Coverage](https://img.shields.io/gitlab/pipeline-coverage/wangenau%2Feminus?branch=main&color=1a962b&logo=gitlab&logoColor=a0dba2&label=Coverage)](https://wangenau.gitlab.io/eminus/htmlcov)
  [![Chat](https://img.shields.io/badge/Chat-Discord-1a962b?logo=discord&logoColor=a0dba2)](https://discord.gg/k2XwdMtVec)

  eminus is a pythonic electronic structure theory code.
  It implements plane wave density functional theory (DFT) with self-interaction correction (SIC) functionalities.
  The goal is to create a simple code that is easy to read and easy to extend while using minimal dependencies.
  It is built upon the [DFT++](https://arxiv.org/abs/cond-mat/9909130) pragmas proposed by Tomas Arias et al. that aim to let programming languages and theory coincide.
  This can be shown by, e.g., solving the Poisson equation. In the operator notation of DFT++ the equation reads

  $$
  \phi(\boldsymbol r) = -4\pi\mathcal L^{-1}\mathcal O\mathcal J n(\boldsymbol r).
  $$

  The corresponding Python code (implying that the operators have been implemented properly) reads

  ```python
  def get_phi(atoms, n):
      return -4 * np.pi * atoms.Linv(atoms.O(atoms.J(n)))
  ```



  The [package](https://pypi.org/project/eminus) and all necessary dependencies can be installed with

  ```terminal
  pip install eminus
  ```

  More information about installing eminus can be found [here](https://wangenau.gitlab.io/eminus/installation.html).



  To learn more about the features, usage, or implementation of eminus, take a look inside the [documentation](https://wangenau.gitlab.io/eminus).



  A supplementary paper is available on [arXiv](https://arxiv.org/abs/2410.19438). The following BibTeX key can be used

  ```terminal
  @Misc{Schulze2021,
    author    = {Schulze, Wanja T. and Schwalbe, Sebastian and Trepte, Kai and Gr{\"a}fe, Stefanie},
    title     = {eminus -- Pythonic electronic structure theory},
    year      = {2024},
    doi       = {10.48550/arXiv.2410.19438},
    publisher = {arXiv},
  }
  ```

  To cite a specific version one can select and cite it with [Zenodo](https://doi.org/10.5281/zenodo.5720635).



  This project is licensed under the Apache 2.0 License. See the [license page](https://wangenau.gitlab.io/eminus/license.html) for more details.


pkgId: 94d188b64439a6416b21e8329dd426efb5162b52458d3cbc483185a7ca2aeb16
name: python-emmet-core-help
arch: noarch
version: 0.84.5
epoch: 0
release: 1
summary: Development documents and examples for emmet-core
url: https://github.com/materialsproject/emmet
rpm_license: modified BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-emmet-core-0.84.5-1.src.rpm
location_href: Packages/python-emmet-core-help-0.84.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Pytest Status](https://github.com/materialsproject/emmet/workflows/testing/badge.svg)](https://github.com/materialsproject/emmet/actions?query=workflow%3Atesting)
  [![Code Coverage](https://codecov.io/gh/materialsproject/emmet/branch/main/graph/badge.svg)](https://codecov.io/gh/materialsproject/emmet)

  The Materials API Toolkit for the Materials Project. Emmet defines the core models, data pipelines, the API server, and the convenience CLI.


pkgId: 66a633e934216b6f0c299e46a3b65a3095a468bb0f45757dcac12c2de556a697
name: python-emmetify-help
arch: noarch
version: 0.0.1rc4
epoch: 0
release: 1
summary: Development documents and examples for emmetify
url: https://pypi.org/project/emmetify/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-emmetify-0.0.1rc4-1.src.rpm
location_href: Packages/python-emmetify-help-0.0.1rc4-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/emmetify.svg)](https://pypi.python.org/pypi/emmetify)
  [![versions](https://img.shields.io/pypi/pyversions/emmetify.svg)](https://github.com/emmetify/emmetify-py)
  [![license](https://img.shields.io/github/license/emmetify/emmetify-py.svg)](https://github.com/emmetify/emmetify-py/blob/main/LICENSE)

  Cut your LLM processing costs by up to 90% by transforming verbose HTML into efficient Emmet notation, without losing structural integrity.



  - 💰 **Drastically Reduce Costs** - Process HTML with your LLM agents at a fraction of the cost by using our efficient Emmet-based compression
  - 🎯 **Maintain Performance** - Your LLM agents can still generate XPath and CSS selectors with the same accuracy using the compressed format
  - 🔌 **Seamless Integration** - Emmet syntax is well-understood by all major LLMs thanks to its 10+ years of widespread use in frontend development
  - ⚡ **Fast Processing** - Less tokens means faster processing times for your HTML analysis tasks



  Emmetify converts complex HTML structures into concise Emmet notation. For example:

  ```html
  <div class="container">
      <header class="header">
          <nav class="nav">
              <ul class="nav-list">
                  <li class="nav-item"><a href="#">Link</a></li>
              </ul>
          </nav>
      </header>
  </div>
  ```
  Becomes:
  ```
  div.container>header.header>nav.nav>ul.nav-list>li.nav-item>a[href=#]
  ```

  Using the [OpenAI Tokenizer](https://platform.openai.com/tokenizer), we can see this simple transformation reduces token count from:
  - HTML: 59 tokens
  - Emmet: 20 tokens

  That's 66% fewer tokens while preserving all structural information! And this is just with default settings.

  You can achieve even higher compression rates (up to 90%, or even more depending on the HTML structure) by using advanced configuration options:
  - Removing unnecessary tags
  - Simplifying attributes
  - Optimizing class names
  - Shortening URLs

  Check our documentation for detailed optimization strategies and their impact on token reduction.



  Emmetify leverages [Emmet](https://emmet.io) notation - a powerful and mature syntax that's been a standard in web development for over a decade. While developers typically use Emmet to expand short abbreviations into HTML:

  ```
  div.container>h1{Title}+p{Content}
  ```
  ↓ Expands to ↓
  ```html
  <div class="container">
      <h1>Title</h1>
      <p>Content</p>
  </div>
  ```

  Emmetify uses this well-established syntax in reverse, converting verbose HTML back into this concise format that LLMs can understand just as well as raw HTML.



  ```bash
  pip install emmetify
  ```





  ```python
  from emmetify import Emmetifier
  import requests

  emmetifier = Emmetifier()
  html = requests.get("https://example.com").text
  emmet = emmetifier.emmetify(html)
  print(emmet)
  ```



  Transform verbose HTML into its most essential form while preserving navigational structure. This mode intelligently:
  - Skips non-essential HTML tags
  - Prioritizes important attributes
  - Removes redundant information

  For example, this verbose HTML:

  ```html
  <link rel="stylesheet" href="style.css">
  <div id="main" class="container" style="color: red;" data-test="ignore">Example</div>
  ```

  Becomes this concise Emmet notation:

  ```
  div#main.container{Example}
  ```

  Much shorter, yet retains all necessary information for LLM navigation and processing!



  ```python
  from emmetify import Emmetifier
  import requests
  import openai


  emmetifier = Emmetifier(config={
      "html": {
          "skip_tags": True,
          "prioritize_attributes": True
      }
  })


  html = requests.get("https://example.com").text
  result = emmetifier.emmetify(html)["result"]
  print(result)


  llm = openai.OpenAI()
  prompt = f"Get list of xpath selectors for all the links on the following page: {result}"
  response = llm.chat.completions.create(
      model="gpt-4o-mini",
      messages=[{"role": "user", "content": emmet}],
  )
  ```



  - ✅ HTML
  - 🚧 XML (Coming Soon)
  - 🚧 JSON (Coming Soon)


pkgId: 83874b563d6b88e6791cff7b945a5a25beb2dc6502fff5a6b5a1b376f0372830
name: python-empdens-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for empdens
url: https://pypi.org/project/empdens/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-empdens-1.0.0-1.src.rpm
location_href: Packages/python-empdens-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  **empdens** provides a unified interface to several density estimation packages,
  including an implementation of
  [classifier-adjusted density
  estimation](https://pdfs.semanticscholar.org/e4e6/033069a8569ba16f64da3061538bcb90bec6.pdf).
  Examples include
  - [Basic usage and testing](https://nbviewer.jupyter.org/github/zkurtz/empdens/blob/master/notebooks/demo.ipynb)
  - [Identifying the common and the rare in Census data](https://nbviewer.jupyter.org/github/zkurtz/empdens/blob/master/notebooks/census_demographics.ipynb)
  - [Modest performance on an anomaly detection benchmark](https://nbviewer.jupyter.org/github/zkurtz/empdens/blob/master/notebooks/vowels.ipynb)

  Applications of density estimation include
  - **Detecting data drift**: The reliability of a trained model's prediction at a new data point
  depends on the similarity between the new point and the training data. A
  density function trained on the training data can serve as a warning of data drift
  if the evaluated density at the new point is exceptionally low. One way to focus such an
  analysis is to train and evaluate the density using only several of the most-important
  features in the model.
  - **Mode detection**: Locating regions of high density is a first step to efficiently
  allocate resources to address an epidemic, market a product, etc.
  - **Feature engineering**: The density at a point with respect to any
  subset of the dimensions of a feature space can encode useful information.
  - **Anomaly/novelty/outlier detection**: A "point of low density"
  is a common working definition of "anomaly", although it's not the only one.
  (In astrostatistics, for example,
   a density spike may draw attention as a possible galaxy.)

  Evaluating the performance of a density estimator is not straightforward. We rely on a
  mix of simulation, real-data sanity checks, and cross-validation in special cases,
  as detailed in our
  [evaluation guide](https://nbviewer.jupyter.org/github/zkurtz/empdens/blob/master/notebooks/performance_metrics.ipynb).




  We're [on pypi](https://pypi.org/project/empdens/), so `pip install empdens`.



  Create and activate a virtual env for dev ops:
  ```
  git clone git@github.com:zkurtz/empdens.git
  cd empdens
  pip install uv
  uv sync
  source .venv/bin/activate
  pre-commit install
  ```




  - [A case has been made](https://github.com/Microsoft/LightGBM/issues/2056) for
  extending boosted trees to include density estimation. See also
  [Liu and Wong (2014)](https://arxiv.org/pdf/1401.2597.pdf) and
  [Li, Yang, Wong (2016)](http://papers.nips.cc/paper/6217-density-estimation-via-discrepancy-based-adaptive-sequential-partition.pdf)
  - [A review of density estimation packages in R](https://vita.had.co.nz/papers/density-estimation.pdf)
  appears not to find any approach that can handle more than 6 features
  - A 'nearest neighbors' [fastkde](https://github.com/mjenrungrot/fastKDE)
  - [Random forests](https://github.com/ksanjeevan/randomforest-density-python)
  - [Outlier detection with sklearn](https://scikit-learn.org/stable/auto_examples/plot_anomaly_comparison.html#sphx-glr-auto-examples-plot-anomaly-comparison-py)
  - [Intersection](https://medium.com/datadriveninvestor/generating-fake-data-density-estimation-and-generative-adversarial-networks-3606a37fa95)
  of density estimation and generative adversarial networks



  Infrastructure:
  - expand code testing coverage
  - define new simulations

  Tutorials, starting with
  - how CADE works
  - density estimation trees

  Density estimation:
  - Implement a dimensionality-reduction pre-processing method. Extreme multicolinearly
  is a potential failure mode in CADE because the classifier can trivially distinguish
  fake data from real since the fake data model assumes feature independence.
  - Merge the best of the tree-based methods of LightGBM,
  [detpack](https://cran.r-project.org/web/packages/detpack/index.html),
  [Schmidberger and Frank](https://link.springer.com/content/pdf/10.1007/11564126_26.pdf),
  and
  [astropy.stats.bayesian_blocks](http://docs.astropy.org/en/stable/api/astropy.stats.bayesian_blocks.html).


pkgId: d288579295513ea03fda3f864017e0ae567c736431992b32cfc6d6250193bd70
name: python-empire-platform-api-public-client-help
arch: noarch
version: 5.0.3
epoch: 0
release: 1
summary: Development documents and examples for empire-platform-api-public-client
url: https://pypi.org/project/empire-platform-api-public-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-empire-platform-api-public-client-5.0.3-1.src.rpm
location_href: Packages/python-empire-platform-api-public-client-help-5.0.3-1.noarch.rpm
checksum_type: sha256
description:
      _OpenAPI specification for the **Platform API** of **Empire**, the allocation and nomination platform of BritNed_  ---  Additional documentation available in the API&#39;s [GitHub repository](https://github.com/britned/empire-platform-api)


pkgId: fbd2211dc0018b3fbf277e83dbb05face0c80f1120fc8f5c35017bf6d11bab2b
name: python-empulse-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for empulse
url: https://pypi.org/project/empulse/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-empulse-0.4.1-1.src.rpm
location_href: Packages/python-empulse-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Python Version](https://img.shields.io/pypi/v/empulse)](https://pypi.org/project/empulse/)
  [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ShimantoRahman/empulse)
  ![](https://img.shields.io/pypi/pyversions/empulse)
  ![Tests](https://github.com/ShimantoRahman/empulse/actions/workflows/tests.yml/badge.svg)
  [![DOI](https://zenodo.org/badge/654945788.svg)](https://zenodo.org/doi/10.5281/zenodo.11185663)



  Empulse is a package aimed to enable value-driven analysis in Python.
  The package implements popular value-driven metrics and algorithms in accordance to sci-kit learn conventions.
  This allows the measures to seamlessly integrate into existing ML workflows.



  Install `empulse` via pip with

  ```bash
  pip install empulse
  ```


  You can find the documentation [here](https://shimantorahman.github.io/empulse/).



  We offer custom metrics and models.
  You can use them within the scikit-learn ecosystem.

  ```python

  from sklearn.preprocessing import StandardScaler
  from sklearn.pipeline import Pipeline
  from sklearn.datasets import make_classification
  from sklearn.model_selection import cross_val_score
  from sklearn.metrics import make_scorer


  from empulse.metrics import empc_score
  from empulse.models import ProfLogitClassifier

  X, y = make_classification()

  pipeline = Pipeline([
      ("scale", StandardScaler()),
      ("model", ProfLogitClassifier())
  ])

  cross_val_score(pipeline, X, y, scoring=make_scorer(empc_score, needs_proba=True))
  ```

rpm_license:
  MIT License  Copyright (c) 2023 Shimanto Rahman  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.   ==  Empulse contains code that is licensed by third-party developers.  == SciPy   The Empulse project contains the codes from SciPy project.   Copyright (c) 2001-2002 Enthought, Inc. 2003-2022, SciPy Developers. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   == CostCla   The Empulse project contains the codes from CostCla project.   Copyright (c) 2014, Alejandro Correa Bahnsen All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the {organization} nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 868eced95249ed46557c8a62521e748091cdcc2f8da317c960df0073e458638d
name: python-encord-help
arch: noarch
version: 0.1.154
epoch: 0
release: 1
summary: Development documents and examples for encord
url: https://github.com/encord-team/encord-client-python
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-encord-0.1.154-1.src.rpm
location_href: Packages/python-encord-help-0.1.154-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <p align="center">Encord Python API Client</p>
    <a href="https://encord.com">
      <img src="https://storage.googleapis.com/docs-media.encord.com/encord.png" width="280" alt="Encord logo"/>
    </a>
  </h1>

  [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)





  - Minimal low-level Python client that allows you to interact with Encord's API
  - Supports Python: `3.8`, `3.9`, `3.10` and `3.11`



  * [Encord website](https://encord.com)
  * [Encord web app](https://app.encord.com)
  * [Encord documentation](https://docs.encord.com)



  For full documentation, please visit [Encord Python SDK](https://docs.encord.com/reference/installation-sdk).

  First, install Encord Python API Client using the [pip](https://pip.pypa.io/en/stable/installing) package manager:

  ```bash
  python3 -m pip install encord
  ```

  Then, generate an public-private key pair, and upload the public key to [Encord website](https://www.encord.com/).
  Detailed guide can be found in the [dedicated manual](https://docs.encord.com/docs/annotate-public-keys).

  Passing the private key to the factory, you can initialise the Encord client directly.

  ```python

  from encord import EncordUserClient


  user_client = EncordUserClient.create_with_ssh_private_key(
    ssh_private_key_path="<private_key_path>"
    )
  ```

  For detailed examples and API reference please refer to [Encord SDK documentation](https://python.docs.encord.com/)



  Please report bugs to the [GitHub Issues](https://github.com/encord-team/encord-client-python/issues).
  Just make sure you read the [Encord documentation](https://docs.encord.com) and search for related issues first.


pkgId: 23bf6e755d1dbb19bb19595edd08f702d11f7ab53765aea6c85a34e30d26dcf4
name: python-ensembl-genomio-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for ensembl-genomio
url: https://pypi.org/project/ensembl-genomio/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ensembl-genomio-1.6.0-1.src.rpm
location_href: Packages/python-ensembl-genomio-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-Apache_2.0-blue.svg)](https://github.com/Ensembl/ensembl-genomio/blob/main/LICENSE)
  [![Coverage](https://vectorbase.gitdocs.ebi.ac.uk/ensembl-genomio/coverage-badge.svg)](https://vectorbase.gitdocs.ebi.ac.uk/ensembl-genomio/)
  [![CI](https://img.shields.io/github/checks-status/Ensembl/ensembl-genomio/main?label=CI)](https://gitlab.ebi.ac.uk/vectorbase/ensembl-genomio/-/pipelines)
  [![Release](https://img.shields.io/pypi/v/ensembl-genomio)](https://pypi.org/project/ensembl-genomio)

  Pipelines to turn basic genomic data into Ensembl cores and back.

  This is a multilanguage (Perl, Python) repo providing eHive pipelines and various scripts (see below) to prepare genomic data and load it as [Ensembl core database](http://www.ensembl.org/info/docs/api/core/index.html) or to dump such core databases as file bundles.

  Bundles themselves consist of genomic data in various formats (e.g. fasta, gff3, json) and should follow the corresponding [specification](https://github.com/Ensembl/ensembl-genomio/blob/main/docs/BRC4_genome_loader.md#input-data).




  This repository is publicly available in [PyPI](https://pypi.org), so it can be easily installed with your preferred Python package manager, e.g.:

  ```bash
  pip install ensembl-genomio
  ```



  Pipelines are intended to be run inside the Ensembl production environment. Please, make sure you have all the proper credential, keys, etc. set up.



  Clone:
  ```
  git clone git@github.com:Ensembl/ensembl-genomio.git
  ```

  Install the python part (of the pipelines) and test it:
  ```
  pip install ./ensembl-genomio

  python -c 'import ensembl.io.genomio'
  ```

  Update your perl envs (if you need to)
  ```
  export PERL5LIB=$(pwd)/ensembl-genomio/src/perl:$PERL5LIB
  export PATH=$(pwd)/ensembl-genomio/scripts:$PATH
  ```



  If you need to install "editable" Python package use '-e' option
  ```
  pip install -e ./ensembl-genomio
  ```

  To install additional dependencies (e.g. `[docs]` or `[cicd]`) provide `[<tag>]` string, e.g.:
  ```
  pip install -e ./ensembl-genomio[cicd]
  ```

  For the list of tags see `[project.optional-dependencies]` in [pyproject.toml](https://github.com/Ensembl/ensembl-genomio/blob/main/pyproject.toml).



  - Install python part with the `[docs]` tag
  - Change into repo dir
  - Run `mkdocs build` command

  ```
  git clone git@github.com:Ensembl/ensembl-genomio.git
  cd ./ensembl-genomio
  pip install -e .[docs]
  mkdocs build
  ```



  Please, refer to the "Installation" section of the [Nextflow pipelines document](https://github.com/Ensembl/ensembl-genomio/blob/main/docs/nextflow.md#installation).





  Pipelines are derived from [`Bio::EnsEMBL::Hive::PipeConfig::HiveGeneric_conf`](https://github.com/Ensembl/ensembl-hive/blob/version/2.6/modules/Bio/EnsEMBL/Hive/PipeConfig/HiveGeneric_conf.pm),
  or from [`Bio::EnsEMBL::Hive::PipeConfig::EnsemblGeneric_conf`](https://github.com/Ensembl/ensembl-hive/blob/version/2.6/modules/Bio/EnsEMBL/Hive/PipeConfig/EnsemblGeneric_conf.pm),
  of from [`Bio::EnsEMBL::EGPipeline::PipeConfig::EGGeneric_conf`](https://github.com/Ensembl/ensembl-production-imported/blob/main/src/perl/Bio/EnsEMBL/EGPipeline/PipeConfig/EGGeneric_conf.pm) (see [documentation](https://github.com/Ensembl/ensembl-production-imported/blob/main/docs/EGGeneric.md)).

  And the same perl class prefix used for every pipeline:
    `Bio::EnsEMBL::EGPipeline::PipeConfig::` .

  N.B. Don't forget to specify `-reg_file` option for the `beekeeper.pl -url $url -reg_file $REG_FILE -loop` command.

  ```
  init_pipeline.pl Bio::EnsEMBL::Pipeline::PipeConfig::BRC4_genome_loader_conf
      $($CMD details script) \
      -hive_force_init 1\
      -queue_name $SPECIFIC_QUEUE_NAME \
      -registry $REG_FILE \
      -pipeline_tag "_${PIPELINE_RUN_TAG}" \
      -ensembl_root_dir ${ENSEMBL_ROOT_DIR} \
      -dbsrv_url $($CMD details url) \
      -proddb_url "$($PROD_SERVER details url)""$PROD_DBNAME" \
      -taxonomy_url "$($PROD_SERVER details url)""$TAXONOMY_DBNAME" \
      -release ${RELEASE_VERSION} \
      -data_dir ${INPUT_DIR}/manifests_dir/ \
      -pipeline_dir $OUT_DIR/loader_run \
      ${OTHER_OPTIONS} \
      2> $OUT_DIR/init.stderr \
      1> $OUT_DIR/init.stdout

  SYNC_CMD=$(cat $OUT_DIR/init.stdout | grep -- -sync'$' | perl -pe 's/^\s*//; s/"//g')



  LOOP_CMD=$(cat $OUT_DIR/init.stdout | grep -- -loop | perl -pe 's/^\s*//; s/\s*#.*$//; s/"//g')



  $SYNC_CMD 2> $OUT_DIR/sync.stderr 1> $OUT_DIR/sync.stdout
  $LOOP_CMD 2> $OUT_DIR/loop.stderr 1> $OUT_DIR/loop.stdout
  ```



  | Pipeline name | Description | Document | Comment | Module |
  | - | - | - | - | - |
  | BRC4_genome_loader | creates an [Ensembl core database](http://www.ensembl.org/info/docs/api/core/index.html) from a set of flat files or adds ad-hoc (i.e. organellas) sequences to the existing core  | [BRC4_genome_loader](https://github.com/Ensembl/ensembl-genomio/blob/main/docs/BRC4_genome_loader.md) | | [Bio::EnsEMBL::Pipeline::PipeConfig::BRC4_genome_loader_conf](https://github.com/Ensembl/ensembl-genomio/blob/main/src/perl/Bio/EnsEMBL/Pipeline/PipeConfig/BRC4_genome_loader_conf.pm)
  | BRC4_genome_dumper | | | | |
  | | | | | |
  | BRC4_genome_prepare | | | | |
  | BRC4_addition_prepare | | | | |
  | BRC4_genome_compare | | | | |
  | | | | | |
  | LoadGFF3 | | | | |
  | LoadGFF3Batch | | | | |




  * [trf_split_run.bash](https://github.com/Ensembl/ensembl-genomio/blob/main/scripts/trf_split_run.bash) -- a trf wrapper with chunking support to be used with [ensembl-production-imported DNAFeatures pipeline](https://github.com/Ensembl/ensembl-production-imported/tree/main/src/perl/Bio/EnsEMBL/EGPipeline/PipeConfig/DNAFeatures_conf.pm) (see [docs](https://github.com/Ensembl/ensembl-genomio/blob/main/docs/trf_split_run.md))



  As for now some [Gitlab CI](https://docs.gitlab.com/ee/ci/) pipelines introduced to keep things in shape. Though, this bit is in constant development. Some documentation can be found in [docs for GitLab CI/CD](https://github.com/Ensembl/ensembl-genomio/blob/main/docs/cicd_gitlab.md)



  See [docs](https://github.com/Ensembl/ensembl-genomio/blob/main/docs)



  The Python part of the codebase has now unit tests available to test each module. Make sure you have installed this repository's `[cicd]` dependencies (via `pip install ensembl-genomio[cicd]`) before continuing.

  Running all the tests in one go is as easy as running `pytest` **from the root of the repository**. If you also want to measure, collect and report the code coverage, you can do:
  ```bash
  coverage run -m pytest
  coverage report
  ```

  You can also run specific tests by supplying the path to the specific test file/subfolder, e.g.:
  ```bash
  pytest lib/python/tests/test_schema.py
  ```



  Some of this code and documentation is inherited from the [EnsemblGenomes](https://github.com/EnsemblGenomes) and other [Ensembl](https://github.com/Ensembl) projects. We appreciate the effort and time spent by developers of the [EnsemblGenomes](https://github.com/EnsemblGenomes) and [Ensembl](https://github.com/Ensembl) projects.

  Thank you!


pkgId: 7c88ac8d3f2f7221e909fd46731d5157efb79f6ce09f6436b9c40c46832846a3
name: python-ensemble-kalman-smoother-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for ensemble-kalman-smoother
url: http://www.github.com/colehurwitz/eks
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ensemble-kalman-smoother-3.0.0-1.src.rpm
location_href: Packages/python-ensemble-kalman-smoother-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  We offer two methods for installing the `eks` package:
  * Method 1, `github+conda`: this is the preferred installation method and will give you access to example scripts and data
  * Method 2, `pip`: this option is intended for non-interactive environments, such as remote servers.
  For both installation methods we recommend using
  [conda](https://docs.anaconda.com/free/anaconda/install/index.html)
  to create a new environment in which this package and its dependencies will be installed:
  ```
  conda create --name eks python=3.10
  ```
  Activate the new environment:
  ```
  conda activate eks
  ```
  Make sure you are in the activated environment during the Lightning Pose installation.

  First you'll have to install the `git` package in order to access the code on github.
  Follow the directions [here](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
  for your specific OS.
  Then, in the command line, navigate to where you'd like to install the `eks` package and move
  into that directory:
  ```
  git clone https://github.com/paninski-lab/eks
  cd eks
  ```
  To make the package modules visible to the python interpreter, locally run pip
  install from inside the main `eks` directory:
  ```
  pip install -e .
  ```
  If you wish to install the developer version of the package, run installation like this:
  ```
  pip install -e ".[dev]"
  ```
  For more information on individual modules and their usage, see [Requirements](docs/requirements.md).

  You can also install the `eks` package using the Python Package Index (PyPI):
  ```
  python3 -m pip install ensemble-kalman-smoother
  ```
  Note that you will not have access to the example data or example scripts with the pip install
  option.

  As of now, EKS singlecam features a jitted parallel scan implementation for quickly optimizing the
  smoothing parameter (notably for larger datasets of 10,000+ frames). In order to utilize parallel scan,
  you will need to have a cuda environment with jax enabled. Further instructions can be found in the [jax
  docs](https://jax.readthedocs.io/en/latest/installation.html).

  We provide several example datasets and fitting scripts to illustrate use of the package. See
  [Command-Line Arguments](docs/command-line_arguments.md) for more information on arguments,
  including optional flags and defaults. We recommend starting with the first of four scripts outlined
  below, `singlecam_example.py`, following along with the [Singlecam Overview](docs/singlecam_overview.md)
  if a deeper understanding of EKS is desired.

  The `singlecam_example.py` script demonstrates how to run the EKS code for standard single-camera
  setups.
  Any of the provided datasets are compatible with this script; below we'll use `data/ibl-pupil` as
  our example.
  To run the EKS on the example data, execute the following command from inside this repo:
  ```console
  python scripts/singlecam_example.py --input-dir ./data/ibl-pupil
  ```
  The singlecam script is currently the most up-to-date script with the greatest number of feature
  implementations, including fast smoothing parameter auto-tuning using GPU-driven parallelization.
  [Here](docs/singlecam_overview.md) is a detailed overview of the workflow.

  Coming soon!

  The `mirrored_multicam_example.py` script demonstrates how to run the EKS code for multi-camera
  setups where the pose predictions for a given model are all stored in a single csv file.
  For example, if there is a body part names `nose_tip` and three cameras named
  `top`, `bottom`, and `side`, then the csv file should have columns named
  `nose_tip_top`, `nose_tip_bottom`, and `nose_tip_side`.
  We provide example data in the `data/mirror-mouse` directory inside this repo,
  for a two-view video of a mouse with cameras named `top` and `bot`.
  To run the EKS on the example data provided, execute the following command from inside this repo:
  ```console
  python scripts/mirrored_multicam_example.py --input-dir ./data/mirror-mouse --bodypart-list paw1LH paw2LF paw3RF paw4RH --camera-names top bot
  ```

  The `ibl_pupil_example.py` script requires a `input-dir` which contains lightning-pose or DLC
  model predictions.
  To run this script on the example data provided, execute the following command from inside this repo:
  ```console
  python scripts/ibl_pupil_example.py --input-dir ./data/ibl-pupil
  ```

  The `ibl_paw_multiview_example.py` script requires a `input-dir` which contains lightning-pose
  or DLC model predictions for the left and right camera views, as well as timestamp files to align
  the two cameras.
  To run this script on the example data provided, execute the following command from inside this repo:
  ```console
  python scripts/ibl_paw_multiview_example.py --input-dir ./data/ibl-paw
  ```

  Cole Hurwitz
  Keemin Lee
  Amol Pasarkar
  Matt Whiteway


pkgId: fd181ebf77726a07e30f20f3f62c2d6b0f971d8589c6948f16f145c9ba3e88ae
name: python-ensembledata-help
arch: noarch
version: 0.2.4
epoch: 0
release: 1
summary: Development documents and examples for ensembledata
url: https://ensembledata.com
rpm_license: LICENCE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ensembledata-0.2.4-1.src.rpm
location_href: Packages/python-ensembledata-help-0.2.4-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/ensembledata?color=%2334D058&label=pypi%20package)](https://pypi.org/project/ensembledata/)
  [![pypi](https://img.shields.io/pypi/pyversions/ensembledata.svg)](https://pypi.org/project/ensembledata/)



  Check out the [API docs](https://ensembledata.com/apis/docs) to see which endpoints are available for each social media and for detailed descriptions of their parameters and functionality.



  Install the package with pip as you would any other python package.

  ```bash
  pip install ensembledata
  ```



  - The package only supports Python 3.7 and above.



  [Register](https://dashboard.ensembledata.com/register) to get your free API token.

  ```python
  from ensembledata.api import EDClient


  client = EDClient("API-TOKEN")
  result = client.tiktok.user_info_from_username(username="daviddobrik")

  print("Data: ", result.data)
  print("Units charged:", result.units_charged)




  ```


  Get started with the [TikTok API Guide](https://github.com/ensembledata/tiktok-scraper). Find out which endpoints are available, and how you can use them with examples using the ensembledata python package.


  Get started with the [Instagram API Guide](https://github.com/ensembledata/instagram-scraper). Find out which endpoints are available, and how you can use them with examples using the ensembledata python package.

  <br>
  <br>



  If you find that one of the endpoints from our [API docs](https://ensembledata.com/apis/docs) is not yet available in this package, you can use the `EDClient.request` method to specify the endpoint manually in the meantime.

  ```python
  from ensembledata.api import EDClient

  client = EDClient("API-TOKEN")
  result = client.request("/instagram/[example]", params={"foo": "...", "bar": "..."})
  ```

  If you find that one the parameters to an existing endpoint is missing, you can still send this parameter via the `extra_params` dictionary which is available on all endpoint methods. See the example below:
  ```python
  from ensembledata.api import EDClient

  client = EDClient("API-TOKEN")
  result = client.instagram.user_info(username="...", extra_params={"baz": "..."})
  ```

  <br>
  <br>



  In the [API docs](https://ensembledata.com/apis/docs), each endpoint lists a handful of possible errors the API may respond with. You can handle these errors by catching the `EDError` exception.

  ```python
  from ensembledata.api import EDClient, EDError, errors


  client = EDClient("API-TOKEN")
  try:
      result = client.tiktok.user_info_from_username(username="daviddobrik")
  except EDError as e:

      
      if e.status_code == errors.STATUS_429_RATE_LIMIT_EXCEEDED:
          print(e.detail)

      
      if e.status_code == errors.STATUS_493_SUBSCRIPTION_EXPIRED:
          print(e.detail)

  except Exception as e:
      
      
      pass


  ```

  <br>
  <br>



  This package provides an asynchronous client, `EDAsyncClient`, which will give you access to async versions of all the same methods that can be found on the `EDClient`.

  ```python
  import asyncio

  from ensembledata.api import EDAsyncClient


  async def main():
      client = EDAsyncClient("API-TOKEN")
      result = await client.tiktok.user_info_from_username(username="daviddobrik")

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



  By default the `EDClient` will perform 3 retries when it encounters network issues. If you would like to customise this behaviour, you can pass in the `max_network_retries` param as show below:

  Note: if the request times out, it will not be retried.

  ```python
  from ensembledata.api import EDClient

  client = EDClient("API-TOKEN", max_network_retries=5)
  ```



  If you would like control over the read timeout, you can configure this either for all request by setting `timeout` when creating the `EDClient`, or you can specify the `timeout` per request, on any of the individual methods as shown below:

  Note: the timeout is specified in seconds.

  ```python
  from ensembledata.api import EDClient

  client = EDClient("API-TOKEN", timeout=120)
  result = client.tiktok.user_info_from_username(username="daviddobrik", timeout=10)
  ```



  The package uses type hints, and is type checked with the latest version of `mypy`. If you experience any type checking related issues with the package, please let us know by creating an issue.


pkgId: 139a8ce9aba03214339df5d3f830fffd08e9581823ee00d9548300af0c88c89b
name: python-envex-help
arch: noarch
version: 4.0.2
epoch: 0
release: 1
summary: Development documents and examples for envex
url: https://pypi.org/project/envex/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-envex-4.0.2-1.src.rpm
location_href: Packages/python-envex-help-4.0.2-1.noarch.rpm
checksum_type: sha256
description:
  `envex` is a dotenv `.env` aware environment variable handler with typing features and Hashicorp vault support.

  [![PyPI version](https://badge.fury.io/py/envex.svg)](https://badge.fury.io/py/envex)
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)



  This module offers a convenient interface for managing application environments and configurations while adhering to the [12-factor app methodology](https://12factor.net). It avoids having any environment-specific variables and security-sensitive data within application code.

  An `Env` instance delivers a lot of functionality by providing a type-smart front-end to `os.environ`, providing a superset of `os.environ` functionality.



  ```shell
  pip install envex
  ```

  `envex` expects Python 3.11 or later; 3.7 through 3.10 should also work but haven't been tested.



  In addition to the standard `os.environ` functionality with automatic type conversion, `envex` provides the following features:


  When enabled with the `decrypt=True` argument and provided with the decryption password `envex` searches for `.env.enc` files first but falls back to `.env`.
  Using encrypted environment files avoids using plain text files on the filesystem that contain sensitive information.
  The provided `envcrypt` utility conveniently allows conversion between encrypted and non-encrypted formats.


  Alternatively, `envex` provides seamless integration with Hashicorp Vault. This reduces the need to store plaintext secrets on the filesystem and provides a more secure approach for managing secrets.
  Hashicorp vault functionality is optional, and is activated automatically when the `hvac` module is installed into the active virtual environment, and where connection and authentication to Vault succeed.
  Values fetched from Vault are cached by default to reduce the overhead of the api call.
  If this is of concern, caching can be disabled using the`enable_cache=False` parameter to Env.


  `envex` provides many features not available in other dotenv handlers (python-dotenv, etc.) including recursive
  expansion of "template" style variables, supporting don't-repeat-yourself (DRY) patterns.

  `envex` provides multiple ways to fetch environment variables:
  ```python
  from envex import env

  assert env['HOME'] == '/Users/username'

  env['TESTING'] = 'This is a test'
  assert env.get('TESTING') == 'This is a test'
  assert env['TESTING'] == 'This is a test'
  assert env('TESTING') == 'This is a test'
  ```

  It provides the ability to set variable defaults without overriding, much the same as a standard python dict:
  ```python
  import os

  assert os.environ['TESTING'] == 'This is a test'

  assert env.get('UNSET_VAR') is None
  env.set('UNSET_VAR', 'this is now set')
  assert env.get('UNSET_VAR') is not None
  env.setdefault('UNSET_VAR', 'and this is a default value but only if not set')
  assert env.get('UNSET_VAR') == 'this is now set'
  del env['UNSET_VAR']
  assert env.get('UNSET_VAR') is None
  ```

  Note that there is a subtle difference between
  - `env.get(<variable>, default=<default value>)` and
  - `env(<variable>, default=<default value>)`.
  If the variable is initially unset, the former simply returns the default value or None,
  but the second also sets the value to the default value if one was provided in the environment, unless it was already set.

  An Env instance can also read a `.env` (the default name) file and update the application environment accordingly.
  It can read this either when created with `Env(readenv=True)` or directly by using the method `read_env()`.
  If provided, the `readenv=True` parameter enable reading environment files according to the search_path
  provided (the current directory by default) and the `parents=True` parameter extends the search to parent directories should the initial target not be found.

  To override the default name of the environment file, use the `DOTENV` environment variable.

  Variables in environment files will not overwrite existing environment variables by default. `overwrite=True` must be used to change this behaviour.

  Env can also be passed one or more BytesIO or String IO objects as positional parameters from which to read environment variables are read as though they were files.
  IO objects passed in this way differ only in that by default variables evaluated from their content overwrites existing
  variables as though `overwrite=True` was used. To change the default behaviour, explicitly use `overwrite=False`.

  Other kwargs that can be passed to `Env` when created:

  * environ (env): pass the environment to update, default is os.environ, passing an empty dict will create a new env
  * readenv (bool): search for and read .env files (default is False)
  * env_file (str): name of the env file, `os.environ["DOTENV"]` if set, or `.env` is the default
  * search_path (str or list): a single path or list of paths to search for the env files
    search_path may also be passed as a colon-separated list (or semicolon on Windows) of directories to search.
  * parents (bool): search (or not) parents of dirs in the search_path
  * overwrite (bool): overwrite already set values read from .env, default is to only set if not currently set
  * update (bool): push update to os.environ if true (default) otherwise changes internally only
    note that the presence of "export" in the .env file will override this individually and the value will be exported
  * working_dirs (bool): add CWD for the current process and PWD of source .env file
  * exception: (optional) Exception class to raise on error (default is `KeyError`)
  * errors: bool whether to raise error on missing env_file (default is False)
  * decrypt: bool whether to support decryption of encrypted env files (default is False)
  * password: str the password, environment variable or file/path to use for decryption (see below)
  * kwargs: (keyword args, optional) additional environment variables to add/override

  In addition, Env supports a few HashiCorp Vault configuration parameters as well:

  * url: (str, optional) vault url, default is `$VAULT_ADDR`
  * token: (str, optional) vault token, default is `$VAULT_TOKEN` or content of `~/.vault-token`
  * cert: (tuple, optional) (cert, key) path to client SSL certificate and key files
  * verify: (bool, optional) whether to verify server cert (default is True)
  * base_path: (optional) secrets base path, or "environment" for secrets (default is None).
  * enable_cache: bool whether to cache values fetched from Vault (default is True)
    This is used to prefix the path to the secret, i.e. `f"/secret/{base_path}/key"`.

  Some type-smart functions act as an alternative to `Env.get` and having to parse the result:
  ```python
  from envex import env

  env['AN_INTEGER_VALUE'] = 2875083
  assert env.get('AN_INTEGER_VALUE') == '2875083'
  assert env.int('AN_INTEGER_VALUE') == 2875083
  assert env('AN_INTEGER_VALUE', type=int) == 2875083

  env['A_TRUE_VALUE'] = True
  assert env.get('A_TRUE_VALUE') == 'True'
  assert env.bool('A_TRUE_VALUE') is True
  assert env('A_TRUE_VALUE', type=bool) is True

  env['A_FALSE_VALUE'] = 0
  assert env.get('A_FALSE_VALUE') == '0'
  assert env.int('A_FALSE_VALUE') == 0
  assert env.bool('A_FALSE_VALUE') is False
  assert env('A_FALSE_VALUE', type=bool) is False

  env['A_FLOAT_VALUE'] = 287.5083
  assert env.get('A_FLOAT_VALUE') == '287.5083'
  assert env.float('A_FLOAT_VALUE') == 287.5083
  assert env('A_FLOAT_VALUE', type=float) == 287.5083

  env['A_LIST_VALUE'] = '1,"two",3,"four"'
  assert env.get('A_LIST_VALUE') == '1,"two",3,"four"'
  assert env.list('A_LIST_VALUE') == ['1', 'two', '3', 'four']
  assert env('A_LIST_VALUE', type=list) == ['1', 'two', '3', 'four']
  ```

  Environment variables are always stored as strings.
  This is enforced by the underlying os.environ, but also true of any provided environment, which must use the `MutableMapping[str, str]` contract.



  To enhance security of environment files that exist on the filesystem `envex` supports the creation and use of AES-256 encrypted files.

  Encrypted `.env` files are named as `.env.enc` by default (strictly, `${DOTENV:-.env}.enc`), to distinguish them from the unencrypted version, but this is only by convention; both to distinguish the files visually, and to prevent other dot-env readers from using them.

  If the feature is enabled and a pass phrase is provided when the environment file is read, `envex` determines automatically if it contains encrypted data. If the `.enc` version of the environment file does not exist, the .env file - encrypted or not - is used as a fallback, but will otherwise be ignored.

  The `envcrypt` CLI utility supports the encryption and decryption of environment files.
  ```shell
  usage: envcrypt.py [-h] [-P PASSWORD | -E ENVIRON | -F FILE] [-e | -d] [-r] [-v] input [output]

  Block data encryption using

  positional arguments:
  input                    File to encrypt or decrypt
  output                   Output file (optional) (default: None)

  options:
  -h, --help               show this help message and exit

  -P, --password PASSWORD  Use given password (default: None)
  -E, --environ ENVIRON    Read password from provided environment variable (default: None)
  -F, --file FILE          Read password from a given file (default: None)

  -e, --encrypt            Use given password (default: False)
  -d, --decrypt            Read password from provided environment variable (default: False)

  -r, --rm                 Remove input file after successful conversion (default: False)
  -v, --verbose            Increase output verbosity (default: False)

  ```
  Either `--encrypt` or `--decrypt` must be provided

  A pass phrase is required, one of `--password`, `--environ`, or `--file` must also be given. If the pass phrase is not provided, the utility will prompt for it stdin is available and is a terminal.

  After an encryption or decryption operation, the input file is retained by default, but can be removed using the `--rm` option.

  Specifying the output filename is optional, and if not given the utility will append `.enc` to the input filename for encryption, or remove `.enc` for decryption. The --rm option will remove the input file on success.

  Note that similar to use of the Vault option, the value of encrypted variables is not published (exported) to the process environment unless the "export" prefix is used in the decrypted environment file, and therefore remains hidden from external processes.
  However, the pass phrase must be available in order for the environment to be read, and therefore the security of the encrypted file is only as strong as the security of that pass phrase.

  Three options are available when using the `Env` class to read encrypted environment files.
  A value passed to the password parameter can be a string which is by default the plain text passphrase.
  If it is prefixed by `$` then it reads the passphrase via the named environment variable, or if it is prefixed by `@` it is read read from a file.



  While slightly less convenient (having to manually encrypt and decrypt environment files), the benefits of using encrypted environment files are:

  - Prevents sensitive data leakage from plaintext `.env` files.
  - Ideal for use in shared or distributed systems.
  - Mitigates risks associated with misconfigured access permissions.
  - Provides an additional layer of security for sensitive data.

  Also, encrypted .env files are not available to other .env aware software.



  In addition to handling of the os environment and .env files - encrypted or plain text - `envex` supports selectively fetching secrets from Hashicorp Vault using the kv.v2 engine.
  This provides a secure secrets store, and completely avoids exposing secrets in plain text on the filesystem and in particular in published docker images.
  It also prevents storing secrets in the operating system’s environment, which can be inspected by external processes.

  This document does not cover how to set up and configure a Vault server, but you can find useful resources on the following websites:

  - [hashicorp.com](https://developer.hashicorp.com/vault) for the developer documentation and detailed information and tutorials on setting up and hosting your own vault server, and
  - [vaultproject.io](https://www.vaultproject.io/) for information about HashiCorp's managed cloud offering.

  To access the Vault server, you need a token with a role that has read permission for the path to the secrets.
  A read-only profile is the strongly recommended policy for tokens used at runtime by the application.

  This library provides a utility called `env2hvac` that can import (create or update) a typical .env file into vault. The
  utility uses a prefix that consists of an application name and an environment name, using the format <appname>/<envname>/<key> - for example, myapp/prod/DB_PASSWORD. The utility requires that the token has a role with create permission for the base secrets path on the vault server.
  The utility currently assumes that the kv secrets engine is mounted at secret/. The final path where the secrets are stored will be secret/data/<appname>/<envname>/<key>.



  The SecretsManager and Vault client leverage environment variables for their configuration.
  This ensures a degree of transparency as it allows the client to use them but mitigates the need for the client code to be aware of their presence.
  A summary of these variables is in the following table:


  | Variable          | Description                                                            |
  | ----------------- | ---------------------------------------------------------------------- |
  | VAULT_ADDR        | The URL of the vault server                                            |
  | VAULT_TOKEN       | The vault token to use for authentication                              |
  | VAULT_CACERT      | The path to the CA certificate to use for TLS verification             |
  | VAULT_CAPATH      | The path to a directory of CA certificates to use for TLS verification |
  | VAULT_CLIENT_CERT | The path to the client certificate to use for TLS connection           |
  | VAULT_CLIENT_KEY  | The path to the client key to use for TLS connection                   |


pkgId: 318a3ca3b4e713241fd2c48529a9aa5d360208aff7d1a71309b1fbc297c46025
name: python-envisionhgdetector-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for envisionhgdetector
url: https://github.com/wimpouw/envisionhgdetector
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-envisionhgdetector-0.0.2-1.src.rpm
location_href: Packages/python-envisionhgdetector-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for detecting and classifying hand gestures using MediaPipe Holistic and deep learning.
  <div align="center">Wim Pouw (wim.pouw@donders.ru.nl)</div>


  This package provides a straightforward way to detect hand gestures in a variety of videos using a combination of MediaPipe Holistic features and a convolutional neural network (CNN). We plan to update this package with better predicting network in the near future, and we plan to also make an evaluation report so that it is clear how it performs for several types of videos. For now, feel free to experiment. If your looking to just quickly generate isolate some gestures into elan, this is the package for you. Do note that annotation by rates will be much superior to this gesture coder.

  The package performs:

  * Feature extraction using MediaPipe Holistic (hand, body, and face features)
  * Post-hoc gesture detection using a pre-trained CNN model, that I trained on SAGA, TEDM3D dataset, and the zhubo, open gesture annotated datasets.
  * Automatic annotation of videos with gesture classifications
  * Output generation in CSV format and ELAN-compatible files, and video labeled

  Currently, the detector can identify:
  - Just a general hand gesture, ("Gesture")
  - Movement patterns ("Move"; this is only trained on SAGA, because these also annotated movements that were not gestures, like nose scratching); it will therefore be an unreliable category perhaps



  ```bash / cmd / anaconda prompt
  pip install envisionhgdetector
  ```

  Note: This package is CPU-only for wider compatibility and ease of use.



  ```python
  from envisionhgdetector import GestureDetector


  detector = GestureDetector(
      motion_threshold=0.8,    # Sensitivity to motion
      gesture_threshold=0.8,   # Confidence threshold for gestures
      min_gap_s=0.3,          # Minimum gap between gestures
      min_length_s=0.3        # Minimum gesture duration
  )


  results = detector.process_folder(
      video_folder="path/to/videos",
      output_folder="path/to/output"
  )
  ```



  The detector uses 29 features extracted from MediaPipe Holistic, including:
  - Head rotations
  - Hand positions and movements
  - Body landmark distances
  - Normalized motion metrics





  The detector generates three types of output in your specified output folder:

  1. Automated Annotations (`/output/automated_annotations/`)
     - CSV files with frame-by-frame predictions
     - Contains confidence values and classifications for each frame
     - Format: `video_name_confidence_timeseries.csv`

  2. ELAN Files (`/output/elan_files/`)
     - ELAN-compatible annotation files (.eaf)
     - Contains time-aligned gesture segments
     - Useful for manual verification and research purposes
     - Format: `video_name.eaf`

  3. Labeled Videos (`/output/labeled_videos/`)
     - Processed videos with visual annotations
     - Shows real-time gesture detection and confidence scores
     - Useful for quick verification of detection quality
     - Format: `labeled_video_name.mp4`



  The package builds on previous work in gesture detection, particularly focused on using MediaPipe Holistic for comprehensive feature extraction. The CNN model is designed to handle complex temporal patterns in the extracted features.


  - Python 3.7+
  - tensorflow-cpu
  - mediapipe
  - opencv-python
  - numpy
  - pandas



  If you use this package, please cite:

  Pouw, W. (2024). EnvisionHGDetector: Hand Gesture Detection Using a Convolutional Neural Network [Version 0.0.1]. Retrieved from: https://github.com/WimPouw/envisionhgdetector



  Zhubo dataset (used for training):
  Bao, Y., Weng, D., & Gao, N. (2024). Editable Co-Speech Gesture Synthesis Enhanced with Individual Representative Gestures. Electronics, 13(16), 3315.

  SAGA dataset (used for training)
  Lücking, A., Bergmann, K., Hahn, F., Kopp, S., & Rieser, H. (2010). The Bielefeld speech and gesture alignment corpus (SaGA). In LREC 2010 workshop: Multimodal corpora–advances in capturing, coding and analyzing multimodality.

  TED M3D:
  Rohrer, Patrick. A temporal and pragmatic analysis of gesture-speech association: A corpus-based approach using the novel MultiModal MultiDimensional (M3D) labeling system. Diss. Nantes Université; Universitat Pompeu Fabra (Barcelone, Espagne), 2022.

  MediaPipe:
  Lugaresi, C., Tang, J., Nash, H., McClanahan, C., Uboweja, E., Hays, M., ... & Grundmann, M. (2019). MediaPipe: A framework for building perception pipelines. arXiv preprint arXiv:1906.08172.

  Adapted CNN Training and inference code:
  Pouw, W. (2024). EnvisionBOX modules for social signal processing (Version 1.0.0) [Computer software]. https://github.com/WimPouw/envisionBOX_modulesWP

  Original Noddingpigeon Training code:
  Yung, B. (2022). Nodding Pigeon (Version 0.6.0) [Computer software]. https://github.com/bhky/nodding-pigeon



  Feel free to help improve this code. As this is primarily aimed at making automatic gesture detection easily accessible for research purposes, contributions focusing on usability and reliability are especially welcome (happy to collaborate).


pkgId: 77bbc10325733beef8c7f7fa9b4f9794bc976d041d7ff6850580751f849763d7
name: python-envoy-schema-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for envoy-schema
url: https://github.com/bsgip/envoy-schema
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-envoy-schema-0.10.0-1.src.rpm
location_href: Packages/python-envoy-schema-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  Public schema for the models/schema associated all envoy API endpoints.

  This repository was built as a shared dependency for the envoy utility server and any external clients wishing to integrate.

  Envoy: https://github.com/bsgip/envoy




  The models served under `envoy_schema.server` are derived from the following standards:

  * [IEEE: Smart Energy Profile (2030.5-2018)](https://standards.ieee.org/ieee/2030.5/5897/)
  * [Sunspec: Common Smart Inverter Profile](https://sunspec.org/2030-5-csip/)
  * [Common Smart Inverter Profile (Australia)](https://csipaus.org/)




  The models served under `envoy_schema.admin` are typically only used for services directly integrating with the envoy utility server (via the admin server). This is for machine-machine services that are not typically exposed externally.



  Install directly from pypi

  `pip install envoy_schema`




  To install `envoy-schema` for development purposes, after cloning this repository:

  ```
  pip install -e .[dev, test]
  pytest
  ```

  We use the following linting/formatting tools:
  * [bandit](https://pypi.org/project/black/)
  * [flake8](https://pypi.org/project/flake8/)
  * [mypy](https://pypi.org/project/mypy/)

  Contributions via a pull request are welcome but will be validated using the above tools.

  Tests can be run with: `pytest` from the root directory.


pkgId: 07e24131930255ad0267ef62f57163cbf52b9668bb21cc9176f51b092df068cf
name: python-envstack-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for envstack
url: http://github.com/rsgalloway/envstack
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-envstack-0.7.2-1.src.rpm
location_href: Packages/python-envstack-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  Environment variable management system.
  | Feature | Description |
  |---------|-------------|
  | Namespaced environments | Environments in envstack are namespaced, allowing you to organize and manage variables based on different contexts or projects. Each environment stack can have its own set of variables, providing a clean separation and avoiding conflicts between different environments. |
  | Environment stacks | Allows you to manage environment variables using .env files called environment stacks. These stacks provide a hierarchical and contextual approach to managing variables. |
  | Hierarchical structure | Stacks can be combined and have a defined order of priority. Variables defined in higher scope stacks flow from higher scope to lower scope, left to right. |
  | Variable expansion modifiers | Supports bash-like variable expansion modifiers, allowing you to set default values for variables and override them in the environment or by higher scope stacks. |
  | Platform-specific variables | Stacks can have platform-specific variables and values. This allows you to define different values for variables based on the platform. |
  | Variable references | Variables can reference other variables, allowing for more flexibility and dynamic value assignment. |
  | Multi-line values | Supports variables with multi-line values. |
  | Includes | Stack files can include other stacks, making it easy to reuse and combine different stacks. |
  | Python API | Provides a Python API that allows you to initialize and work with environment stacks programmatically. Easily initialize pre-defined environments with Python scripts, tools, and wrappers. |
  | Running commands | Allows you to run command line executables inside an environment stack, providing a convenient way to execute commands with a pre-defined environment. |
  | Wrappers | Supports wrappers, which are command line executable scripts that automatically run a given command in the environment stack. This allows for easy customization and management of environments. |
  | Shell integration | Provides instructions for sourcing the environment stack in your current shell, allowing you to set and clear the environment easily. |

  The easiest way to install:
  ```bash
  $ pip install -U envstack
  ```
  Alternatively,
  ```bash
  $ git clone https://github.com/rsgalloway/envstack
  $ cd envstack
  $ python setup.py install
  ```

  If installing from source to a network location, you can use
  [distman](https://github.com/rsgalloway/distman) to
  install envstack using the provided `dist.json` file:
  ```bash
  $ ENVPATH=./env distman [-d]
  ```
  Using distman will deploy the targets defined in the `dist.json` file to the
  root folder defined by `${DEPLOY_ROOT}` (defined in `env/default.env`).

  Envstack looks for .env files in directories specified by `${ENVPATH}` and i
  the current working directory. Start by getting the latest `default.env`
  environment stack file:
  ```bash
  $ wget -O default.env \
  https://raw.githubusercontent.com/rsgalloway/envstack/master/env/default.env
  ```
  Set `$ENVPATH` to the directory containing your environment stack files:
  ```bash
  $ export ENVPATH=/path/to/env/stack/files
  ```
  Define as many paths as you want, and envstack will search for stack file in
  order from left to right, for example:
  ```bash
  $ export ENVPATH=/mnt/pipe/dev/env:/mnt/pipe/prod/env
  ```
  In the case above, stack files in `/mnt/pipe/dev/env` will take precedence over those
  found in `/mnt/pipe/prod/env`.

  Running the `envstack` command will show you the default environment stack,
  defined in the `default.env` stack file:
  ```bash
  $ envstack
  DEPLOY_ROOT=${ROOT}/${ENV}
  ENV=prod
  ENVPATH=${DEPLOY_ROOT}/env:${ENVPATH}
  HELLO=${HELLO:=world}
  LOG_LEVEL=${LOG_LEVEL:=INFO}
  PATH=${DEPLOY_ROOT}/bin:${PATH}
  PYTHONPATH=${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
  ROOT=/mnt/pipe
  STACK=default
  ```
  If you are not seeing the above output, make sure the `default.env`
  stack file is in your `$ENVPATH` or current working directory.
  > NOTE: The name of the current stack will always be stored in `${STACK}`.
  To see stacks, pass the stack name as the first arg. Environment stacks can be
  combined, in order of priority (variables defined in stacks flow from higher
  scope to lower scope, left to right):
  ```bash
  $ envstack [STACK [STACK ...]]
  ```

  Environment stack files are also executable scripts that can be run directly:
  ```bash
  $ ./env/test.env
  DEPLOY_ROOT=${ROOT}/${STACK}
  ENV=${STACK}
  ENVPATH=${DEPLOY_ROOT}/env:${ROOT}/prod/env
  HELLO=${HELLO:=world}
  LOG_LEVEL=DEBUG
  PATH=${DEPLOY_ROOT}/bin:${ROOT}/prod/bin:${PATH}
  PYTHONPATH=${DEPLOY_ROOT}/lib/python:${ROOT}/prod/lib/python:${PYTHONPATH}
  ROOT=/mnt/pipe
  STACK=test
  ```
  Run commands inside a specific environment stack file:
  ```bash
  $ ./env/test.env -- <command>
  ```
  For example:
  ```bash
  $ ./env/hello.env -- echo {HELLO}
  world
  ```
  Export a specific environment stack file:
  ```bash
  $ ./env/hello.env --export
  ```

  Envstack uses bash-like variable expansion modifiers. Setting `$VAR` to a fixed
  value means `$VAR` will always use that value. Using an expansion modifier
  allows you to override the value:
  | Value | Description |
  |---------------------|-------------|
  | value |  'value' |
  | ${VAR:-default} | os.environ.get('VAR', 'default') |
  | ${VAR:=default} | VAR = VAR or 'default' |
  | ${VAR:?error message} | if not VAR: raise ValueError() |
  Without the expansion modifier, values are set and do not change (but can be
  overridden by lower scope stacks, i.e. a lower scope stack file may override
  a higher one).
  If we define `$HELLO` like this:
  ```yaml
  HELLO: world
  ```
  Then the value is set and cannot be modified (except by lower scope stacks):
  ```bash
  $ envstack -- echo {HELLO}
  world
  $ HELLO=goodbye envstack -- echo {HELLO}
  world
  ```
  With an expansion modifier, variables have a default value and can also be
  overridden in the environment, or by higher scope stacks:
  ```yaml
  HELLO: ${HELLO:=world}
  ```
  Here we show the default value, and how we can override it in the environment:
  ```bash
  $ envstack -- echo {HELLO}
  world
  $ HELLO=goodbye envstack -- echo {HELLO}
  goodbye
  ```

  Several example or starter stacks are available in the [env folder of the
  envstack repo](https://github.com/rsgalloway/envstack/tree/master/env).
  To create a blank environment stack, create a new envstack file and declare some
  variables.
  Create a new stack file called "foobar.env" and make it executable (note: at
  least one VAR needs to be defined under all):

  ```yaml

  all: &default
    FOO: bar
    BAR: ${FOO}
  darwin:
    <<: *default
  linux:
    <<: *default
  windows:
    <<: *default
  ```
  Make it executable
  ```bash
  $ chmod +x ./foobar.env
  ```
  To see the resolved environment for the `foobar` stack, run:
  ```bash
  $ envstack foobar
  FOO=bar
  BAR=$FOO
  ```
  or execute it directly:
  ```bash
  $ ./foobar.env
  ```
  To see resolved values:
  ```bash
  $ ./foobar.env -r
  FOO=bar
  BAR=bar
  ```

  Variables can be platform specific:
  ```yaml
  darwin:
    <<: *default
    HELLO: olleh
  linux:
    <<: *default
    HELLO: world
  windows:
    <<: *default
    HELLO: goodbye
  ```
  Variables can reference other variables:
  ```yaml
  all: &default
    FOO: ${BAR}
    BAR: ${BAZ}
    BAZ: ${BIZ}
    BIZ: ${BIZ:=foo}
  ```
  As you might expect, the above resolves to:
  ```bash
  $ envstack -r
  BAR=foo
  BAZ=foo
  BIZ=foo
  FOO=foo
  ```

  Environment stack files can include other namespaced environments (you should
  probably always include the `default` stack):
  ```yaml
  include: [default, test]
  ```

  To see the unresolved environment for one or more environment stacks (values are
  defined in the stacks from left to right):
  ```bash
  $ envstack [STACK [STACK ...]]
  ```
  To resolve one or more environment vars for a given stack:
  ```bash
  $ envstack [STACK] -r [VAR [VAR ...]]
  ```
  To trace where one or more environment vars is being set:
  ```bash
  $ envstack [STACK] -t [VAR [VAR ...]]
  ```
  To get the list of source files for a given stack:
  ```bash
  $ envstack [STACK] --sources
  ```

  To initialize the environment stack in Python, use the `init` function:
  ```python
  >>> envstack.init()
  >>> os.getenv("HELLO")
  'world'
  ```
  To initialize the "dev" stack:
  ```python
  >>> envstack.init("dev")
  >>> os.getenv("ENV")
  'dev'
  ```
  To revert the original environment:
  ```python
  >>> envstack.revert()
  >>> os.getenv("HELLO")
  >>>
  ```
  Creating and resolving environments:
  ```python
  >>> from envstack.env import Env, resolve_environ
  >>> env = Env({"BAR": "${FOO}", "FOO": "foo"})
  >>> resolve_environ(env)
  {'BAR': 'foo', 'FOO': 'foo'}
  ```
  Loading and resolving predefined environments from stack files:
  ```python
  >>> from envstack.env import load_environ, resolve_environ
  >>> env = resolve_environ(load_environ(name))
  ```

  To run any command line executable inside of an environment stack, where
  `[COMMAND]` is the command to run:
  ```bash
  $ envstack [STACK] -- [COMMAND]
  ```
  For example:
  ```bash
  $ envstack -- echo {HELLO}
  world
  ```
  Running Python commands in the default stack:
  ```bash
  $ envstack -- python -c "import os; print(os.environ['HELLO'])"
  world
  ```
  Overriding values in the stack:
  ```bash
  $ HELLO=goodbye envstack -- python -c "import os; print(os.environ['HELLO'])"
  goodbye
  ```
  Same command but using the "thing" stack"
  ```bash
  $ envstack thing -- python -c "import os; print(os.environ['FOO'])"
  bar
  ```

  Wrappers are command line executable scripts that automatically run a given
  command in the environment stack.
  Here is a simple example that runs a `python -c` command in the `hello`
  environment stack that sets a value for `${PYEXE}`:

  ```yaml
  all: &default
    PYEXE: /usr/bin/python
  ```

  ```python
  import sys
  from envstack.wrapper import Wrapper
  class HelloWrapper(Wrapper):
      def __init__(self, *args, **kwargs):
          super(HelloWrapper, self).__init__(*args, **kwargs)
      def executable(self):
          """Return the command to run."""
          return "${PYEXE} -c 'import os,sys;print(os.getenv(sys.argv[1]))'"
  if __name__ == "__main__":
      hello = HelloWrapper("hello", sys.argv[1:])
      hello.launch()
  ```
  Running the wrapper:
  ```bash
  $ hello HELLO
  world
  ```

  In order to set an environment stack in your current shell, the stack must be
  sourced (that's because Python processes and subshells cannot alter the
  environment of the parent process).
  To source the environment in your current shell, create an alias that sources
  the output of the `--export` command:

  ```bash
  alias envstack-init='source <(envstack --export)';
  ```

  ```cmd
  doskey envstack-set=for /f "usebackq" %i in (`envstack --export $*`) do %i
  ```
  Then you can set the environment stack in your shell with the `envstack-init`
  command. To clear the environment in your current shell, create an alias that
  sources the output of the `--clear` command:

  ```bash
  alias envstack-clear='source <(envstack --clear)';
  ```

  ```cmd
  doskey envstack-clear=for /f "usebackq" %i in (`envstack --clear $*`) do %i
  ```

  The following environment variables are used to help manage functionality:
  | Name | Description |
  |------|-------------|
  | ENVPATH | Colon-separated paths to search for stack files |
  | IGNORE_MISSING | Ignore missing stack files when resolving environments |
  | STACK | Name of the current environment stack |

  Unit tests can be run using pytest (currently only tested on linux):
  ```bash
  $ pytest tests -s
  ```


pkgId: 3d688a8563d4b3c43ccb42a3abd2ce29c66c3763c5f80d6e6d942a8198c20471
name: python-eo4eu-data-utils-help
arch: noarch
version: 0.18.0
epoch: 0
release: 1
summary: Development documents and examples for eo4eu-data-utils
url: https://pypi.org/project/eo4eu-data-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eo4eu-data-utils-0.18.0-1.src.rpm
location_href: Packages/python-eo4eu-data-utils-help-0.18.0-1.noarch.rpm
checksum_type: sha256
description:
  This package provides classes and functions that help with common tasks involving:

  - Reading data from configMaps and secrets
  - Uploading to and downloading from S3 buckets
  - Configuring components in general

  The current API is unstable and the previous readme was outdated. New documentation will be provided once the package stabilizes.


pkgId: b183550ec3850e965b47be51f398011817d5f5f35fd376f61eb7ecbe8355493a
name: python-eo4eu-meta-utils-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for eo4eu-meta-utils
url: https://pypi.org/project/eo4eu-meta-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eo4eu-meta-utils-0.7.2-1.src.rpm
location_href: Packages/python-eo4eu-meta-utils-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  This module is intended to be used for configuring automated test and deployments of components. It is very much work-in-progress at the moment.


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

  ```console
  pip install eodash_catalog
  ```

  Project uses pytest and runs it as part of CI:
  ```bash
  python -m pytest
  ```

  Project uses ruff to perform checks on code style and formatting
  ```bash
  ruff check .
  ```

  eodash_catalog adheres to [Semantic Versioning](https://semver.org/) and follows these rules:
  Given a version number `MAJOR.MINOR.PATCH`, we increment the:
  - `MAJOR` version when we make incompatible API changes
  - `MINOR` version when we add functionality in a backward compatible manner
  - `PATCH` version when we make backward compatible bug fixes
  Active development is followed by the `main` branch.
  `
  New features or maintenance commits should be done against this branch in the form of a Merge Request of a Feature branch.

  This repository uses bump2version for managing tags. To bump a version use
  ```bash
  bump2version <major|minor|patch> # or bump2version --new-version <new_version>
  git push && git push --tags
  ```
  Pushing a tag in the repository automatically creates:
  - versioned package on pypi

  `eodash_catalog` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: e2e753615bd595741fd99bae6ef91df824ce582f01c5ff0a479f8c6b38a45e17
name: python-eodhd-help
arch: noarch
version: 1.0.32
epoch: 0
release: 1
summary: Development documents and examples for eodhd
url: https://github.com/EodHistoricalData/EODHD-APIs-Python-Financial-Library
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eodhd-1.0.32-1.src.rpm
location_href: Packages/python-eodhd-help-1.0.32-1.noarch.rpm
checksum_type: sha256
description:
  [Full documentation](https://eodhd.com/financial-apis/python-financial-libraries-and-code-samples/)

  This is the official Python library developed by [EODHD](https://eodhd.com) for accessing various financial data via API in your code. If you have any feedback or questions, you can reach out to our support team, available 24/7 via live chat on [our website](https://eodhd.com).

  To access our APIs, you need to register on our site (it’s free) and obtain an API key. Access to some data requires a subscription to one of [our paid plans](https://eodhd.com/pricing).



  * End of the Day Historical Stock Market Data
  * Live (Delayed) Stock Prices and Macroeconomic Data
  * Bonds Fundamentals
  * Intraday Historical Data
  * Historical Dividends
  * Historical Splits
  * Bulk API for EOD, Splits and Dividends
  * Calendar. Upcoming Earnings, Trends, IPOs and Splits
  * Economic Events
  * Stock Market and Financial News
  * List of supported Exchanges
  * Insider Transactions
  * Macro Indicators
  * Exchange API. Trading Hours, Stock Market Holidays, Symbols Change History
  * Stock Market Screener
  * Technical Indicator
  * Historical Market Capitalization
  * Fundamental Data: Stocks, ETFs, Mutual Funds, Indices and Cryptocurrencies

  All functions are described in our [documentation](https://eodhd.com/financial-apis/python-financial-libraries-and-code-samples/).




  In short:

  python3 -m pip install eodhd -U

  If you have any difficulties, go to our full [documentation](https://eodhd.com/financial-apis/python-financial-libraries-and-code-samples/) with step by step instructions.



  The files below contain examples of available functions:

  * example_api.py: describes the functions that can be used in the APIClient class.
  * example_scanner.py: describes the functions that can be used in the ScannerClient class.
  * example_websockets.py: describes the functions that can be used in the WebSocketClient class.


  New features will be added to the example files. The most relevant functions can be viewed directly in the code files.


pkgId: c1baeda56adaca0a8c1a4f6d21af88f5fbd15bf4a3154c74debf80a18c44f045
name: python-eole-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for eole
url: https://pypi.org/project/eole/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eole-0.0.3-1.src.rpm
location_href: Packages/python-eole-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  We have made significant progress in several areas:
  - **Configuration Management**: Streamlined through [pydantic](https://docs.pydantic.dev) models.
  - **Command Line Entry Points**: Improved using structured subparsers for better organization.
  - **Reproducible Recipes**: Provided for widely used models and tasks, ensuring consistency and reliability.
  - **Core API Simplification**: Refined around the new configuration objects for ease of use.

  There are still several exciting avenues to explore:
  - **Further Simplification and Refactoring**: Continue enhancing the codebase for clarity and efficiency.
  - **Inference Server**: Develop a robust solution for model inference.
  - **Additional Recipes**: Expand the library of reproducible recipes.
  - **Documentation**: Enhance and expand the documentation for better user guidance.
  - **Test Coverage**: Improve testing to ensure code reliability and performance.
  - **Logging Enhancements**: Implement more sophisticated logging mechanisms.


pkgId: 7948ca80f1e42fb7ffe2b7b286b8b3f0324c1b036239461c2a867011b748cb3e
name: python-eoq3-help
arch: noarch
version: 2.9.8
epoch: 0
release: 1
summary: Development documents and examples for eoq3
url: https://gitlab.com/eoq/py/eoq3
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eoq3-2.9.8-1.src.rpm
location_href: Packages/python-eoq3-help-2.9.8-1.noarch.rpm
checksum_type: sha256
description:
  This implements EOQ3 domains, values, queries and commands in python.
  It is the central module of the EOQ3 implementation for python.
  It contains a ready-to-use domainwithmdb for programatic model interactions.



  This example implements the ["Why EOQ?"](https://eoq.gitlab.io/doc/eoq3/10_eoq.html#why-eoq-an-application-example) example and some additional prints of model information.

      from eoq3.domainwithmdb import DomainWithMdb
      from eoq3.command import Crt, Get,Set #commands
      from eoq3.query import Cls,Pth #queries
      from eoq3.concepts import * #import constants as CONCEPTS, ....
      from eoq3.examples.warehouse import CreateWarehouseM1Model, CreateWarehouseM2Model #creation of example models
      
  	from eoq3pyecoremdb import PyEcoreMdb #requres pyecoremdb to be installed

  	
  	mdb = PyEcoreMdb()
  	domain = DomainWithMdb(mdb)
  	
  	CreateWarehouseM2Model(domain) #open function to see model creation commands
  	CreateWarehouseM1Model(domain) #open function to see model creation commands
  	
  	articles = domain.Do( Get( Cls('Article') ) )
  	print("Articles: %s")
  	
  	badArticles = domain.Do( Get( Cls('Article').Sel(Pth('sells').Les(3)) ) )
  	print("Bad articles: %s")
  	
  	nameAndPrice = domain.Do( Get( Cls('Article').Zip([Pth('name'),Pth('price')])))
  	print("Article prices: %s")
  	domain.Do( Set(
  		Cls('Article').Sel(Pth('sells').Les(3)),
  		'price',
  		Cls('Article').Sel(Pth('sells').Les(3)).Pth('price').Mul(0.9)
  	) )
  	nameAndPrice = domain.Do( Get( Cls('Article').Zip([Pth('name'),Pth('price')])))
  	print("Article prices: %s")
  	
  	badCategories = domain.Do( Get( Cls('Article').Sel(Pth('sells').Les(3)).Met('PARENT').Pth('name').Uni([]).Idx('SORTASC') ) )
  	print(badCategories)

  This example is available as  https://gitlab.com/eoq/py/pyeoq/Examples/Eoq3/WhyWarehouse.py



  For more information see EOQ3 documentation: https://eoq.gitlab.io/doc/eoq3/



  Pyeoq module's source can be found here: https://gitlab.com/eoq/py/pyeoq



  2024 Bjoern Annighoefer


pkgId: c03f685794ed6f125ff00470738f60191cda94e371aefa067181a7ae4ae203eb
name: python-epCC1101-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for epCC1101
url: https://github.com/eydam-prototyping/cc1101
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-epCC1101-0.1.0-1.src.rpm
location_href: Packages/python-epCC1101-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This project provides a Python driver for the CC1101 transceiver chip, enabling seamless integration with Raspberry Pi and other compatible platforms. The driver supports data transmission and reception, making it ideal for wireless communication projects.


  * Connect the CC1101 module to your hardware as per your wiring setup.

  * Run a sample script:

      * For transmission:
          ```bash
          python samples/transmitter.py
          ```
      * For reception:
          ```bash
          python samples/receiver.py
          ```


  * **src/:** Contains the main driver code.
  * **samples/**: Example scripts for transmission and reception.
  * **tests/**: Unit tests for the driver.





  ```python
  cc1101.configurator.set_base_frequency_hz(433.92e6)
  cc1101.set_configuration()
  ```
  The base frequency is a key parameter in configuring the CC1101 transceiver, as it defines the central frequency at which the device operates. This parameter determines the starting point of the RF (radio frequency) signal generation and reception, which is crucial for ensuring compatibility with the chosen communication standard or regulatory requirements.

  The base frequency is typically set in the range of 300 MHz to 928 MHz, depending on the hardware and regional regulations. For example, in the ISM (Industrial, Scientific, and Medical) bands, common frequencies include 433 MHz, 868 MHz, and 915 MHz.

  *Note: Make sure, you have the right Antenna connected*



  ```python





  cc1101.configurator.set_modulation_format(0)
  cc1101.set_configuration()
  ```
  The modulation format determines how data is encoded onto the carrier frequency for transmission and decoded during reception. This parameter is essential for ensuring compatibility between transmitting and receiving devices, as both must use the same modulation scheme to communicate effectively.

  The CC1101 supports several modulation formats, including:
    * 2/4-FSK (Frequency Shift Keying): A robust modulation scheme commonly used in environments with high interference.
    * GFSK (Gaussian Frequency Shift Keying): A variation of FSK with smoother transitions, reducing spectral bandwidth and interference.
    * ASK/OOK (Amplitude Shift Keying/On-Off Keying): Simple schemes often used in low-power, short-range applications like remote controls.
    * MSK (Minimum Shift Keying): Provides high spectral efficiency, ideal for data-intensive applications.

  The choice of modulation format impacts key aspects of the communication, including data rate, power consumption, and signal robustness. For example, FSK is highly reliable in noisy environments, while OOK is energy-efficient but more susceptible to interference.



  2-FSK is a digital modulation scheme where the carrier frequency shifts between two discrete frequencies to represent binary data (0 and 1). It is one of the simplest forms of frequency modulation and is widely used for robust communication in environments with noise or interference.

  **Relevant CC1101 Parameters:**

    * Deviation: The difference between the carrier frequency and the modulated frequencies.

  ![2-FSK Modulation](img/Sample_2-FSK.png)




  Like 2-FSK, but with 4 Frequencies.

  ![4-FSK Modulation](img/Sample_4-FSK.png)



  ASK (Amplitude Shift Keying) is a modulation scheme where the amplitude of the carrier signal varies to represent binary data. Unlike OOK, which is a subset of ASK with only two states (presence or absence of a signal), ASK can include more amplitude levels for more complex data encoding, though in most applications, it uses only two states:

  High Amplitude represents binary 1.
  Low Amplitude (or Zero in OOK) represents binary 0.
  ASK/OOK is commonly used in simple, low-power communication systems such as wireless sensors, keyless entry systems, and remote controls.

  **Relevant CC1101 Parameters:**

    * PA-Table Setting: \
        Byte 0 represents the power for a logical zero\
        Byte 1 represents the power for a logical one

    * FREND0.PA_POWER represents the PA power setting, that is used for a logical one. Default is 1.

  ![ASK/OOK Modulation](img/Sample_ASK_OOK.png)


pkgId: a77038d37a86628fb6c0ba6ea5c96e08b2bcdf0377157019b5fb07dc351711cc
name: python-epcis-dummy-generator-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for epcis-dummy-generator
url: https://github.com/Violeta-Carvalho/EPCIS-Dummy-Generator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-epcis-dummy-generator-0.0.1-1.src.rpm
location_href: Packages/python-epcis-dummy-generator-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This project is still in development, and the idea is to make my job as a QA engineer automating tests related to EPCIS easier. I figured if I need this, someone else might need as well. This is my first Python package, any problems, doubts or suggestions, either comment on the [Github repository](https://github.com/Violeta-Carvalho/EPCIS-Dummy-Generator), or send me an [email](mailto:violetadecarvalho@gmail.com).


  EPCIS data related to companies.



  `generate_company_prefix(length: int)`

  Randomly generates a company prefix (str) with a length that varies from 6 to 12, 7 is default.


  EPCIS data related to items.



  `generate_gtin(company_prefix: str, company_prefix_length: int)`

  Randomly generates a GTIN (str) with a length of 14. You must either inform `company_prefix` or `company_prefix_length`, if only `company_prefix_length` is informed, it generates a `company_prefix` with the `generate_company_prefix` function before generating the GTIN. Then, it generates the check digit.



  `get_company_prefix_and_gs1_id_from_gtin(gtin: str, company_prefix_length: int)`

  Reads the GTIN (str) and returns a dictionary with the following template:

  ```
  {
      "gs1_id": <gs1_id>,
      "company_prefix": <company_prefix>
  }
  ```

  You must inform both `gtin` and `company_prefix_length`.



  `generate_sgtin(serial: str, gtin=None, company_prefix=None, company_prefix_length=None)`

  Generates an SGTIN based on serial informed and `gtin` and `company_prefix` informed. If no `gtin` is informed, it generates one with the `generate_gtin` function, using either the `company_prefix`. If only `company_prefix_length` is informed it generates `company_prefix` with the function `generate_company_prefix`.


  EPCIS data related to locations.



  `generate_gln(company_prefix: str, company_prefix_length: int)`

  Randomly generates a GLN (str) with a length of 13. You must either inform `company_prefix` or `company_prefix_length`, if only `company_prefix_length` is informed, it generates a `company_prefix` with the `generate_company_prefix` function before generating the GLN. Then, it generates the check digit.



  `generate_sgln(serial: str, gln=None, company_prefix=None, company_prefix_length=None)`

  Generates an SGLN based on serial informed and `gln` and `company_prefix` informed. If no `gln` is informed, it generates one with the `generate_gln` function, using either the `company_prefix`. If only `company_prefix_length` is informed it generates `company_prefix` with the function `generate_company_prefix`.


  Functions unrelated to EPCIS, but which are used by EPCIS-related functions.



  `generate_x_length_number(x: int)`

  Generates a string made of X digits. Used to randomly generate Company Prefixes and GS1 IDs.



  `calculate_check_digit(base: str)`

  Calculates check digit based on Modulo 10 rule, using the base, a string made entirely of digits.


pkgId: be6e4c50221b3dc24ea555152b35aa7d617efe823686e75669c87bfffd177926
name: python-ephios-help
arch: noarch
version: 0.18.11
epoch: 0
release: 1
summary: Development documents and examples for ephios
url: https://ephios.de
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ephios-0.18.11-1.src.rpm
location_href: Packages/python-ephios-help-0.18.11-1.noarch.rpm
checksum_type: sha256
description:
  ![tests](https://github.com/ephios-dev/ephios/workflows/tests/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/ephios/badge/?version=latest)](https://docs.ephios.de/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/ephios)](https://pypi.org/project/ephios/)
  [![Coverage Status](https://coveralls.io/repos/github/ephios-dev/ephios/badge.svg?branch=main)](https://coveralls.io/github/ephios-dev/ephios?branch=main)
  [![translated by Weblate](https://hosted.weblate.org/widgets/ephios/-/svg-badge.svg)](https://hosted.weblate.org/engage/ephios/)




  ephios is a tool to manage shifts for medical services.
  Planners can create events for which volunteer help is required (e.g. security/medical services, beach patrols, exercises).
  An event can contain multiple shifts for which different processes can be applied for signup
  (e.g. a direct confirmation for an event or an "application" that has to be accepted first).
  The volunteers can register for the respective shifts via a clearly arranged web interface.
  The planners can then assign personnel and have an overview of the current status.
  Around this central feature there are further supporting functions like the management of the volunteers and their
  qualifications or an overview of the volunteer hours worked. A flexible group systems helps to support complex permission
  szenarios. The functionality can be extended using plugins.


  You can find the documentation for ephios at [Read the Docs](https://docs.ephios.de/en/latest). This includes
  the user guide and installation instructions.


  Contributions to ephios are very welcome. You can find information about contributing at our [Contribution page](https://docs.ephios.de/en/latest/development/contributing.html)
  We are using Weblate for translations, you can also contribute [there](https://hosted.weblate.org/engage/ephios/).


pkgId: 4389533485e1e7340fe3a9c8dc55e47e0e451b052579769291332a3a89e58057
name: python-epik8s-tools-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for epik8s-tools
url: https://github.com/yourusername/epik8s-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-epik8s-tools-0.6.1-1.src.rpm
location_href: Packages/python-epik8s-tools-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Generate a new project structure for a beamline with the following command:
  ```bash
  epik8s-tools my_project --beamline MyBeamline --iocbaseip 10.96.0.0/12 --beamlinerepogit https://github.com/beamline/repo.git
  ```

  To generate OPI panels from YAML configuration files, you can use the `epik8s-opigen` tool. This tool reads a YAML file with OPI configurations and outputs the generated OPI files in the specified project directory.

  ```bash
  epik8s-opigen --yaml deploy/values.yaml --projectdir opi-output
  ```
  - **`--yaml`**: Path to the YAML configuration file (e.g., `deploy/values.yaml`).
  - **`--projectdir`**: Directory where the OPI files will be generated (e.g., `opi-output`).


pkgId: c2932fcada3697e1d363c5f34ef8e26171edad7cc1bb1523d531ef8ad619fdcd
name: python-eppo-metrics-sync-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for eppo-metrics-sync
url: https://pypi.org/project/eppo-metrics-sync/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eppo-metrics-sync-0.1.3-1.src.rpm
location_href: Packages/python-eppo-metrics-sync-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/eppo-metrics-sync.svg)](https://badge.fury.io/py/eppo-metrics-sync)
  [![Tests](https://github.com/Eppo-exp/eppo-metrics-sync/actions/workflows/run_tests.yml/badge.svg)](https://github.com/Eppo-exp/eppo-metrics-sync/actions)

  A Python package for syncing metric definitions with Eppo's API. Manage your Eppo metrics as code using YAML files. Documentation is available in Eppo's [documentation page](https://docs.geteppo.com/data-management/certified-metrics/).



  -   Sync metrics and fact sources to Eppo
  -   Validate metric definitions locally
  -   Support for dbt models
  -   Dry-run capability for testing
  -   Prefix support for testing in shared workspaces



  ```bash
  pip install eppo-metrics-sync
  ```





  1. Set required environment variables:

  ```bash
  export EPPO_API_KEY="your-api-key"

  export EPPO_SYNC_TAG="your-sync-tag" # optional
  ```

  2. Create your metrics YAML files (see [Documentation](#documentation))

  3. Run the sync:

  ```bash
  python -m eppo_metrics_sync path/to/yaml/directory
  ```



  ```bash
  python -m eppo_metrics_sync [OPTIONS] DIRECTORY
  ```

  Options:

  -   `--dryrun` Validate files without syncing to Eppo
  -   `--schema` Schema type: eppo (default) or dbt-model
  -   `--sync-prefix` Prefix for fact/metric names (useful for testing)
  -   `--dbt-model-prefix` Warehouse/schema prefix for dbt models



  For detailed information about metric configuration and available options, see Eppo's [documentation page](https://docs.geteppo.com/data-management/certified-metrics/).



  ```yaml
  fact_sources:
      - name: Revenue
        sql: |
            SELECT ts, user_id, amount
            FROM revenue_table
        timestamp_column: ts
        entities:
            - entity_name: User
              column: user_id
        facts:
            - name: Revenue
              column: amount

  metrics:
      - name: Total Revenue
        description: Sum of Total Purchase Value in Purchases Fact Table
        entity: User
        numerator:
            fact_name: Revenue
            operation: sum
  ```







  ```bash
  python -m venv .venv
  source .venv/bin/activate
  ```



  ```bash
  pip install -r requirements.txt
  ```



  ```bash
  pytest tests
  ```



  For package maintainers:

  1. Update version in `pyproject.toml`
  2. Build the package:

  ```bash
  python -m build
  ```

  3. The package will be automatically published to PyPI when a new release is created on GitHub.


pkgId: e45db34b7981a9be482497d7adcab9d621908b702ea83f5cc2c875045cdfe7c6
name: python-eprempy-help
arch: noarch
version: 0.8.3
epoch: 0
release: 1
summary: Development documents and examples for eprempy
url: https://pypi.org/project/eprempy/
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eprempy-0.8.3-1.src.rpm
location_href: Packages/python-eprempy-help-0.8.3-1.noarch.rpm
checksum_type: sha256
description:
  Tools for working with EPREM simulation runs



  ```bash
  $ pip install eprempy
  ```



  Before getting started in earnest with `eprempy`, one simple task you can perform to make sure everything is installed is to print the version number.

  ```python
  >>> import eprempy
  >>> print(eprempy.__version__)
  ```

  You can also print the version number via the package command-line interface (CLI)

  ```shell
  $ python -m eprempy --version
  ```

  The value printed will depend on which version you have installed.



  The examples below assume a working knowledge of [EPREM](https://github.com/myoung-space-science/eprem) &mdash; essentially, they assume that you have successfully run EPREM and have access to both the runtime configuration file and the output files.

  Most users will begin by creating an interface to a full dataset, or to a single stream or point observer. The syntax is similar among all three cases.

  You may create an interface to a full dataset by providing a path to the directory containing output from an EPREM simulation run (`source`), the name of the runtime configuration file used to initialize the simulation run (`config`), and the metric system in which to observe physical quantities (`system`).

  ```python
  from eprempy import eprem

  dataset = eprem.dataset(source='/path/to/my/eprem/run', config='eprem.cfg', system='mks')
  ```

  All parameters have default values

  * The default `source` is the current directory.
  * The default `config` is any file called `eprem_input_file`, or a file ending in `.cfg`, `.ini`, or `.in`.
  * The default `system` is `'mks'` &mdash; options are `'mks'` or `'cgs'` (case-insensitive).

  Each dataset has the following properties

  * `directory`: the full path to the relevant EPREM output directory.
  * `config`: the full path to the runtime configuration file used to initialize the EPREM simulation run.
  * `system`: an instance of `eprempy.metric.System` representing an observer's metric system
  * `observers`: all observers in the dataset, keyed by ID.
  * `streams`: all stream observers in the dataset, keyed by ID.
  * `points`: all point observers in the dataset, keyed by ID.
  * `parameters`: an interface to EPREM runtime parameter values.



  You may directly create an individual observer by providing its ID (e.g., stream number or name), as well as the same arguments used to create a dataset. The observer ID must be the first argument and is required.

  ```python
  from eprempy import eprem

  stream = eprem.stream(4, source='/path/to/my/eprem/run', config='eprem.cfg', system='mks')
  point = eprem.point(1, source='/path/to/my/eprem/run', config='eprem.cfg', system='mks')
  ```

  A stream-observer ID is alway an integer. A point-observer ID may be a string or an integer, in order to accommodate the possibility of named point observers (e.g., 'earth' or 'PSP') in EPREM.

  Therefore, the following invokations are equivalent to those above, as long as you're working in the simulation output directory and the simulation configuration file has a standard name.

  ```python
  from eprempy import eprem

  dataset = eprem.dataset()
  stream = eprem.stream(4)
  point = eprem.point(1)
  ```

  Each observer has the following properties

  * `source`: the full path to an observer's data file.
  * `system`: an instance of `eprempy.metric.System` representing an observer's metric system.
  * `times`: the observer's time coordinates.
  * `species`: the available particle species.



  Every observer provides a key-based interface (i.e., a mapping) to observable quantities. Users may request a known observable quantity from an observer by passing a valid alias for the observable via bracket syntax. For example, any of the following commands will return the observable quantity representing particle flux

  ```python
  stream['flux']
  stream['Flux']
  stream['j']
  stream['J']
  ```

  Each observable quantity knows its unit and its subscriptable dimensions.

  ```python
  >>> stream = eprem.stream(4, system='mks')
  >>> stream['flux']
  Quantity(unit='J^-1 s^-1 sr^-1 m^-2', dimensions={'time', 'shell', 'species', 'energy'})
  >>> stream = eprem.stream(4, system='cgs')
  >>> stream['flux']
  Quantity(unit='erg^-1 s^-1 sr^-1 cm^-2', dimensions={'time', 'shell', 'species', 'energy'})
  ```

  An observable quantity has `unit` and `dimensions` properties. Using the MKS example,

  ```python
  >>> flux = stream['flux']
  >>> flux.unit
  Unit('J^-1 s^-1 sr^-1 m^-2')
  >>> flux.dimensions
  Dimensions({'time', 'shell', 'species', 'energy'})
  ```

  It is possible to change the unit of an observable quantity via the `.withunit` method.

  ```python
  >>> stream['flux'].withunit('1 / (cm^2 s sr MeV/nuc)')
  Quantity(unit='nuc MeV^-1 s^-1 sr^-1 cm^-2', dimensions={'time', 'shell', 'species', 'energy'})
  ```

  The full list of observable quantities, with registered aliases, is

  * 'phiOffset'
  * 't' = 'times' = 'time'
  * 'shells' = 'shell'
  * 'pitch-angle cosines' = 'mu' = 'pitch-angle cosine' = 'pitch-angle' = 'pitch angles' = 'pitch angle' = 'pitch-angles'
  * 'm' = 'mass'
  * 'q' = 'charge'
  * 'energy' = 'egrid' = 'E' = 'energies'
  * 'v' = 'vgrid' = 'speed'
  * 'radius' = 'R' = 'r'
  * 'T' = 'theta'
  * 'phi' = 'P'
  * 'Br' = 'br'
  * 'bt' = 'btheta' = 'Btheta' = 'Bt'
  * 'Bphi' = 'Bp' = 'bphi' = 'bp'
  * 'ur' = 'vr' = 'Vr' = 'Ur'
  * 'Ut' = 'utheta' = 'Utheta' = 'Vtheta' = 'Vt' = 'ut'
  * 'uphi' = 'up' = 'Vp' = 'Vphi' = 'Up' = 'Uphi'
  * 'rho' = 'Rho'
  * 'Dist' = 'dist' = 'f'
  * 'Flux' = 'J' = 'j(E)' = 'j' = 'J(E)' = 'flux'
  * 'X' = 'x'
  * 'y' = 'Y'
  * 'Z' = 'z'
  * 'bmag' = 'b_mag' = 'b mag' = '|b|' = '|B|' = 'b' = 'B'
  * 'u mag' = 'umag' = '|U|' = 'U' = 'u_mag' = 'u' = '|u|'
  * 'Upara' = 'u_para' = 'upara'
  * 'u_perp' = 'Uperp' = 'uperp'
  * 'angle' = 'flow_angle' = 'flow angle'
  * 'div_u' = 'divu' = 'div(u)' = 'div(U)' = 'divU' = 'div u' = 'div U'
  * 'Rg' = 'rigidity' = 'R_g'
  * 'mean_free_path' = 'mean free path' = 'mfp'
  * 'ar' = 'acceleration rate' = 'acceleration_rate'
  * 'energy_density' = 'energy density'
  * 'average_energy' = 'average energy'
  * 'fluence'
  * 'integral flux' = 'integral_flux' = 'intflux'



  Users may observe an observable quantity via standard subscription syntax, such as

  ```python
  flux[0, 0, 0, 0]
  flux[0, ...]
  flux[:, 0, ...]
  flux[:]
  ```

  Users may also observe an observable quantity via physical subscription syntax, such as

  ```python
  time = 1.0, 2.0, 'day'
  radius = 0.5, 'au'
  species = 'H+'
  energy = 1.0, 10.0, 100.0, 'MeV'
  flux[time, radius, species, energy]
  ```
  or, more compactly,
  ```python
  flux[(1.0, 2.0, 'day'), (0.5, 'au'), 'H+', (1.0, 10.0, 100.0, 'MeV')]
  ```

  Note that physical subscription syntax requires a tuple to express an index with one or more value(s) and a unit.

  Each observation inherits its unit from the observable quantity at the time of observation, and it has its own `unit` property and `withunit` method. In place of the `dimensions` property, each observation has an `axes` property that contains information about the specific axis types and their corresponding values.

  Changing an observation's unit self-consistently scales the observed values. Attempting to convert an observable quantity or an observation to a physically inconsistent unit (e.g., converting 'm / s' to 'kg / erg') raises a `ValueError`.

  You may directly convert any observation to a `numpy.ndarray`

  ```python
  import numpy

  numpy.array(flux[0, 0, 0, 0])
  numpy.array(flux[:])
  ```

  You may also directly convert any observable quantity to a `numpy.ndarray`

  ```python
  numpy.array(flux)
  ```
  Doing so is essentially a shortcut for converting the full observation.



  Accessing a runtime parameter value via the dataset interface's `parameters` property returns a `Variable` for physical quantities &mdash; those with one or more value(s) and a unit &mdash; and a built-in type (e.g., integer or string) for all other quantities.

  The full list of parameters, with registered aliases, is

  * 'FailModeDump'
  * 'adiabaticChangeAlg'
  * 'adiabaticFocusAlg'
  * 'aziSunStart'
  * 'boundaryFunctAmplitude' = 'J0'
  * 'boundaryFunctBeta' = 'beta'
  * 'E0' = 'boundaryFunctEcutoff'
  * 'reference energy' = 'boundaryFunctEr' = 'Er'
  * 'gamma' = 'boundaryFunctGamma'
  * 'reference radius' = 'R0' = 'boundaryFunctR0' = 'r0'
  * 'boundaryFunctXi' = 'xi'
  * 'boundaryFunctionInitDomain'
  * 'charge'
  * 'checkSeedPopulation'
  * 'dsh_hel_min'
  * 'dsh_min'
  * 'dumpFreq'
  * 'dumpOnAbort'
  * 'eMax'
  * 'eMin'
  * 'epCalcStartTime'
  * 'epEquilibriumCalcDuration'
  * 'epremDomain'
  * 'epremDomainOutputTime'
  * 'fieldAligned'
  * 'flowMag'
  * 'fluxLimiter'
  * 'focusingLimit'
  * 'gammaEhigh'
  * 'gammaElow'
  * 'idealShock'
  * 'idealShockFalloff'
  * 'idealShockInitTime'
  * 'idealShockJump'
  * 'idealShockPhi'
  * 'idealShockPhiWidth'
  * 'idealShockScale'
  * 'idealShockScaleLength'
  * 'idealShockSharpness'
  * 'idealShockSpeed'
  * 'idealShockTheta'
  * 'idealShockThetaWidth'
  * 'idealShockWidth'
  * 'idw_p'
  * 'kper/kpar' = 'kperxkpar' = 'kper / kpar' = 'kper_kpar'
  * 'lambda0' = 'lam0' = 'lamo'
  * 'mass'
  * 'mfpRadialPower' = 'mfp_radial_power'
  * 'mhdBAu'
  * 'mhdBConvert'
  * 'mhdCouple'
  * 'mhdCoupledTime'
  * 'mhdDensityAu'
  * 'mhdDigits'
  * 'mhdDirectory'
  * 'mhdInitFromOuterBoundary'
  * 'mhdInitMonteCarlo'
  * 'mhdInitRadius'
  * 'mhdInitTimeStep'
  * 'mhdNumFiles'
  * 'mhdRadialMax'
  * 'mhdRadialMin'
  * 'mhdRhoConvert'
  * 'mhdRotateSolution'
  * 'mhdStartTime'
  * 'mhdSteadyState'
  * 'mhdTimeConvert'
  * 'mhdVConvert'
  * 'mhdVmin'
  * 'minInjectionEnergy'
  * 'numColumnsPerFace'
  * 'numEnergySteps'
  * 'numEpSteps'
  * 'numMuSteps'
  * 'numNodesPerStream'
  * 'numObservers'
  * 'numRowsPerFace'
  * 'numSpecies'
  * 'obsPhi'
  * 'obsR'
  * 'obsTheta'
  * 'omegaSun'
  * 'outputFloat'
  * 'outputRestart'
  * 'parallelFlow'
  * 'pointObserverOutput'
  * 'pointObserverOutputTime'
  * 'preEruptionDuration'
  * 'rScale'
  * 'rigidityPower' = 'rigidity_power'
  * 'saveRestartFile'
  * 'seedFunctionTest'
  * 'shockDetectPercent'
  * 'shockInjectionFactor'
  * 'shockSolver'
  * 'simStartTime'
  * 'simStopTime'
  * 'streamFluxOutput'
  * 'streamFluxOutputTime'
  * 'streamSpawnLocAzi'
  * 'streamSpawnLocZen'
  * 'subTimeCouple'
  * 'tDel'
  * 'unifiedOutput'
  * 'unifiedOutputTime'
  * 'unstructuredDomain'
  * 'unstructuredDomainOutputTime'
  * 'useAdiabaticChange'
  * 'useAdiabaticFocus'
  * 'useBoundaryFunction'
  * 'useDegrees'
  * 'useDrift'
  * 'useEPBoundary'
  * 'useManualStreamSpawnLoc'
  * 'useMhdSteadyStateDt'
  * 'useParallelDiffusion'
  * 'useShellDiffusion'
  * 'useStochastic'
  * 'warningsFile'



  Interested in contributing? Check out the contributing guidelines. Please note that this project is released with a Code of Conduct. By contributing to this project, you agree to abide by its terms.



  `eprempy` was created by Matt Young. It is licensed under the terms of the BSD 3-Clause license.



  `eprempy` was created with [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/) and the `py-pkgs-cookiecutter` [template](https://github.com/py-pkgs/py-pkgs-cookiecutter).


pkgId: 50a5ddbdec412ff732173d916690ff73a146776564b257e556b7b3d4b6938b0c
name: python-eprllib-help
arch: noarch
version: 1.5.1
epoch: 0
release: 1
summary: Development documents and examples for eprllib
url: https://pypi.org/project/eprllib/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eprllib-1.5.1-1.src.rpm
location_href: Packages/python-eprllib-help-1.5.1-1.noarch.rpm
checksum_type: sha256
description:
  Copyright 2023 Ray Authors
  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

rpm_license:
  MIT License  Copyright (c) 2024 Germán Rodolfo Henderson  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.  ------------------------------------------------------------------------------------- Copyright 2023 Ray Authors  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.  ------------------------------------------------------------------------------------- EnergyPlus, Copyright (c) 1996-2024, The Board of Trustees of the University of Illinois, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy), Oak Ridge National Laboratory, managed by UT-Battelle, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


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

  > [!IMPORTANT]
  > 🇬🇧 You will need username and password credentials from EPIAS to access Transparency Platform data. Register through [EPIAS Registration Platform](https://kayit.epias.com.tr/home) and get your username (your email) and password. English version is available. `eptr2` is still in active development. Breaking changes can be expected. Fill an [issue](https://github.com/tideseed/eptr2/issues) if you encounter any problem.

  > [!ÖNEMLİ]
  > 🇹🇷 Şeffaflık Platformu verilerine erişmek için EPİAŞ üzerinden kayıt yaparak kullanıcı adı ve şifre almanız gerekmektedir. [EPİAŞ Kayıt Platformu](https://kayit.epias.com.tr/home) üzerinden kullanıcı adınızı (kayıt e-postası) ve şifrenizi alabilirsiniz. `eptr2` hala aktif olarak geliştirilmektedir. Büyük değişiklikler beklenebilir. Herhangi bir sorunda, [issue](https://github.com/tideseed/eptr2) kısmından istek açabilirsiniz.




  🇬🇧 `eptr2` (**EP**IAS **Tr**ansparency **2**.0) package is a thin wrapper around [EPIAS Transparency Platform v2.0](https://seffaflik.epias.com.tr/home) API brought to you by [Robokami](https://robokami.com). It is an unofficial package with Apache License 2.0 (free and permissable use for commercial applications, [see details](https://www.tldrlegal.com/license/apache-license-2-0-apache-2-0)). `eptr2` accesses currently more than 199 services with convenience methods.


  🇹🇷 `eptr2` (**EP**İAŞ **Tr**ansparency **2**.0) paketi [Robokami](https://robokami.com) tarafından [EPİAŞ Şeffaflık Platformu 2.0](https://seffaflik.epias.com.tr/home) API'si üzerine geliştirilmiş bir Python paketidir. Apache License 2.0 ile lisanslanmıştır ([ücretsiz ve büyük ölçüde serbest kullanım](https://www.tldrlegal.com/license/apache-license-2-0-apache-2-0)). `eptr2` 199'dan fazla veri servisine erişim sağlar.




  You can simply use PyPI to install `eptr2` package or directly through GitHub. See [eptr2demo](https://eptr2demo.streamlit.app) page for available calls and examples.

  ```bash
  pip install eptr2
  ```

  NOTE: Starting from v0.4.0, data frame returns will be optional. If pandas is not installed, data frames will not be returned. You can install "dataframe" version with the following command. _(Not implemented yet)_

  ```bash
  pip install "eptr2[dataframe]"
  ```

  ```bash
  pip install git+https://github.com/Tideseed/eptr2.git
  ```



  You can simply use `EPTR2` class to call services with convenience methods.

  ```python
  from eptr2 import EPTR2

  cred_d = {
      "username": "YOUR_USERNAME",
      "password": "YOUR_PASSWORD",
      "is_test": False, ## (optional) Default: False. Set only to True for transparency test servers.
  }

  eptr = EPTR2(
      username=cred_d["username"], password=cred_d["password"], is_test=cred_d["is_test"]
  )

  res = eptr.call("mcp", start_date="2024-07-29", end_date="2024-07-29")
  ```

  You can search for available calls with `eptr.get_available_calls()` function. We plan to include all transparency services in the future.

  ```python
  available_calls = eptr.get_available_calls()
  print(available_calls)
  ```



  Starting from `v0.7.0` you can create aliases for your calls. Just prepare an alias dictionary and add it to the `EPTR2` object.

  ```python
  custom_aliases = {"market-clearing-price": "mcp", "system-marginal-price": "smp"}

  eptr = EPTR2(
      username=cred_d["username"], password=cred_d["password"], is_test=cred_d["is_test"], custom_aliases=custom_aliases
  )
  ```

  As a warning aliases may overwrite the default keys and default aliases. For instance if your alias is "mcp" pointing to "smp", now default "mcp" call is overwritten with "mcp" alias pointing to "smp".

  Library will also have default aliases. You can check aliases with `eptr.get_aliases()` function. If you want to include custom aliases, you can get them with `include_custom_aliases` parameter. `eptr.get_available_calls()` function may also include aliases.

  ```python
  eptr.get_aliases(include_custom_aliases = True)

  eptr.get_available_calls(include_aliases = True)
  ```



  Main object call has some parameters to control the behavior of the package.

  + You can set `ssl_verify` to `False` if you have SSL verification problems.
  + You can set `postprocess` to `False` if you don't want to get data frames as response.
  + You can set `get_raw_response` to `True` if you want to get raw urllib3 response object.


pkgId: 36b91fe90d93fd7946c8f0e9aa10d8357d4cd930623f5d40a44e04272bf511b1
name: python-eptr2-help
arch: noarch
version: 0.7.3
epoch: 0
release: 1
summary: Development documents and examples for eptr2
url: https://pypi.org/project/eptr2/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eptr2-0.7.3-1.src.rpm
location_href: Packages/python-eptr2-help-0.7.3-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/eptr2) ![PyPI - Downloads](https://img.shields.io/pypi/dm/eptr2)

  > [!IMPORTANT]
  > 🇬🇧 You will need username and password credentials from EPIAS to access Transparency Platform data. Register through [EPIAS Registration Platform](https://kayit.epias.com.tr/home) and get your username (your email) and password. English version is available. `eptr2` is still in active development. Breaking changes can be expected. Fill an [issue](https://github.com/tideseed/eptr2/issues) if you encounter any problem.

  > [!ÖNEMLİ]
  > 🇹🇷 Şeffaflık Platformu verilerine erişmek için EPİAŞ üzerinden kayıt yaparak kullanıcı adı ve şifre almanız gerekmektedir. [EPİAŞ Kayıt Platformu](https://kayit.epias.com.tr/home) üzerinden kullanıcı adınızı (kayıt e-postası) ve şifrenizi alabilirsiniz. `eptr2` hala aktif olarak geliştirilmektedir. Büyük değişiklikler beklenebilir. Herhangi bir sorunda, [issue](https://github.com/tideseed/eptr2) kısmından istek açabilirsiniz.




  🇬🇧 `eptr2` (**EP**IAS **Tr**ansparency **2**.0) package is a thin wrapper around [EPIAS Transparency Platform v2.0](https://seffaflik.epias.com.tr/home) API brought to you by [Robokami](https://robokami.com). It is an unofficial package with Apache License 2.0 (free and permissable use for commercial applications, [see details](https://www.tldrlegal.com/license/apache-license-2-0-apache-2-0)). `eptr2` accesses currently more than 213 services with convenience methods.


  🇹🇷 `eptr2` (**EP**İAŞ **Tr**ansparency **2**.0) paketi [Robokami](https://robokami.com) tarafından [EPİAŞ Şeffaflık Platformu 2.0](https://seffaflik.epias.com.tr/home) API'si üzerine geliştirilmiş bir Python paketidir. Apache License 2.0 ile lisanslanmıştır ([ücretsiz ve büyük ölçüde serbest kullanım](https://www.tldrlegal.com/license/apache-license-2-0-apache-2-0)). `eptr2` 213'ten fazla veri servisine erişim sağlar.




  You can simply use PyPI to install `eptr2` package or directly through GitHub. See [eptr2demo](https://eptr2demo.streamlit.app) page for available calls and examples.

  ```bash
  pip install eptr2
  ```

  NOTE: Starting from v0.4.0, data frame returns will be optional. If pandas is not installed, data frames will not be returned. You can install "dataframe" version with the following command. _(Not implemented yet)_

  ```bash
  pip install "eptr2[dataframe]"
  ```

  ```bash
  pip install git+https://github.com/Tideseed/eptr2.git
  ```



  You can simply use `EPTR2` class to call services with convenience methods.

  ```python
  from eptr2 import EPTR2

  cred_d = {
      "username": "YOUR_USERNAME",
      "password": "YOUR_PASSWORD",
      "is_test": False, ## (optional) Default: False. Set only to True for transparency test servers.
  }

  eptr = EPTR2(
      username=cred_d["username"], password=cred_d["password"], is_test=cred_d["is_test"]
  )

  res = eptr.call("mcp", start_date="2024-07-29", end_date="2024-07-29")
  ```

  You can search for available calls with `eptr.get_available_calls()` function. We plan to include all transparency services in the future.

  ```python
  available_calls = eptr.get_available_calls()
  print(available_calls)
  ```



  Starting from `v0.7.0` you can create aliases for your calls. Just prepare an alias dictionary and add it to the `EPTR2` object.

  ```python
  custom_aliases = {"market-clearing-price": "mcp", "system-marginal-price": "smp"}

  eptr = EPTR2(
      username=cred_d["username"], password=cred_d["password"], is_test=cred_d["is_test"], custom_aliases=custom_aliases
  )
  ```

  As a warning aliases may overwrite the default keys and default aliases. For instance if your alias is "mcp" pointing to "smp", now default "mcp" call is overwritten with "mcp" alias pointing to "smp".

  Library will also have default aliases. You can check aliases with `eptr.get_aliases()` function. If you want to include custom aliases, you can get them with `include_custom_aliases` parameter. `eptr.get_available_calls()` function may also include aliases.

  ```python
  eptr.get_aliases(include_custom_aliases = True)

  eptr.get_available_calls(include_aliases = True)
  ```



  Main object call has some parameters to control the behavior of the package.

  + You can set `ssl_verify` to `False` if you have SSL verification problems.
  + You can set `postprocess` to `False` if you don't want to get data frames as response.
  + You can set `get_raw_response` to `True` if you want to get raw urllib3 response object.


pkgId: 89b8f9593cbf4e83696c58fda21cfb61544defee2b6da21a2ce1d16afddbb779
name: python-epubmangler-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for epubmangler
url: https://github.com/davekeogh/epubmangler
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-epubmangler-0.1.0-1.src.rpm
location_href: Packages/python-epubmangler-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Tools to read and modify the metadata of EPUB files.

  Documentation to be written. See the minimal example below and others in the `example` directory.

  Requires: Python 3.8



  ```python
  from epubmangler import EPub

  with EPub('Frankenstein.epub') as book:  # https://gutenberg.org/ebooks/84

      
      language = book.get('language')
      subjects = book.get_all('subject')
      book.pretty_print()

      
      book.set('title', 'Frankenstein 2')
      book.set_cover('cat_picture.jpg')
      book.set_identifier('http://github.com/davekeogh/epubmangler', 'URI')

      
      book.add('contributor', 'epubmangler', {'opf:role' : 'bkp'})
      book.remove('date', {'opf:event' : 'conversion'})

      
      book.add_subject('Sequel')
      book.add_subject('Comedy')
      book.remove_subject('Horror tales')

      book.save('Frankenstein 2.epub', overwrite=True)

  ```


pkgId: 4250430e938c78465f9ea43b48ebc7751a16059b0a13a4dc5d7f8dbd3411cd18
name: python-epyk
arch: noarch
version: 1.12.30
epoch: 0
release: 1
url: https://github.com/epykure/epyk-ui
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-epyk-1.12.30-1.src.rpm
location_href: Packages/python-epyk-1.12.30-1.noarch.rpm
checksum_type: sha256
summary:
  A simple way to create rich interactive websites and dashboards compatible with modern web frameworks

description:
  <div align="center" >
      <img src="https://raw.githubusercontent.com/epykure/epyk-ui/master/epyk/static/images/epykIcon.PNG">
  <br/><i>A single module to link Python ecosystem to the Web.</i>

  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/epykure/epyk-ui/graphs/commit-activity)
  [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/epyk.svg)](https://pypi.python.org/pypi/epyk/)
  [![Documentation Status](https://readthedocs.org/projects/epyk-ui/badge/?version=latest)](http://epyk-ui.readthedocs.io/?badge=latest)
  [![PRs welcome](https://img.shields.io/badge/PRs-welcome-ff69b4.svg)](https://github.com/epykure/epyk-ui/issues)
  [![Donate](https://img.shields.io/badge/Bitcoin-000?style=for-the-badge&logo=bitcoin&logoColor=white)](https://www.blockchain.com/btc/address/bc1qjhlke0q8g4sk9hdza2afx3ytwp7tmlagsjq9sq)

  </div>

  This project is in active and constant improvement so do not forget to run the below command to always get the latest version install.

  ```
  pip install epyk --upgrade
  ```





  We started the implementation of Epyk already few years ago in order to help Python developers (from beginner to advanced) to present their work to clients or colleagues. At this time there were only few packages in Python available and it was quite difficult for people to move to web technologies like JS, HTML and CSS.

  With this idea we started to create Epyk, a kind of transpiler which is dedicated to assist from Python the developers to develop rich web UI.
  It will try, thanks to the autocompletion provided by the library, to familiarise the developer / data scientist in the wording of web technologies. Indeed we tried as much as possible to keep the same naming convention for CSS attributes and Javascript function to simplify the review of the transpiled HTML page if needed.

  Today Epyk is a bit more than a transpiler as it will encompass more than [**100** JavaScript](https://epyk-ui.readthedocs.io/en/latest/report/supported_ext.html#libraries) and CSS modules.

  Most of the popular web libraries (JQuery, Bootstrap, ApexCharts, ChartJs, Tabulator, AgGrid...) are available from the Epyk components. The resulting page transpiled will only import the ones needed for the selected components.




  For people impatient to understand the concept, you can test the below minimalist dashboard.

  Install Epyk

  > pip install epyk

  The below code will create a simple interactive dashboard relying on internal mock data.

  ```py
  import epyk as pk


  from epyk.mocks import randoms

  page = pk.Page()
  page.headers.dev()

  js_data = page.data.js.record(data=randoms.languages)
  filter1 = js_data.filterGroup("filter1")

  select = page.ui.select([
    {"value": '', 'name': 'name'},
    {"value": 'type', 'name': 'code'},
  ])

  bar = page.ui.charts.chartJs.bar(randoms.languages, y_columns=["rating", 'change'], x_axis='name')
  pie = page.ui.charts.chartJs.pie(randoms.languages, y_columns=['change'], x_axis='name')
  page.ui.row([bar, pie])

  select.change([
    bar.build(filter1.group().sumBy(['rating', 'change'], select.dom.content, 'name')),
    pie.build(filter1.group().sumBy(['change'], select.dom.content, 'name')),
  ])
  ```

  More information in the doc [Getting started with Epyk](https://epyk-ui.readthedocs.io/en/latest/intro/getting-started-with-epyk.html)



  First install Epyk to your Python environment



  ```py
  pip install epyk
  ```

  Create a report and change CSS3 or add JavaScript events.

  ```py
  import epyk as pk

  page = pk.Page()
  page.headers.dev()

  button = page.ui.button("Click me")
  button.style.css.color = "red"
  button.click([
      page.js.console.log("log message")
  ])
  ....


  page.outs.html_file(path="/templates", name="test")
  ```



  Go to the next level and add real time flux in few lines or code. Epyk allows to integrate concepts of Reactive programming thanks
  to Python 3 and asyncio. All the features available in JavaScript (socket, websocket, observable ...) can be used as long as the underlying webserver is compatible.

  If the underlying web server is not compatible with those modern features, Ajax (post, get...) are also available.
  More examples are available in the []template / interactive](https://github.com/epykure/epyk-templates/tree/master/interactives) section.


  On the client side
  ```py
  import epyk as pk

  page = pk.Page()
  page.headers.dev()

  socket.connect(url="127.0.0.1", port=3000, namespace="/news")
  input = page.ui.input()

  pie = page.ui.charts.chartJs.polar([], y_columns=[1], x_axis="x")

  container.subscribe(socket, 'news received', data=socket.message['content'])
  pie.subscribe(socket, 'news received', data=socket.message['pie'])

  page.ui.button("Send").click([
    socket.emit("new news", input.dom.content)
  ])

  page.outs.html_file(path="/templates", name="socket_example")
  ```


  On the server side (using socketio)
  ```py
  from flask import Flask, render_template_string
  from flask_socketio import SocketIO, emit

  app = Flask(__name__)

  app.config['SECRET_KEY'] = 'secret!'
  socketio = SocketIO(app)


  @socketio.on('new news', namespace='/news')
  def new_news(message):
    values = getSeries(5, 100)
    result_pie = chart_data.chartJs.y(values, [1, 4, 5], 'g')
    emit('news received', {"content": message, 'pie': result_pie}, broadcast=True)

  ```



  We maintain a separate Github repository of Jupyter Notebooks that contain an
  interactive tutorial and examples:

  https://nbviewer.jupyter.org/github/epykure/epyk-templates-notebooks/

  To launch a live notebook server with those notebook using [binder](https://mybinder.org/) click on one of the following badge:

  [![Binder](https://beta.mybinder.org/badge.svg)](https://beta.mybinder.org/v2/gh/epykure/epyk-templates-notebooks/master)


  More examples are available on the [official repository](https://github.com/epykure/epyk-templates)




  **No dependency hence  the library can be integrated to any existing Python project**

  Epyk is compatible with the most common Web Python Frameworks (Flask and Django).
  By default, the server package embeds a Flask app as it is easier to install and ready to use.

  The Framework can be included within a Jupyter or JupyterLab project. But this will lead to some limitations - for example Ajax and Socket will not be available.

  The generated Web pages are compatible with the common modern web frameworks.

  [<img src="resources/python.svg" alt="python" height=40>](https://www.python.org)
  [<img src="resources/flask.png" alt="flask" height=40>](https://flask.palletsprojects.com/en/2.2.x/)
  [<img src="resources/tornado.png" alt="tornad0" height=40>](https://www.tornadoweb.org/en/stable/)
  [<img src="resources/django.png" alt="django" height=40>](https://www.djangoproject.com/)
  [<img src="resources/fastapi.svg" alt="fastapi" height=40>](https://fastapi.tiangolo.com)
  [<img src="resources/jupyter.png" alt="jupyter" height=40>](https://nbviewer.org/github/epykure/epyk-templates-notebooks/blob/master/tutorials/components/00_components.ipynb)
  [<img src="resources/collab.png" alt="collab" height=40>](https://colab.research.google.com/drive/12ZL_PHDItSvfILi5akyUc-thd4J8dx6J)
  [<img src="resources/react.png" alt="react" height=40>](https://reactjs.org/)
  [<img src="resources/angular.png" alt="angular" height=40>](https://angularjs.org/)
  [<img src="resources/vue.png" alt="vue">](https://vuejs.org/)
  [<img src="resources/svelte.svg" alt="svelte" height=40>](https://svelte.dev)




  - [Documentation](https://epyk-ui.readthedocs.io/en/latest/)
  - [Changelog](CHANGELOG.md)
  - [Templates](https://github.com/epykure/epyk-templates/tree/master/tutos)
  - [Gallery](https://epykure.github.io/demos/)
  - [Collab & Jupyter](https://epykure.github.io/demos/)
  - [Stackoverflow](https://stackoverflow.com/search?q=epyk)



  **Epyk Studio** is a rich and collaborative framework to simplify the use of this library with bespoke configuration / styles. You can start downloading it [here](https://pypi.org/project/epyk-studio/)
  or contribute to the project on the [Github repository](https://github.com/epykure/epyk-studio). This is still under development hence it is not yet official released




  See [CONTRIBUTING.md](CONTRIBUTING.md)

  Please get in touch if there is any feature you feel Epyk-UI needs.




  Want to donate? Feel free. Send to [blockchain](https://www.blockchain.com/btc/address/bc1qjhlke0q8g4sk9hdza2afx3ytwp7tmlagsjq9sq)

  [<img src="resources/blockchain_qrcode.PNG" alt="Donate" height=100>](https://www.blockchain.com/btc/address/bc1qjhlke0q8g4sk9hdza2afx3ytwp7tmlagsjq9sq)


pkgId: 9f971b6f519c4adbf751a604acde454ec748bd40047a5238c477389d50860e7b
name: python-epythet-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for epythet
url: https://github.com/i2mint/epythet
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-epythet-0.1.7-1.src.rpm
location_href: Packages/python-epythet-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  Documentation and packaging tools.
  Less humdrum, more automation, earlier at the pub.

  [Full documentation here](https://i2mint.github.io/epythet/index.html) generated by Epythet.


  Follow the [Sphinx Installation Guide](https://www.sphinx-doc.org/en/master/usage/installation.html)

  ```
  pip install epythet
  ```
  Follow the short [Quickstart Guide](https://i2mint.github.io/epythet/module_docs/epythet.html#quickstart)


  Tired of learning new frameworks and just need something to quickly display your docstrings in your python files? You've come to the right place. Epythet is built on
   [Sphinx Python Documentation Generator](https://www.sphinx-doc.org/en/master/index.html) but automatically generates pages for each module .py files and a table of contents.



  Add workflow [.github/workflows/publish-docs.yml](https://github.com/i2mint/epythet/blob/master/.github/workflows/publish-docs.yml) to your repo and modify the trigger conditions to suit your needs.  Example below will run automatically when the other "Continuous Integration" workflow is completed.
  ```
  name: GitHub Pages

  on:
    workflow_run:
      workflows: ["Continuous Integration"]
      types:
        - completed

  jobs:
    deploy:
      runs-on: ubuntu-latest
      steps:
        - uses: i2mint/epythet/actions/publish-github-pages@master
          with:
            github-token: ${{ secrets.GITHUB_TOKEN }}
            docs-branch: "gh-pages"
            docs-dir: "./docsrc/_build/html/"
            python-version: "3.10"
  ```
  Setup the GitHub Pages for your repo after the target docs-branch is created.  Set the target branch (default: "gh-pages") and folder as `/(root)`
  ![image](https://user-images.githubusercontent.com/22692594/212193474-80b287e2-211c-470d-aa7c-9f779bdd3866.png)


pkgId: 2e5da4561171f1cf4b57cbac5a17c93dae1514e0345a48d65957776b8ddc200d
name: python-eq-quizgen-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for eq-quizgen
url: https://github.com/edulinq/quizgen
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eq-quizgen-0.3.1-1.src.rpm
location_href: Packages/python-eq-quizgen-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  A tool for generating quizzes from a standard, text-based definition.
  Quizzes can be taken from the standard definition and converted into:
   - PDFs
   - Canvas Quizzes (Uploaded to Canvas)
   - GradeScope Quizzes
     - Both GradeScope-Compatible PDFs and Uploaded to GradeScope
   - HTML Forms
   - [QTI Zip Files](https://en.wikipedia.org/wiki/QTI)

  Sample quizzes that demonstrate all question types are available [in the CSE Cracks course](https://github.com/eriq-augustine/cse-cracks-course/tree/main/quizzes).
  Additionally, you can see examples of good questions by looking at the [test cases for this project](tests/questions/good).

  Documentation Table of Contents:
   - [Installation / Requirements](#installation--requirements)
     - [Python](#python)
     - [KaTeX (NodeJS)](#katex-nodejs)
     - [Canvas Uploading](#canvas-uploading)
     - [GradeScope Uploading](#gradescope-uploading)
   - [Usage](#usage)
     - [Parsing a Specific Quiz](#parsing-a-specific-quiz)
       - [Outputting a JSON Quiz](#outputting-a-json-quiz)
       - [Outputting a TeX Quiz](#outputting-a-tex-quiz)
       - [Outputting an HTML Quiz](#outputting-an-html-quiz)
       - [Outputting a QTI Quiz](#outputting-a-qti-quiz)
     - [Parsing a Specific Question](#parsing-a-specific-question)
     - [Parsing a Specific File](#parsing-a-specific-file)
     - [Uploading a Quiz to Canvas](#uploading-a-quiz-to-canvas)
     - [Uploading a Quiz to GradeScope](#uploading-a-quiz-to-gradescope)
   - [Quiz Format](#quiz-format)
     - [Answer Shuffling](#answer-shuffling)
     - [Question Selection from Groups](#question-selection-from-groups)
     - [Question Prompts](#question-prompts)
     - [Quiz Descriptions](#quiz-descriptions)
   - [Question Types](/docs/question-types.md)
   - [QuizGen Markdown Syntax](/docs/syntax.md)
   - [Builtin Templates and Hints](/docs/builtin-templates.md)
   - [Styling](/docs/styling.md)





  The project can be installed from PyPi with:
  ```
  pip install eq-quizgen
  ```

  Standard Python requirements are listed in `pyproject.toml`.
  The project and Python dependencies can be installed from source with:
  ```
  pip3 install .
  ```



  To output equations in HTML documents (which includes Canvas), [KaTeX](https://katex.org) is required.
  KaTeX is distributed as a NodeJS package, and this project requires that KaTeX is accessible via `npx` (which typically requires it to be installed via `npm`).
  Once NodeJS and NPM are installed, you can just install KaTeX normally:
  ```
  npm install katex
  ```



  To upload quizzes to Canvas, you will need three things:
   - The Canvas Base URL
     - The base URL for the Canvas instance you are using.
     - Ex: `https://canvas.ucsc.edu`
   - The Canvas Course ID
     - The numeric ID for the course you want to upload the quiz under.
     - You can find this by going to the main page for your course (or almost any page related to your course), and looking at the url.
     - Ex: For `https://canvas.ucsc.edu/courses/12345`, the course ID is `12345`.
   - A Canvas Access Token
     - A token is specific for each user, and that user should the have ability to make quizzes for your specific course.
     - To get a new token, go to your account settings ("Account" -> "Settings"), and under "Approved Integrations" click "+ New Access Token".



  To upload quizzes to GradeScope, you will need three things:
   - A GradeScope Instructor Account
     - Technically, any account capable of creating assignments should be sufficient.
   - A GradeScope Account Password
     - If you normally log into GradeScope through an organization account (like via a university email), then you will just need to create a GradeScope password.
       This can be done via the [password reset page](https://www.gradescope.com/reset_password), which in this case will allow you to create a new password.
   - A GradeScope Course ID



  This project has executable modules in the `quizgen.cli` package.
  All executable modules have their own help/usage accessible with the `-h` / `--help` option.



  To parse an entire specific quiz, you can use the `quizgen.cli.parse-quiz` module.
  This is useful if you want to check if a quiz properly parses.
  The basic usage is as follows:
  ```
  python3 -m quizgen.cli.parse.quiz <path to quiz JSON file>
  ```

  This command will output the fully parsed quiz in for format controlled by the `--format` option,
  and will exit with a non-zero status if the parse failed.
  Parsing a quiz is particularly useful in CI to ensure that all course quizzes are properly maintained.

  The `--key` flag can be used to generate an answer key instead of a normal quiz.
  Not all formats support answer keys.



  To output a JSON quiz to a file called `quiz.json`, you can use the following command:
  ```
  python3 -m quizgen.cli.parse.quiz <path to quiz JSON file> --format json > quiz.json
  ```

  A JSON representation of a parsed quiz (which is different from a standard quiz definition) can be useful for debugging.
  If debugging, the `--flatten-groups` flag can be useful (which will include all questions from all groups in the output quiz.



  To output a TeX quiz to a file called `quiz.tex`, you can use the following command:
  ```
  python3 -m quizgen.cli.parse.quiz <path to quiz JSON file> --format tex > quiz.tex
  ```

  You can then compile or edit the TeX file as you see fit.



  To output a HTML quiz to a file called `quiz.html`, you can use the following command:
  ```
  python3 -m quizgen.cli.parse.quiz <path to quiz JSON file> --format html > quiz.html
  ```

  All question in an HTML quiz are grouped together into a single HTML form.



  You can use the same `quizgen.cli.parse.quiz` command to view the core QTI file for a quiz:
  ```
  python3 -m quizgen.cli.parse.quiz <path to quiz JSON file> --format qti > quiz.qti.xml
  ```

  However you will instead probably want a fill QTI zip archive,
  which is the common form used to upload to other platforms (like Canvas).
  To generate a full QTI zip archive, use the `quizgen.cli.qti.create` command:
  ```
  python -m quizgen.cli.qti.create ~/code/cse-cracks-course/quizzes/regex/quiz.json --canvas
  ```

  The `--canvas` flag enables Canvas-specific tweaks required when uploading a QTI file to Canvas.



  To parse a specific quiz question, you can use the `quizgen.cli.parse.question` module.
  This is useful if you want to check if a question properly parses.
  The basic usage is as follows:
  ```
  python3 -m quizgen.cli.parse.question <path to question JSON file>
  ```

  This command will output the fully parsed question in the JSON format,
  and will exit with a non-zero status if the parse failed.

  You can use the same `--format` options used in `quizgen.cli.parse.quiz` to change the output format of the question.
  The question will be placed in a "dummy" quiz, so the output should be fully stand-alone.



  To parse a specific file, you can use the `quizgen.cli.parse.file` module.
  This is useful if you want to check if/how a specific document parses.
  The basic usage is as follows:
  ```
  python3 -m quizgen.cli.parse.file <path to file> --format html
  ```

  This command will output the fully parsed file in for format controlled by the `--format` option,
  and will exit with a non-zero status if the parse failed.
  This can be used to parse prompt markdown files.



  To upload a quiz to Canvas, the `quizgen.cli.canvas.upload` module can be used.
  The basic usage is as follows:
  ```
  python3 -m quizgen.cli.canvas.upload <path to quiz JSON file> --course <canvas course id> --token <canvas access token>
  ```

  If an existing quiz with the same name is found, then nothing will be uploaded unless the `--force` flag is given..



  To create a PDF version of a quiz, `quizgen.cli.pdf.create` module can be used.
  The basic usage is as follows:
  ```
  python3 -m quizgen.cli.pdf.create <path to quiz JSON file>
  ```

  Some additional options that may be useful:
   - `--outdir <dir>` -- Choose where the output (TeX, PDF, etc) will be written to.
   - `--variants <X>` -- Create X variants (alternate versions) if the quiz. X may be in [1, 26].



  To upload a quiz to GradeScope, the `quizgen.cli.gradescope.upload` module can be used.
  The basic usage is as follows:
  ```
  python3 -m quizgen.cli.gradescope.upload <path to quiz JSON file> --course <course id> --user <username> --pass <password>
  ```

  Since GradeScope uses passwords instead of tokens, take extra caution about your password appearing in config files or command histories.
  All the same options for creating PDFs (`quizgen.cli.pdf.create`) can be used.



  Below are some common fields used in the **quiz** JSON configuration.

  | Key                     | Type           | Required? | Default      | Description |
  |-------------------------|----------------|-----------|--------------|-------------|
  | `title`                 | Plain String   | true      |              | The title of the quiz. |
  | `course_title`          | Plain String   | false     | empty string | The title of the course for this quiz. |
  | `term_title`            | Plain String   | false     | empty string | The title of the term this quiz is given in. |
  | `description`           | Parsed String  | true      |              | The description of the quiz. May also be [provided in MD file](#quiz-descriptions). |
  | `date`                  | Plain String   | false     | today        | An [ISO 8601](https://docs.python.org/3/library/datetime.html#datetime.datetime.fromisoformat) date string. |
  | `time_limit_mins`       | Integer        | false     | null/None    | The time limit of the quiz, null/None for no limit. |
  | `shuffle_answers`       | Boolean        | false     | true         | Whether to shuffle question answers/choices, see [Answer Shuffling](#answer-shuffling). |
  | `pick_with_replacement` | Boolean        | false     | true         | Whether to select questions from groups with replacement, see [Question Selection from Groups](#question-selection-from-groups). |
  | `version`               | Plain String   | false     | current git commit hash | The title of the quiz. |
  | `groups`                | Object         | true      |              | The question groups. |


  Below are some common fields used in the **group** JSON configuration.
  The `Inherited?` column indicates values that will be inherited by questions within the group.

  | Key                     | Type           | Required? | Default      | Inherited? | Description |
  |-------------------------|----------------|-----------|--------------|------------|-------------|
  | `name`                  | Plain String   | true      |              | true       | The name of the question group. |
  | `pick_count`            | Integer        | false     | 1            | false      | The number of questions to randomly pick from this group, see [Question Selection from Groups](#question-selection-from-groups). |
  | `points`                | Number         | false     | 10           | true       | The number of points each question from this group is worth. |
  | `shuffle_answers`       | Boolean        | false     | true         | true       | Whether to shuffle question answers/choices, see [Answer Shuffling](#answer-shuffling). |
  | `pick_with_replacement` | Boolean        | false     | true         | false      | Whether to select questions from groups with replacement, see [Question Selection from Groups](#question-selection-from-groups). |
  | `custom_header`         | Plain String   | true      | null/None    | true       | An alternate header for a question. An empty string for no header. |
  | `skip_numbering`        | Boolean        | true      | false        | true       | Whether this question should skip incrementing the question number. |
  | `hints`                 | Object         | true      | empty object | true       | Formatting hints passed the converter about the questions in this group. |
  | `hints_first`           | Object         | true      | empty object | true*      | Hints inherited only by the first question in this group. |
  | `hints_last`            | Object         | true      | empty object | true*      | Hints inherited only by the last question in this group. |
  | `questions`             | Plain String   | true      |              | false      | The questions in the group. |



  By default, answers/choices for each question will be shuffled.
  This behavior can be controlled with the `shuffle_answers` option that appears at the quiz, group, and question level.
  To know if a question's answers will be shuffled, take the conjunction of `shuffle_answers` values for that question's
  config, group, and quiz (with the default value being `true`).



  When selecting answers from a question group,
  the `pick_count` field of a group is used to determine how many questions for choose from each group
  (with the default being 1).
  By default, questions are chosen [with replacement](https://en.wikipedia.org/wiki/Sampling_(statistics)#Replacement_of_selected_units),
  with respects to different variants.
  This means that when variants are created, they could have randomly chosen the same questions from a group.
  The `pick_with_replacement` field of a question/group can be used to override this behavior
  (using the same conjunction semantics see in [Answer Shuffling](#answer-shuffling)).
  If you choose to pick questions without replacement (`pick_with_replacement`: false`),
  then you have to ensure you have enough questions in the group to distribute amongst all variants.
  If you do not have enough questions, then a warning will be output and some questions will be chosen with replacment.



  Question prompts can be provided in two ways:
   - In a "prompt" field in the `question.json`.
   - In a file adjacent to the `question.json` file called `prompt.md`.

  Putting the prompt directly in the JSON can be convenient for questions with short or simple prompts.
  But for larger prompts that may involve things like tables and images,
  having a whole file just for the prompt is generally recommended.

  **WARNING**: Remember that in JSON backslashes will need to be escaped.
  So prompts written in JSON will need to escape backslashes
  (which then in-turn may be used to escape characters in QuizGen markdown).

  For example, in markdown you may have a prompt like:
  ```
  This is a cool\-ish question.
  ```

  In JSON this would need to be:
  ```
  "prompt": "This is a cool\\-ish question."
  ```



  Like question prompts, quiz descriptions can either be specified in the quiz's JSON file,
  or in an adjacent file with the same base filename as the quiz's JSON file but with the `md` extension.

  For example, the description could be in the `my_quiz.json` file:
  ```
  "description": "Look at my awesome quiz\\!"
  ```

  Or, it can be in the `my_quiz.md` file in the same directory as `my_quiz.json`:
  ```
  Look at my awesome quiz\!
  ```

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: d7b37b59b655e7eb172f762d0e84453d8fcb77f3b84aa1a17507c040d8f42358
name: python-eqt-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for eqt
url: https://pypi.org/project/eqt/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eqt-1.0.2-1.src.rpm
location_href: Packages/python-eqt-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Tests](https://img.shields.io/github/actions/workflow/status/TomographicImaging/eqt/test.yml?branch=main&label=Tests&logo=GitHub)](https://github.com/TomographicImaging/eqt/actions?query=branch%3Amain) [![PyPI](https://img.shields.io/pypi/v/eqt.svg?logo=pypi&logoColor=white)](https://pypi.org/project/eqt) [![Conda](https://img.shields.io/conda/v/conda-forge/eqt.svg?label=conda-forge&logo=conda-forge)](https://anaconda.org/conda-forge/eqt)

  Templates & tools to develop Qt GUIs in Python.

  One use case is accepting user input while running another task asynchronously (so that the UI is still responsive).

  1. `UIFormWidget`: a class to help creating Qt forms programmatically, useable in `QDockWidgets` and `QWidget`
  2. `FormDialog`: a `QDialog` with a form inside with <kbd>OK</kbd> and <kbd>Cancel</kbd> buttons
  3. `Worker`: a class that defines a `QRunnable` to handle worker thread setup, signals and wrap up



  Via `pip`/`conda`/`mamba`, i.e. any of the following:

  - `python -m pip install eqt`
  - `conda install -c conda-forge eqt`
  - `mamba install -c conda-forge eqt`



  See the [`examples`](examples) directory, e.g. how to launch a `QDialog` with a form inside using `eqt`'s [`QWidget`](examples/dialog_example.py) or [`FormDialog`](examples/dialog_example_2.py).



  To run a function in a separate thread we use a `Worker` which is a subclass of a `QRunnable`.

  For the `Worker` to work one needs to define:

  1. the function that does what you need
  2. Optional callback methods to get the status of the thread by means of `QtCore.QSignal`s

  On [initialisation](https://github.com/TomographicImaging/eqt/blob/535e487d09d928713d7d6aa1123657597627c4b0/eqt/threading/QtThreading.py#L32-L38) of the `Worker` the user needs to pass the function that has to run in the thread, i.e. `fn` below, and additional optional positional and keyword arguments, which will be passed on to the actual function that is run in the `QRunnable`.

  ```python
  class Worker(QtCore.QRunnable):
      def __init__(self, fn, *args, **kwargs):
          self.fn = fn
          self.args = args
          self.kwargs = kwargs
          self.signals = WorkerSignals()
  ```

  In practice the user will need to pass to the `Worker` as many parameters as there are listed in the [function](https://github.com/TomographicImaging/eqt/blob/535e487d09d928713d7d6aa1123657597627c4b0/eqt/threading/QtThreading.py#L56) to be run.

  ```python
  result = self.fn(*self.args, **self.kwargs)
  ```

  But `Worker` will [add](https://github.com/TomographicImaging/eqt/blob/535e487d09d928713d7d6aa1123657597627c4b0/eqt/threading/QtThreading.py#L41-L43) to the `**kwargs` the following `QSignal`.

  ```python
          
          self.kwargs['progress_callback'] = self.signals.progress
          self.kwargs['message_callback'] = self.signals.message
          self.kwargs['status_callback'] = self.signals.status
  ```

  Therefore it is advisable to always have `**kwargs` in the function `fn` signature so that you can access the `QSignal` and emit the signal required. For instance one could emit a progress by:

  ```python
  def fn(num_iter, **kwargs):
      progress_callback = kwargs.get('progress_callback', None)
      for i in range(num_iter):
          do_something
          if progress_callback is not None:
              progress_callback.emit( i )
  ```



  This is done just after one has defined the `Worker`:

  ```python
  def handle_progress(num_iter):
      
      print ("Current progress is ", num_iter)

  worker = Worker(fn, 10)
  worker.signals.progress.connect(handle_progress)
  ```

  So, each time `fn` comes to `progress_callback.emit( i )` the function `handle_progress` will be called with the parameter `i` of its `for` loop.



  The signals that are available in the `Worker` class are defined in [`WorkerSignal`](https://github.com/TomographicImaging/eqt/blob/535e487d09d928713d7d6aa1123657597627c4b0/eqt/threading/QtThreading.py#L66) and are the following. Below you can also see the type of data that each signal can emit.

  ```python
  finished = QtCore.Signal()
  error = QtCore.Signal(tuple)
  result = QtCore.Signal(object)

  progress = QtCore.Signal(int)
  message = QtCore.Signal(str)
  status = QtCore.Signal(tuple)
  ```

  Read more on [Qt signals and slots](https://doc.qt.io/qt-5/signalsandslots.html) and on how to use them in [PySide2](https://wiki.qt.io/Qt_for_Python_Signals_and_Slots).


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


pkgId: 68e07f9284bb13def12b12eb3e7dccdf7cb5bca839df321ae44904aecef8eabb
name: python-eradication-data-requirements-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for eradication-data-requirements
url: https://github.com/IslasGECI/eradication_data_requirements
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eradication-data-requirements-2.0.0-1.src.rpm
location_href: Packages/python-eradication-data-requirements-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://www.islas.org.mx/"><img src="https://www.islas.org.mx/img/logo.svg" align="right" width="256" /></a>


  Tools for eradication proyects.


pkgId: 02012ac2c6089d5462a97d23f2acceb0c455481552ad4e74fcd893a612acfed0
name: python-eratos-as-api-help
arch: noarch
version: 4.3.0
epoch: 0
release: 1
summary: Development documents and examples for eratos-as-api
url: https://bitbucket.csiro.au/projects/SC/repos/as-models-api/browse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eratos-as-api-4.3.0-1.src.rpm
location_href: Packages/python-eratos-as-api-help-4.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Unit tests may be run with the following command:

      python -m unittest discover



  With this method, you can test using the same environment that as-models-api natively runs in.

  By default, we provide a `docker-compose.yml` file that will run the unittests on both Python 2.7 and Python 3.5

  To run the tests on the working copy of your source:

      docker-compose up

  The first run will take a while to pull down and build the images. Subsequent runs should be very fast.



  Coverage reporting is handled by the Python [coverage](https://coverage.readthedocs.io)
  library. If necessary, it can be installed as follows:

      sudo pip install coverage

  An HTML coverage report can then be generated with these commands:

      coverage run -m unittest discover
      coverage html

  The results will be placed in the '/htmlcov' directory.


pkgId: 9750637fccf43817bd9ceb9eab01c44cb0aa02f4db2f3e11c002a56efb1b535a
name: python-eratos-as-client-help
arch: noarch
version: 2.23.0
epoch: 0
release: 1
summary: Development documents and examples for eratos-as-client
url: https://bitbucket.csiro.au/projects/SC/repos/as-client-python/browse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eratos-as-client-2.23.0-1.src.rpm
location_href: Packages/python-eratos-as-client-help-2.23.0-1.noarch.rpm
checksum_type: sha256
description:
  AS-Client - Client Library for Analysis Services



  Documentation of the client's classes and functions can be generated with
  [Doxygen](http://www.stack.nl/~dimitri/doxygen/index.html). The project also
  uses [doxypypy](https://github.com/Feneric/doxypypy) - a Python-specific filter
  for Doxygen - to allow the documentation to be specified more naturally within
  the various Python docstrings throughout the code.



  Naturally, generating the documentation requires that Doxygen be installed - see
  https://www.stack.nl/~dimitri/doxygen/manual/install.html for instructions.

  The doxypypy filter is most easily installed using the Python "pip" package
  manager (see https://pip.pypa.io/en/stable/installing/ for installation
  instructions for pip). With pip installed, simply issue the following
  command to install doxypypy (for Unix-like systems):

      sudo pip install doxypypy

  Unfortunately, Doxygen assumes that filters can be called without supplying any
  command-line parameters except for the path of the file to filter.
  Unfortunately, doing so with a standard doxypypy installation will omit several
  important options. The Doxyfile included with this project addresses this by
  instead calling a simple wrapper script `doxypypy.sh` that is included as part
  of the project.



  To generate the documentation for the client, simply change directory to the
  project's root directory (containing the `Doxyfile` file), and issue the
  following command:

      doxygen Doxyfile

  This will process the Python source files, and generate a new `doc` directory
  containing the documentation files.


pkgId: 959189a8a8a6bc58b8800917e6d74d0979a11101935e2c65fa6a90fb2528ab93
name: python-eratos-sensor-help
arch: noarch
version: 2.17.0
epoch: 0
release: 1
summary: Development documents and examples for eratos-sensor
url: https://bitbucket.csiro.au/projects/SC/repos/sensor-api-python-client/browse
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eratos-sensor-2.17.0-1.src.rpm
location_href: Packages/python-eratos-sensor-help-2.17.0-1.noarch.rpm
checksum_type: sha256
description:
  This project is a python client implementation for the [Senaps Sensor API v2](https://senaps.io/api-docs/).
  Project home page: https://bitbucket.csiro.au/projects/SC/repos/sensor-api-python-client/browse


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

  ```console
  pip install erf-gui
  ```

  `erf-gui` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 74b85b916ba60be0108955cc9a693b42c0626ae27fbaa219ffe70f816112f73f
name: python-eric-sse-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for eric-sse
url: https://laxertu.github.io/eric
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eric-sse-0.6.1-1.src.rpm
location_href: Packages/python-eric-sse-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <a id="the-lightweight-library-for-async-messaging-nobody-expects"></a>



  *Installation*

  pip install eric-sse

  *Features*

  * Send to one listener and broadcast
  * SSE format was adopted by design, making the library suitable for such kind of model
  * Callbacks and threading support
  * Sockets server prefab for offline inter process communication

  *Possible applications*

  * Message delivery mechanisms based on SSE
  * Message queue processing (logging, etc)
  * See [https://github.com/laxertu/eric-api](https://github.com/laxertu/eric-api)

  *Documentation*

  * Home [https://laxertu.github.io/eric](https://laxertu.github.io/eric)


  *Trivia*

  * Library name pretends to be a tribute to the following movie [https://en.wikipedia.org/wiki/Looking_for_Eric](https://en.wikipedia.org/wiki/Looking_for_Eric)


pkgId: e41a4a48ed9d36e6410d4cd6873720524eadd7507cf8b2891b6b4acd165f824d
name: python-erlab-help
arch: noarch
version: 3.2.0
epoch: 0
release: 1
summary: Development documents and examples for erlab
url: https://pypi.org/project/erlab/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-erlab-3.2.0-1.src.rpm
location_href: Packages/python-erlab-help-3.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/erlab?logo=python&logoColor=white)](https://pypi.org/project/erlab/)
  [![PyPi](https://img.shields.io/pypi/v/erlab?logo=pypi&logoColor=white)](https://pypi.org/project/erlab/)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/erlab?logo=condaforge&logoColor=white)](https://anaconda.org/conda-forge/erlab)
  [![Workflow Status](https://img.shields.io/github/actions/workflow/status/kmnhan/erlabpy/ci.yml?logo=github&label=tests)](https://github.com/kmnhan/erlabpy/actions/workflows/ci.yml)
  [![Documentation Status](https://img.shields.io/readthedocs/erlabpy?logo=readthedocs&logoColor=white)](https://erlabpy.readthedocs.io/)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/kmnhan/erlabpy/main.svg)](https://results.pre-commit.ci/latest/github/kmnhan/erlabpy/main)
  [![Codecov Coverage](https://img.shields.io/codecov/c/github/kmnhan/erlabpy?logo=codecov&logoColor=white)](https://codecov.io/gh/kmnhan/erlabpy)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![SPEC 1 — Lazy Loading of Submodules and Functions](https://img.shields.io/badge/SPEC-1-green?labelColor=%23004811&color=%235CA038)](https://scientific-python.org/specs/spec-0001/)

  A library that provides a set of tools and utilities to handle, manipulate, and
  visualize data from condensed matter physics experiments, with a focus on angle-resolved
  photoemission spectroscopy (ARPES).

  *ERLabPy* is built on top of the popular scientific computing libraries
  [*numpy*](https://numpy.org/), [*scipy*](https://scipy.org/), and
  [*xarray*](https://xarray.pydata.org/), and is designed to be easy to use and integrate
  with existing scientific Python workflows so that you can quickly get started with your
  data analysis. The package is still under development, so if you have any questions or
  suggestions, please feel free to contact us. We hope you find ERLabPy useful for your
  research!

  *ERLabPy* is developed and maintained by the electronic structure research
  laboratory at Korea Advanced Institute of Science and Technology (KAIST).



  - **Data Loading**: A flexible and extensible data loading system is included, capable
    of handling various data formats.
  - **Data Manipulation**: A set of tools for manipulating and transforming data,
    including interpolation, masking and symmetrization is provided.
  - **Plotting**: ERLabPy provides many different plotting functions for visualizing image
    data, including 2D and 3D plots. Publication-quality plots can be generated with
    minimal effort.
  - **Fitting**: Several functions and models are implemented for fitting various types of
    data, including broadened Fermi-Dirac distributions, momentum distribution curves
    (MDCs), and energy distribution curves (EDCs).
  - **Interactive Data Visualization**: ERLabPy includes many interactive plotting
    routines that resemble panels in Igor Pro that are very responsive and easy to use.
    See screenshots below.
  - **Active Development**: ERLabPy is actively developed and maintained, with new
    features and improvements being added regularly.



  Most interactive windows support dark mode. Viewing this page from a supported browser
  with dark mode enabled will show the dark mode screenshots.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/kmnhan/erlabpy/blob/main/docs/source/images/imagetool_dark.png?raw=true">
    <source media="(prefers-color-scheme: light)" srcset="https://github.com/kmnhan/erlabpy/blob/main/docs/source/images/imagetool_light.png?raw=true">
    <img alt="Imagetool in action." src="https://github.com/kmnhan/erlabpy/blob/main/docs/source/images/imagetool_light.png?raw=true">
  </picture>

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/kmnhan/erlabpy/blob/main/docs/source/images/ktool_1_dark.png?raw=true">
    <source media="(prefers-color-scheme: light)" srcset="https://github.com/kmnhan/erlabpy/blob/main/docs/source/images/ktool_1_light.png?raw=true">
    <img alt="Imagetool in action." src="https://github.com/kmnhan/erlabpy/blob/main/docs/source/images/ktool_1_light.png?raw=true">
  </picture>



  To get started, see [installation instructions](https://erlabpy.readthedocs.io/en/stable/getting-started.html).



  The full documentation for ERLabPy is available on [Read the Docs](https://erlabpy.readthedocs.io/).



  ERLabPy is an open-source project and we welcome contributions from the community. If
  you find any bugs, issues, or have any suggestions, please open an issue
  [here](https://github.com/kmnhan/erlabpy/issues).

  If you have any questions or need help with using ERLabPy, please feel free to ask on
  the [Discussions page](https://github.com/kmnhan/erlabpy/discussions).

  If you would like to add a new feature or fix a bug yourself, we would love to have your
  contribution. Feel free to fork the repository and submit a pull request with your
  changes.

  For more information on contributing, see our [Contributing page](https://erlabpy.readthedocs.io/en/stable/contributing.html).



  This project is licensed under the terms of the [GPL-3.0 License](LICENSE).

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


pkgId: 13a0f7dfa5ecb0848035f0f2097d2505f1419c3a629431642d3e059393419cf4
name: python-erpl-help
arch: noarch
version: 0.1.11
epoch: 0
release: 1
summary: Development documents and examples for erpl
url: https://pypi.org/project/erpl/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-erpl-0.1.11-1.src.rpm
location_href: Packages/python-erpl-help-0.1.11-1.noarch.rpm
checksum_type: sha256
description:
  Warning: Still development

  ERPL (Escape Room Programming Language) is a programming language to facilitate the creation of virtual escape room games. The program is composed of a parser and an engine (both can be used separately). The parser will receive an .erpl file (described below) that will have the escape room information, it will analyze it and then the engine with this information will generate the escape room game, with the help of the pygame module.



          erparse <.erpl file>



       -h, --help                                      show this help message and exit
       -o OUTPUT , --output OUTPUT                     output (json) file (default is stdout)
       -i INPUT , --input  INPUT                       input file (.erpl file)
       -args ARGS [ARGS ...], --args ARGS [ARGS ...]   arguments to be replaced in the erpl file



          erengine <json file>



      -h, --help                                      show this help message and exit
      -i INPUT , --input  INPUT                       input file (json file)
      -e ENGINE, --engine ENGINE                      Escolha a engine do jogo: pygame ou p5


pkgId: 2a633b4e64959c733dd50c96f4d94ffe082331f0a4b20d4999a862cdb08f4098
name: python-esbmtk-help
arch: noarch
version: 0.14.0.6
epoch: 0
release: 1
summary: Development documents and examples for esbmtk
url: https://github.com/uliw/esbmtk
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esbmtk-0.14.0.6-1.src.rpm
location_href: Packages/python-esbmtk-help-0.14.0.6-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://pypi.org/project/esbmtk/">
  <img alt="Documentation Status" src="https://img.shields.io/pypi/v/esbmtk.svg"/>
  </a>

  <a href="https://pyscaffold.org">
  <img alt="Project generated with PyScaffold" src="https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold"/>
  </a>

  <a href="https://esbmtk.readthedocs.io/en/latest/?badge=latest">
  <img alt="Documentation Status" src="https://readthedocs.org/projects/esbmtk/badge/?version=latest" />
  </a>

  <a href="https://img.shields.io/badge/Python-3.11-blue.svg">
  <img alt="Python 3.11 ready" src="https://www.python.org" />
  </a>

  <a href="https://doi.org/10.5281/zenodo.11959366">
  <img alt=Zenodo DOI src="https://zenodo.org/badge/DOI/10.5281/zenodo.11959366.svg" alt="DOI"></a>




  <img src="https://raw.githubusercontent.com/uliw/esbmtk/staging/mpc.png" width="600px" align="center">"

  ESBMTK is a python library that aims to simplify typical box modeling projects in the Earth-Sciences. It uses a declarative approach to describe models, and abstracts typical modeling tasks like gas-exchange and carbonate dissolution through python classes. See the manual at <https://esbmtk.readthedocs.io/> for installation instructions, usage, and example code.

  ESBMTK is available via

  -   GitHub `git clone https://github.com/uliw/esbmtk.git`
  -   pypi <https://pypi.org/project/esbmtk/>
  -   conda-forge <https://anaconda.org/conda-forge/esbmtk>
  -   sample code is available at <https://github.com/uliw/ESBMTK-Examples>

  ESBMTK is under active development, before updating, please check the [Changelog](https://esbmtk.readthedocs.io/en/latest/changelog.html)


pkgId: dabed55dba0b3da46da4929d4a26a4c2f3a992d2ca895367c7e7a2de05e142a6
name: python-esig-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for esig
url: https://pypi.org/project/esig/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esig-1.0.0-1.src.rpm
location_href: Packages/python-esig-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  The Python package [esig](https://pypi.org/project/esig/) provides a toolset (previously called sigtools) for transforming vector time series in stream space to signatures in effect space. It is based on the [libalgebra](https://github.com/terrylyons/libalgebra) C++ library.

  [![build](https://github.com/datasig-ac-uk/esig/actions/workflows/build.yml/badge.svg?branch=release)](https://github.com/datasig-ac-uk/esig/actions/workflows/build.yml)


  esig can be installed from a wheel using pip in most cases.
  The wheels contain all of the dependencies and thus make it easy to use the package.
  For example, on Python 3.8, you can install esig using the following console command:
  ```
  python3.8 -m pip install esig
  ```
  (You may need to tweak this command based on your platform, Python version, and preferences.)

  esig can be compiled from source, but this is not advised.
  More information can be found in the [documentation](https://esig.readthedocs.org/en/latest).


  esig provides a collection of basic functions for computing the signature of a data stream in the form of a Numpy array.
  The `stream2sig` function computes the signature of a data stream up to a specific depth.
  For example, we can create a very simple data stream and compute its signature as follows.
  ```python3
  import numpy as np
  import esig

  stream = np.array([
      [1.0, 1.0],
      [3.0, 4.0],
      [5.0, 2.0],
      [8.0, 6.0]
  ])
  depth = 2

  sig = esig.stream2sig(stream, depth) # compute the signature
  print(sig) # prints "[1.0, 7.0, 5.0, 24.5, 19.0, 16.0, 12.5]"
  ```
  The signature is returned as a flat Numpy array that contains the terms of the signature - which is fundamentally a higher dimensional tensor - in degree order.
  This first element is always 1.0, which corresponds to the empty tensor key.
  In this case the dimension is 2 (specified by the number of columns in the stream array), and so the next two elements are the signature elements corresponding to the words (1) and (2).
  These are the depth 1 words.
  The final 4 elements are the depth 2 words (1,1), (1,2), (2,1), and (2,2).
  esig provides the `sigkeys` function to generate these labels for you based on the parameters of the data.
  ```python3
  width = 2
  sig_keys = esig.sigkeys(width, depth)
  print(sig_keys) # prints " () (1) (2) (1,1) (1,2) (2,1) (2,2)"
  ```
  To compute the log signature of a data stream you use the `stream2logsig` function.
  This works in a similar manner to the `stream2sig` function in that it takes a Numpy array (the data) and a depth and returns a flat Numpy array containing the elements of the log signature in degree order.
  ```python3
  log_sig = esig.stream2logsig(stream, depth)
  print(log_sig) # prints "[7.  5.  1.5]"
  ```
  Here the first two elements are the depth 1 Lie elements (corresponding to the letters 1 and 2) and the third element is the coefficient of the Hall basis element \[1,2\].
  Again, esig provides a utility function `logsigkeys` for getting the keys that correspond to the coefficients in order for the log signature.
  ```python3
  log_sig_keys = esig.logsigkeys(width, depth)
  print(log_sig_keys) # prints " 1 2 [1,2]"
  ```
  There are two additional utility functions for computing the size of a signature or logsignature with a specified dimension and depth: `sigdim` and `logsigdim`.
  These functions return an integer that is the dimension of the Numpy array returned from the `stream2sig` or `stream2logsig` functions, respectively.

  esig also provides another function `recombine`, which performs a reduction of a measure defined on a large ensemble in a way so that the resulting measure has the same total mass, but is supported on a (relatively) small subset of the original ensemble.
  In particuar, the expected value over the ensemble with respect to the new measure agrees with that of the original measure.


  esig uses libalgebra as a backend for computing signatures and log signatures
   by default.
  However, the computation backend can be changed to instead use an alternative
   library for computing signatures and log signatures.
  This is achieved by using the `set_backend` function in esig and providing
   the name of the backed that you wish to use.
  For example, we can switch to using the `iisignature` package as a backend by
   first installing the `iisignature` package and then using the command
  ```python3
  import esig
  esig.set_backend("iisignature")
  ```
  To make it easier to install and use `iisignature` as a backend, it is
   offered as an optional extra when installing esig:
  ```
  python3.8 -m pip install esig[iisignature]
  ```
  You can also define your own backend for performing calculations by creating
   a class derived from `esig.backends.BackendBase`, implementing the methods
   `describe_path` (log_signature) and `signature` and related methods.


pkgId: 2551b9b153074b1994d7f9a238bfebd5eaa8bdd5cc15b5748e596461279e3e4e
name: python-esm-efficient-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for esm-efficient
url: https://github.com/uci-cbcl/esm-efficient
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esm-efficient-0.0.7-1.src.rpm
location_href: Packages/python-esm-efficient-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/esm-efficient.svg)](https://pypi.python.org/pypi/esm-efficient)
  [![DOI:10.1101/2024.10.22.619563](http://img.shields.io/badge/DOI-10.1101/2024.10.22.619563-B31B1B.svg)](https://doi.org/10.1101/2024.10.22.619563)

  Efficient implementation of the ESM family of models: ESM1b, ESM1v, ESM2, ESMC.

  <img src="docs/methods.png"  width="300" /> <img src="docs/speedup.png" width="400" />



  Download the appropriate version of [pytorch](https://pytorch.org/get-started/locally/) and install it.
  ```
  pip install flash-attn --no-build-isolation
  pip install esm-efficient
  ```



  ```python
  from esme import ESM

  model = ESM.from_pretrained('esmc') # or 'esm1b', 'esm1v', 'esm2', 'esm2_8m', ...
  ```
  This will download the model weights from the HuggingFace model hub and load the model. [See doc from getting started]().


  Predict the log probabilities of a sequence of tokens using the model.

  ```python
  import torch
  from esme import ESM2
  from esme.alphabet import tokenize


  model = ESM2.from_pretrained("{model}.safetensors", device=0)

  tokens = tokenize(['MEEPQSDPSVEPPLSQESTFSLDLWK', 'MADQLTEEQIAEFKEAFSLFDKDG'])
  tokens = tokens.to(0)


  logits = model(tokens)



  log_probs = model.predict_log_prob(tokens)

  ```


  ```python
  from esme.alphabet import tokenize_unpad

  tokens, indices, cu_lens, max_len = tokenize_unpad(['MEEPQSDPSVEPPLSQETFSDLWK', 'MADQLTEEQIAEFKEAFSLFDKDG'])
  tokens = tokens.to(0)
  cu_lens = cu_lens.to(0)
  log_probs = model.predict_log_prob(tokens, (cu_lens, max_len))

  ```


  ```python

  from esme.variant import predict_mask_margin

  seq = 'MEEPQSDPSVEPPLSQETFSDLWK'
  df = predict_mask_margin(model, seq)




  ```


  ```python


  model.add_lora(rank=16, layers=('query', 'key', 'value'), adapter_names=['adapter1', 'adapter2'])


  model.mark_only_lora_as_trainable()


  model.save_lora('<path>.safetensors', adapter_names=['adapter1'])


  model.load_lora('<path>.safetensors')
  ```


  ```python
  model = ESM2.from_pretrained('8M.safetensors', quantization='4bit', device=0)
  ```

  Activation checkpointing of each transformer layer:
  ```python
  model = ESM2.from_pretrained('8M.safetensors', checkpointing=True)
  ```



  We provide pytorch lightning trainer for training the model. The following code trains the model with the masked language model objective:

  ```python
  from esme import ESM2
  from esme.data import MaskedFastaTokenDataModule
  from esme.trainer import MaskedPLM

  trainer = MaskedPLM(model) # pytorch lightning trainer
  datamodule = MaskedFastaTokenDataModule(
      train_fasta='train.fasta',
      val_fasta='val.fasta',
      token_per_batch=50_000,
  ) # data module for training
  trainer.fit(datamodule)
  ```



  The model weights can be downloaded from the HuggingFace: [https://huggingface.co/mhcelik/esm-efficient/tree/main](https://huggingface.co/mhcelik/esm-efficient/tree/main)



  To perform the evaluation reported in the paper, run the following command:

  ```bash
  snakemake -n --use-conda
  ```

  This will download the data, train the models, and evaluate them. The results will be saved in the `results` directory.
  See the `workflow/Snakefile` for more details.

  To generate a specific figures in the paper, run the following command:
  ```bash
  snakemake reports/paper_figures/figure-2.pdf -n --use-conda
  ```


  Manuscript for the efficient implementation: [https://www.biorxiv.org/content/10.1101/2024.10.22.619563v1](https://www.biorxiv.org/content/10.1101/2024.10.22.619563v1)
  ```bib
  @article {Celik2024.10.22.619563,
      author = {Celik, Muhammed Hasan and Xie, Xiaohui},
      title = {Efficient Inference, Training, and Fine-tuning of Protein Language Models},
      elocation-id = {2024.10.22.619563},
      year = {2024},
      doi = {10.1101/2024.10.22.619563},
      publisher = {Cold Spring Harbor Laboratory},
      URL = {https://www.biorxiv.org/content/early/2024/10/25/2024.10.22.619563},
      eprint = {https://www.biorxiv.org/content/early/2024/10/25/2024.10.22.619563.full.pdf},
      journal = {bioRxiv}
  }
  ```
  Also, cite original ESM papers for the related model: [https://github.com/facebookresearch/esm](https://github.com/facebookresearch/esm)


  This code implements ESM models from scratch and is licensed under the MIT License. Refer to the [esm](https://github.com/evolutionaryscale/esm) and [fair-esm](https://github.com/facebookresearch/esm) repositories for the licenses for the model weights.


pkgId: 1619d0ca0ba6758f7e836478598c9051b696cb09254ad84d09788ebd6bfb8161
name: python-esmerald-help
arch: noarch
version: 3.6.1
epoch: 0
release: 1
summary: Development documents and examples for esmerald
url: https://github.com/dymmond/esmerald
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esmerald-3.6.1-1.src.rpm
location_href: Packages/python-esmerald-help-3.6.1-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: [https://esmerald.dev](https://www.esmerald.dev) 📚
  **Source Code**: [https://github.com/dymmond/esmerald](https://github.com/dymmond/esmerald)


pkgId: 9dad283a56e1b9effe74d1f8cffc9164f6b8ffcb442fb8915c46296ebf28455b
name: python-esp-docs-help
arch: noarch
version: 1.12.0
epoch: 0
release: 1
summary: Development documents and examples for esp-docs
url: https://github.com/espressif/esp-docs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esp-docs-1.12.0-1.src.rpm
location_href: Packages/python-esp-docs-help-1.12.0-1.noarch.rpm
checksum_type: sha256
description:
  Esp-docs is a python based wrapper for the documentation building package Sphinx.

  It is intended to simplify and extend Sphinx's functionality to better suit what is needed for building documentation for Espressif's development frameworks

  Provides:
   * Functionality for building documentation for multiple targets (e.g. ESP32 and ESP32-C3) from the same rst source files.
   * Sphinx extensions used at Espressif
   * Scripts for deploying docs

  For a more in-depth guide on how to install, write, and compile documentation please see [ESP-Docs User Guide](https://docs.espressif.com/projects/esp-docs/en/latest/index.html).


pkgId: 69d80378751c01988d74796536f4e432654ef2c3ab243fdf28ec4126b97cd9a8
name: python-esperanto-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for esperanto
url: https://github.com/lfnovo/esperanto
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esperanto-0.5.0-1.src.rpm
location_href: Packages/python-esperanto-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/esperanto.svg)](https://badge.fury.io/py/esperanto)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/esperanto)](https://pypi.org/project/esperanto/)
  [![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen)](https://github.com/lfnovo/esperanto)
  [![Python Versions](https://img.shields.io/pypi/pyversions/esperanto)](https://pypi.org/project/esperanto/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  Esperanto is a powerful Python library that provides a unified interface for interacting with various Large Language Model (LLM) providers. It simplifies the process of working with different LLM APIs by offering a consistent interface while maintaining provider-specific optimizations.



  - **Unified Interface**: Work with multiple LLM providers using a consistent API
  - **Provider Support**:
    - OpenAI (GPT-4, GPT-3.5)
    - Anthropic (Claude 3)
    - OpenRouter (Access to multiple models)
    - xAI (Grok)
    - Groq (Mixtral, Llama)
    - Gemini
    - Vertex AI (Google Cloud)
    - Ollama (Local deployment)
  - **Embedding Support**: Multiple embedding providers for vector representations
  - **Async Support**: Both synchronous and asynchronous API calls
  - **Streaming**: Support for streaming responses
  - **Structured Output**: JSON output formatting (where supported)
  - **LangChain Integration**: Easy conversion to LangChain chat models

  For detailed information about our providers, check out:
  - [LLM Providers Documentation](https://github.com/lfnovo/esperanto/blob/main/docs/llm.md)
  - [Embedding Providers Documentation](https://github.com/lfnovo/esperanto/blob/main/docs/embedding.md)



  Install Esperanto using Poetry:

  ```bash
  poetry add esperanto
  ```

  Or with pip:

  ```bash
  pip install esperanto
  ```



  Esperanto supports multiple providers through optional dependencies. Install only what you need:

  ```bash

  poetry add esperanto[openai]



  poetry add esperanto[anthropic]



  poetry add esperanto[gemini]



  poetry add esperanto[vertex]



  poetry add esperanto[ollama]



  poetry add esperanto[groq]



  poetry add "esperanto[openai,anthropic,gemini,groq]"



  poetry add "esperanto[all]"

  ```



  | Provider  | LLM Support | Embedding Support | JSON Mode |
  |-----------|-------------|------------------|-----------|
  | OpenAI    | ✅          | ✅               | ✅        |
  | Anthropic | ✅          | ❌               | ✅        |
  | Groq      | ✅          | ❌               | ✅        |
  | Gemini    | ✅          | ✅               | ✅        |
  | Vertex AI | ✅          | ✅               | ❌        |
  | Ollama    | ✅          | ✅               | ❌        |



  You can use Esperanto in two ways: directly with provider-specific classes or through the AI Factory.



  ```python
  from esperanto.factory import AIFactory


  model = AIFactory.create_llm("openai", "gpt-3.5-turbo")
  messages = [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "What's the capital of France?"},
  ]
  response = model.chat_complete(messages)


  model = AIFactory.create_embedding("openai", "text-embedding-3-small")
  texts = ["Hello, world!", "Another text"]
  embeddings = model.embed(texts)
  ```



  All providers in Esperanto return standardized response objects, making it easy to work with different models without changing your code.



  ```python
  from esperanto.factory import AIFactory

  model = AIFactory.create_llm("openai", "gpt-3.5-turbo")
  messages = [{"role": "user", "content": "Hello!"}]


  response = model.chat_complete(messages)
  print(response.choices[0].message.content)  # The actual response text
  print(response.choices[0].message.role)     # 'assistant'
  print(response.model)                       # The model used
  print(response.usage.total_tokens)          # Token usage information


  for chunk in model.chat_complete(messages):
      print(chunk.choices[0].delta.content)   # Partial response text
  ```



  ```python
  from esperanto.factory import AIFactory

  model = AIFactory.create_embedding("openai", "text-embedding-3-small")
  texts = ["Hello, world!", "Another text"]


  response = model.embed(texts)
  print(response.data[0].embedding)     # Vector for first text
  print(response.data[0].index)         # Index of the text (0)
  print(response.model)                 # The model used
  print(response.usage.total_tokens)    # Token usage information
  ```

  The standardized response objects ensure consistency across different providers, making it easy to:
  - Switch between providers without changing your application code
  - Handle responses in a uniform way
  - Access common attributes like token usage and model information



  - **Documentation**: [GitHub Documentation](https://github.com/lfnovo/esperanto#readme)
  - **Source Code**: [GitHub Repository](https://github.com/lfnovo/esperanto)
  - **Issue Tracker**: [GitHub Issues](https://github.com/lfnovo/esperanto/issues)



  This project is licensed under the MIT License - see the [LICENSE](https://github.com/lfnovo/esperanto/blob/main/LICENSE) file for details.


pkgId: 47e20d9e6eaee9cd0e8c8a9671ce2bfd910d9f3d6d560e760f07e09cab9cb9cf
name: python-esperanto-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for esperanto
url: https://pypi.org/project/esperanto/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esperanto-0.7.2-1.src.rpm
location_href: Packages/python-esperanto-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/esperanto.svg)](https://badge.fury.io/py/esperanto)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/esperanto)](https://pypi.org/project/esperanto/)
  [![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen)](https://github.com/lfnovo/esperanto)
  [![Python Versions](https://img.shields.io/pypi/pyversions/esperanto)](https://pypi.org/project/esperanto/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  Esperanto is a powerful Python library that provides a unified interface for interacting with various Large Language Model (LLM) providers. It simplifies the process of working with different AI models (LLMs, Embedders, Transcribers) APIs by offering a consistent interface while maintaining provider-specific optimizations.



  - **Unified Interface**: Work with multiple LLM providers using a consistent API
  - **Provider Support**:
    - OpenAI (GPT-4, GPT-3.5, o1, Whisper, TTS)
    - Anthropic (Claude 3)
    - OpenRouter (Access to multiple models)
    - xAI (Grok)
    - Groq (Mixtral, Llama, Whisper)
    - Google GenAI (Gemini LLM, Text To Speech, Embedding)
    - Vertex AI (Google Cloud)
    - Ollama (Local deployment)
    - ElevenLabs (Text-to-Speech)

  - **Embedding Support**: Multiple embedding providers for vector representations
  - **Speech-to-Text Support**: Transcribe audio using multiple providers
  - **Text-to-Speech Support**: Generate speech using multiple providers
  - **Async Support**: Both synchronous and asynchronous API calls
  - **Streaming**: Support for streaming responses
  - **Structured Output**: JSON output formatting (where supported)
  - **LangChain Integration**: Easy conversion to LangChain chat models

  For detailed information about our providers, check out:
  - [LLM Providers Documentation](https://github.com/lfnovo/esperanto/blob/main/docs/llm.md)
  - [Embedding Providers Documentation](https://github.com/lfnovo/esperanto/blob/main/docs/embedding.md)
  - [Speech-to-Text Providers Documentation](https://github.com/lfnovo/esperanto/blob/main/docs/speech_to_text.md)
  - [Text-to-Speech Providers Documentation](https://github.com/lfnovo/esperanto/blob/main/docs/text_to_speech.md)



  Install Esperanto using pip:

  ```bash
  pip install esperanto
  ```

  For specific providers, install with their extras:

  ```bash

  pip install "esperanto[openai]"


  pip install "esperanto[anthropic]"


  pip install "esperanto[google]"


  pip install "esperanto[vertex]"


  pip install "esperanto[groq]"


  pip install "esperanto[ollama]"


  pip install "esperanto[all]"
  ```



  | Provider    | LLM Support | Embedding Support | Speech-to-Text | Text-to-Speech | JSON Mode |
  |------------|-------------|------------------|----------------|----------------|-----------|
  | OpenAI     | ✅          | ✅               | ✅             | ✅             | ✅        |
  | Anthropic  | ✅          | ❌               | ❌             | ❌             | ✅        |
  | Groq       | ✅          | ❌               | ✅             | ❌             | ✅        |
  | Google (GenAI)     | ✅          | ✅               | ❌             | ✅             | ✅        |
  | Vertex AI  | ✅          | ✅               | ❌             | ❌             | ❌        |
  | Ollama     | ✅          | ✅               | ❌             | ❌             | ❌        |
  | ElevenLabs | ❌          | ❌               | ❌             | ✅             | ❌        |



  You can use Esperanto in two ways: directly with provider-specific classes or through the AI Factory.



  ```python
  from esperanto.factory import AIFactory


  model = AIFactory.create_llm("openai", "gpt-3.5-turbo")
  messages = [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "What's the capital of France?"},
  ]
  response = model.chat_complete(messages)


  model = AIFactory.create_embedding("openai", "text-embedding-3-small")
  texts = ["Hello, world!", "Another text"]
  embeddings = model.embed(texts)
  ```



  All providers in Esperanto return standardized response objects, making it easy to work with different models without changing your code.



  ```python
  from esperanto.factory import AIFactory

  model = AIFactory.create_llm("openai", "gpt-3.5-turbo")
  messages = [{"role": "user", "content": "Hello!"}]


  response = model.chat_complete(messages)
  print(response.choices[0].message.content)  # The actual response text
  print(response.choices[0].message.role)     # 'assistant'
  print(response.model)                       # The model used
  print(response.usage.total_tokens)          # Token usage information


  for chunk in model.chat_complete(messages):
      print(chunk.choices[0].delta.content)   # Partial response text
  ```



  ```python
  from esperanto.factory import AIFactory

  model = AIFactory.create_embedding("openai", "text-embedding-3-small")
  texts = ["Hello, world!", "Another text"]


  response = model.embed(texts)
  print(response.data[0].embedding)     # Vector for first text
  print(response.data[0].index)         # Index of the text (0)
  print(response.model)                 # The model used
  print(response.usage.total_tokens)    # Token usage information
  ```

  The standardized response objects ensure consistency across different providers, making it easy to:
  - Switch between providers without changing your application code
  - Handle responses in a uniform way
  - Access common attributes like token usage and model information



  - **Documentation**: [GitHub Documentation](https://github.com/lfnovo/esperanto#readme)
  - **Source Code**: [GitHub Repository](https://github.com/lfnovo/esperanto)
  - **Issue Tracker**: [GitHub Issues](https://github.com/lfnovo/esperanto/issues)



  This project is licensed under the MIT License - see the [LICENSE](https://github.com/lfnovo/esperanto/blob/main/LICENSE) file for details.


pkgId: 7dc6d728a1cb37aababb3120fdad5d8720ef7fbe4cb81112790b238fd7451076
name: python-esphome-dashboard-help
arch: noarch
version: 20241217.0
epoch: 0
release: 1
summary: Development documents and examples for esphome-dashboard
url: https://github.com/esphome/dashboard
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esphome-dashboard-20241217.0-1.src.rpm
location_href: Packages/python-esphome-dashboard-help-20241217.0-1.noarch.rpm
checksum_type: sha256
description:
  The ESPHome dashboard is a user facing dashboard embedded in ESPHome. It allows users to easily create and manage their configurations.

  This repository contains the JavaScript frontend and is embedded in ESPHome releases.



  Check out this repository, run `npm install` and then run

  ```
  npm run develop
  ```

  It will start the dev server and will automatically re-bundle updated JavaScript (except for the `static` folder).

  Then run ESPHome in dashboard dev mode by defining the relative path from the ESPHome repository to this dashboard repository as the environment variable `ESPHOME_DASHBOARD_DEV`.

  ```
  ESPHOME_DASHBOARD_DEV=../dashboard esphome dashboard ./
  ```


pkgId: f781b528c52f8b714640657d701c1ab557b8285df3e4151ffe0c74548b021a8e
name: python-esphome-help
arch: noarch
version: 2024.11.3
epoch: 0
release: 1
summary: Development documents and examples for esphome
url: https://pypi.org/project/esphome/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esphome-2024.11.3-1.src.rpm
location_href: Packages/python-esphome-help-2024.11.3-1.noarch.rpm
checksum_type: sha256
description:
  [![ESPHome Logo](https://esphome.io/_images/logo-text.png)](https://esphome.io/)

  **Documentation:** https://esphome.io/

  For issues, please go to [the issue tracker](https://github.com/esphome/issues/issues).

  For feature requests, please see [feature requests](https://github.com/esphome/feature-requests/issues).

  [![ESPHome - A project from the Open Home Foundation](https://www.openhomefoundation.org/badges/esphome.png)](https://www.openhomefoundation.org/)


pkgId: e8a63e9656758916052d86238ba95c0a928bb006ea71d356cc7674fabf6ff180
name: python-esplog-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for esplog
url: https://github.com/armanghobadi/esplog
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-esplog-1.0.0-1.src.rpm
location_href: Packages/python-esplog-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  `esplog` is a lightweight logging system designed for MicroPython environments. It allows you to log messages at different severity levels, output logs to both the console and a file, and supports log rotation based on file size. The system is flexible and can be configured to use color-coded logs for the console and store logs in either text or JSON format. It is optimized for use on embedded systems and microcontrollers where resources are limited.



  - **Multiple log levels**: Supports various log levels including DEBUG, INFO, WARNING, ERROR, CRITICAL, and TRACE.
  - **Color-coded console output**: Log messages in the console are color-coded for better visibility and differentiation based on severity.
  - **File logging**: Logs can be written to a file in either text or JSON format.
  - **Log rotation**: If the log file exceeds a certain size, it will be automatically rotated (older logs are renamed).
  - **Timestamping**: Each log entry includes a timestamp in the format `YYYY-MM-DD HH:MM:SS`.
  - **Flexible log level management**: You can set the minimum log level dynamically and filter out lower-level messages.
  - **Disable logging**: You can completely disable logging when necessary.

  To install **esplog**, you can use `upip`:

   for MicroPython, use the appropriate package manager like `upip` to install directly on your microcontroller.

  ```bash
  upip install esplog
  ```





  ```python
  from esplog.core import Logger


  logger = Logger(
      level="DEBUG",          # Set default log level to DEBUG
      log_to_console=True,    # Enable logging to console
      log_to_file=True,       # Enable logging to file
      file_name="app_log.txt", # Name of the log file
      max_file_size=1024,     # Maximum log file size in bytes before rotation
      use_colors=True,        # Use color coding in console logs
      log_format="text"       # Log format, can be "text" or "json"
  )


  logger.debug("This is a debug message.")
  logger.info("System initialized successfully.")
  logger.warning("Warning: High memory usage detected.")
  logger.error("Error: Disk space is running low.")
  logger.critical("Critical error: Immediate action required.")
  logger.trace("Trace message for detailed debugging.")


  logger.set_level("ERROR")
  logger.info("This message will not be logged.")
  logger.error("A critical error occurred.")


  logger.disable()
  logger.error("This message will not be logged.")
  ```





  - **level**: Set the default log level (one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`).
  - **log_to_console**: Boolean flag to log messages to the console.
  - **log_to_file**: Boolean flag to log messages to a file.
  - **file_name**: Name of the log file when logging to file.
  - **max_file_size**: Maximum file size in bytes before rotating the log file (0 means no rotation).
  - **use_colors**: Boolean flag to enable color-coded output in the console.
  - **log_format**: The format of the log file, either "text" or "json".



  The logger supports the following log levels:

  - **DEBUG**: Detailed debug messages.
  - **INFO**: General information messages.
  - **WARNING**: Warnings about potential issues.
  - **ERROR**: Errors that need attention.
  - **CRITICAL**: Critical errors requiring immediate action.
  - **TRACE**: Trace messages for detailed debugging (lowest level).



  - **set_level(level)**: Set the logging level to control the severity of messages logged.
  - **debug(message)**: Log a message at the `DEBUG` level.
  - **info(message)**: Log a message at the `INFO` level.
  - **warning(message)**: Log a message at the `WARNING` level.
  - **error(message)**: Log a message at the `ERROR` level.
  - **critical(message)**: Log a message at the `CRITICAL` level.
  - **trace(message)**: Log a message at the `TRACE` level.
  - **disable()**: Disable all logging (no messages will be logged).




  Each log entry consists of the following format:
  ```
  [YYYY-MM-DD HH:MM:SS][LEVEL] message
  ```

  Example:
  ```
  [2024-12-16 14:23:45][INFO] System initialized successfully.
  ```


  Each log entry is a JSON object with the following fields:
  ```json
  {
    "timestamp": "YYYY-MM-DD HH:MM:SS",
    "level": "LEVEL",
    "message": "message",
    "color": "color_code"  // Only included for console logs with colors enabled
  }
  ```

  Example:
  ```json
  {
    "timestamp": "2024-12-16 14:23:45",
    "level": "INFO",
    "message": "System initialized successfully.",
    "color": "\u001b[92m"
  }
  ```



  - **File Rotation**: When the log file exceeds the defined size (`max_file_size`), the file is rotated and renamed with a `.old` suffix.
  - **Compatibility**: This logger is designed for MicroPython environments and works on microcontrollers like ESP32, ESP8266, and other low-resource systems.
  - **Error Handling**: The logger gracefully handles errors when writing to files or rotating logs, ensuring that logging continues without disruption.



  esplog is licensed under the MIT License. See the LICENSE file for more details.


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





  Imaging data reduction for the European Spallation Source



  ```sh
  python -m pip install essimaging
  ```

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


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





  Common data reduction tools for the ESS facility



  ```sh
  python -m pip install essreduce
  ```

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


pkgId: 833c9b591a809dddc01330e207bb55fcb5829046013c2e4ecc7c848d3f660ef9
name: python-etacorpy-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for etacorpy
url: https://github.com/itaipelles/etacorpy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-etacorpy-0.1.2-1.src.rpm
location_href: Packages/python-etacorpy-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/etacorpy.svg)](https://pypi.org/project/etacorpy/)
  [![Docs](https://readthedocs.org/projects/etacorpy/badge/?version=latest)](https://etacorpy.readthedocs.io/en/latest/)
  [![Tests](https://github.com/itaipelles/etacorpy/actions/workflows/test.yml/badge.svg)](https://github.com/itaipelles/etacorpy/actions/workflows/test.yml)
  [![Changelog](https://img.shields.io/github/v/release/itaipelles/etacorpy?include_prereleases&label=changelog)](https://github.com/itaipelles/etacorpy/releases)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/itaipelles/etacorpy/blob/main/LICENSE)

  A Python package for calculating eta_n, the rank-transform area coverage coefficient of correlation. This is the official repository of the paper (link TBD):

  "A coefficient of correlation for continuous random variables based on area coverage"



  Install this library using `pip`:
  ```bash
  pip install etacorpy
  ```


  ```python
  import numpy as np
  from etacorpy import calc_eta_n
  x = np.random.rand(100)
  y = np.random.rand(100)
  print(f'x and y are independent, eta_n = {calc_eta_n(x,y)}')
  y = np.square(x)
  print(f'x and y are dependent, eta_n = {calc_eta_n(x,y)}')
  ```



  To contribute to this library, first checkout the code. Then create a new virtual environment:
  ```bash
  cd etacorpy
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  python -m pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```


pkgId: 7d4ca31cee515a90da8f9bf9d118a1b5f82360861036257ca377c4b8252df95a
name: python-etflow-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for etflow
url: https://pypi.org/project/etflow/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-etflow-0.1.2-1.src.rpm
location_href: Packages/python-etflow-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Implementation of [Equivariant Flow Matching for Molecule Conformer Generation](https://arxiv.org/abs/2410.22388) by M Hassan, N Shenoy, J Lee, H Stark, S Thaler and D Beaini.

  ET-Flow is a state-of-the-art generative model for generating small molecule conformations using equivariant transformers and flow matching.


  We are now available on PyPI. Easily install the package using the following command:
  ```bash
  pip install etflow
  ```



  We have a sample notebook ([generate_confs.ipynb](generate_confs.ipynb)) to generate conformations for custom smiles input. One needs to pass the config and corresponding checkpoint path in order as additional inputs.

  We have added support to load the model config and checkpoint with automatic download and caching. See ([tutorial.ipynb](tutorial.ipynb)) or use the following snippet to load the model and generate conformations for custom smiles input.

  ```python
  from etflow import BaseFlow
  model=BaseFlow.from_default(model="drugs-o3")
  model.predict(['CN1C=NC2=C1C(=O)N(C(=O)N2C)C'], num_samples=3, as_mol=True)
  ```

  We currently support the following configurations and checkpoint:
  - `drugs-o3`
  - `qm9-o3`
  - `drugs-so3`


  Run the following commands to setup the environment:
  ```bash
  conda env create -n etflow -f env.yml
  conda activate etflow

  python3 -m pip install -e .
  ```


  To pre-process the data, perform the following steps,
  1. Download the raw GEOM data and unzip the raw data using the following commands,

  ```bash
  wget https://dataverse.harvard.edu/api/access/datafile/4327252 -O <output_folder_path/rdkit_folder.tar>
  tar -zxvf <output_folder_path/rdkit_folder.tar>
  ```

  2. Process the data for `ET-Flow` training. First, set the `DATA_DIR` environment variable. All preprocessed data will be created inside this.

  ```bash
  export DATA_DIR=</path_to_data>
  python scripts/prepare_data.py -p /path/to/geom/rdkit-raw-folder
  ```

  3. Download the splits from the zenodo link (`https://zenodo.org/records/13870058`). Once these files are downloaded, extract the zip files to the respective folders inside `$DATA_DIR`,

  ```bash
  unzip QM9.zip -d $DATA_DIR
  unzip DRUGS.zip -d $DATA_DIR
  ```


  We provide our configs for training on the GEOM-DRUGS and the GEOM-QM9 datasets in various configurations. Run the following commands once datasets are preprocessed and the environment is set up:

  ```bash
  python etflow/train.py -c configs/drugs-base.yaml
  ```

  The following two configs from the `configs/` directory can be used for replicating paper results:
  - `drugs-base.yaml`: ET-Flow trained on GEOM-DRUGS dataset
  - `qm9-base.yaml`: ET-Flow trained on GEOM-QM9 dataset


  Before running eval with any checkpoint, create an evaluation csv (will be saved at `$DATA_DIR/processed/geom.csv`), using the following script,
  ```
  python scripts/prepare_eval_csv.py -p /path/to/geom/rdkit-raw-folder
  ```

  Evaluation happens in 2 steps as follows,

  1. Generating Conformations
  To run the evaluation on either GEOM or QM9 given a config and a checkpoint, run the following command,
  ```bash

  python etflow/eval.py --config=<config-path> --checkpoint=<checkpoint-path> --dataset_type=qm9 --nsteps=50
  ```

  To run the evaluation on GEOM-XL (a test-set containing much larger molecules), run the following command,
  ```bash
  python etflow/eval_xl.py --config=<config-path> --checkpoint=<checkpoint-path> --batch_size=16 --nsteps=50
  ```

  2. Evaluating Conformations with RMSD Metrics
  The above sample generation script should created a `generated_files.pkl` at the following path, `logs/samples/<config-path>/<data-time>/flow_nsteps_{value-passed-above}/generated_files.pkl`. With the given path, we can get the various RMSD metrics using,

  ```bash
  python etflow/eval_cov_mat.py --path=<path-to-generated-files.pkl> --num_workers=10
  ```


  Coming Soon!


  Our codebase is built using the following open-source contributions,
  - [torchmd-net](https://github.com/torchmd/torchmd-net)
  - [e3-diffusion-for-molecules](https://github.com/ehoogeboom/e3_diffusion_for_molecules)
  - [pytorch lightning](https://lightning.ai/pytorch-lightning)


  For further questions, feel free to raise an issue.


  ```
  @misc{hassan2024etflow,
        title={ET-Flow: Equivariant Flow-Matching for Molecular Conformer Generation},
        author={Majdi Hassan and Nikhil Shenoy and Jungyoon Lee and Hannes Stark and Stephan Thaler and Dominique Beaini},
        year={2024},
        eprint={2410.22388},
        archivePrefix={arXiv},
        primaryClass={q-bio.QM},
        url={https://arxiv.org/abs/2410.22388},
  }
  ```


pkgId: 3f6f004b5a4de2c5b59def16b66043fb53a7fb086eb36f8d13fcbbe47effaaaa
name: python-ethernity-cloud-sdk-py-help
arch: noarch
version: 0.2.11
epoch: 0
release: 1
summary: Development documents and examples for ethernity-cloud-sdk-py
url: https://github.com/ethernity-cloud/ethernity-cloud-sdk-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ethernity-cloud-sdk-py-0.2.11-1.src.rpm
location_href: Packages/python-ethernity-cloud-sdk-py-help-0.2.11-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://ethernity.cloud" title="Ethernity Cloud">
      <img src="https://ethernity.cloud/images/dark_gradient_logo.svg" alt="Ethernity Cloud logo" width="244" />
    </a>
  </p>

  <h3 align="center">The Python implementation of the Ethernity CLOUD SDK protocol</h3>



  This project provides a set of tools and scripts to work with the Ethernity Cloud SDK in a python environment.



  - [Pre-requisites](#pre-requisites)
  - [Installation](#installation)
  - [Usage](#usage)
    - [Scripts](#scripts)
  - [Project Structure](#project-structure)
  - [Contributing](#contributing)
  - [License](#license)


  Linux:
  - build-essentials
  - Python 3.10+
  - docker
  - docker-compose

  Windows:
  - Microsoft Visual Studio Community 2022+ (https://visualstudio.microsoft.com/)
    - MSVC++ 14.3+ build tools
    - C++ CMake tools for Windows
    - Windows SDK (for current running version)
    - Reboot required
  - Python 3.13
  - Docker Desktop



  To install the package and its dependencies, run:

  ```sh
  python -m venv venv

  source venv/bin/activate # for MacOS and Linux
  venv\Scripts\activate # for Windows

  pip install ethernity-cloud-sdk-py
  ```



  After installation, you can use the provided scripts to build, publish, and initialize your project.


  The sdk has been tested on the following operating systems:
  - Windows 10
  - linux (Ubuntu 20.04)


  - Bloxberg:
      - Testnet - tested and working
      - Mainnet - to be provided during the following updates
  - Polyhon:
      - Amoy Testnet - to be provided during the following updates
      - Mainnet - to be provided during the following updates



  - **Initialize**: To initialize the project, run:
    ```sh
    ecld-init
    ```
    at this step, all the initial configurations will be set up and the project will be ready to be built, published and run.

  - **Build**: To build the project, run:
    ```sh
    ecld-build
    ```
      the project will be built and the docker repository output will be stored in the `registry/` directory. This is the stage where the backend functions are added to the secure images.

  - **Publish**: To publish the project, run:
    ```sh
    ecld-publish
    ```
    Required after build, to build and integrate the secure certificates that will be used during executions and to register the project to the Ethernity Cloud Image Register.

  - **Run**: To run the project, run:
    ```sh
    python src/ethernity_task.py
    ```
    command to start the demo application and test the integration.



  To use the SDK:
  - after installation, run `ecld-init` to initialize the project
  - in you workspace, you will find the `scr/serverless` directory, this contains a `backend.py` file. This file will be imported in the dApp images to provide the backend functions for calling from the frontend of your application, eg.:
  ```py
  def hello(msg='World'):
      return "Hello "+msg
  ```
  From your py application, using the ethernity cloud runner library, you will be calling the function as seen in the below example, where we pass `hello("World")` to be executed on the backend which will run in the Blockchain:
  ```py
  import os
  import sys
  from dotenv import load_dotenv

  load_dotenv()

  from ethernity_cloud_runner_py.runner import EthernityCloudRunner  # type: ignore


  def execute_task() -> None:
      ipfs_address = "https://ipfs.ethernity.cloud/api/v0"

      code = 'hello("Hello, Python World!")'

      runner = EthernityCloudRunner()
      runner.initialize_storage(ipfs_address)

      resources = {
          "taskPrice": 8,
          "cpu": 1,
          "memory": 1,
          "storage": 1,
          "bandwidth": 1,
          "duration": 1,
          "validators": 1,
      }
      
      
      runner.run(
          os.getenv("PROJECT_NAME"),
          code,
          "0xd58f5C1834279ABD601df85b3E4b2323aDD4E75e",
          resources,
          os.getenv("TRUSTED_ZONE_IMAGE", ""),
      )


  if __name__ == "__main__":
      execute_task()

  ```
  - you are able to define the functions needed to be used in the backend, while making sure that the function that is script is compilable and that it exports the function that will be called from the frontend, in the above example, the `hello` function.



  Contributions are welcome! Please open an issue or submit a pull request.



  This project is licensed under the AGPL-3.0 License. See the LICENSE file for details.


pkgId: 249300013d4223a6861ea631e84c17669b1a5ac21062c033be9e33780bf20d5e
name: python-ethyca-fides-help
arch: noarch
version: 2.51.1
epoch: 0
release: 1
summary: Development documents and examples for ethyca-fides
url: https://github.com/ethyca/fides
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ethyca-fides-2.51.1-1.src.rpm
location_href: Packages/python-ethyca-fides-help-2.51.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Latest Release Version][release-image]][release-url]
  [![Docker][docker-workflow-image]][docker-actions-url]
  [![Docs][docs-workflow-image]][docs-actions-url]
  [![Package][release-workflow-image]][publish-actions-url]
  [![License][license-image]][license-url]
  [![Code style: black][black-image]][black-url]
  [![Checked with mypy][mypy-image]][mypy-url]
  [![Twitter][twitter-image]][twitter-url]
  [![Coverage](https://codecov.io/github/ethyca/fides/coverage.svg?branch=main)](https://codecov.io/gh/ethyca/fides)

  ![Fides banner](docs/fides/docs/img/fides-banner.png "Fides banner")



  Fides (pronounced */fee-dhez/*, from Latin: Fidēs) is an open-source privacy engineering platform for managing the fulfillment of data privacy requests in your runtime environment, and the enforcement of privacy regulations in your code.





  In order to get started quickly with Fides, a sample project is bundled within the Fides CLI that will set up a server, privacy center, and a sample application for you to experiment with.



  * [Docker](https://www.docker.com/products/docker-desktop) (version 20.10.11 or later)
  * [Python](https://www.python.org/downloads/) (version 3.9 through 3.10)



  > [!TIP]
  > We highly recommend setting up a Python virtual environment such as `venv` to install Fides into. For example:
  >
  > ```sh
  > mkdir ~/fides
  > cd ~/fides
  > python3 -m venv venv
  > source venv/bin/activate
  > ```

  Once your virtual environment is ready, you can easily download and install Fides using `pip`. Run the following command to get started:

  ```
  pip install ethyca-fides
  ```



  By default, Fides ships with a small project belonging to a fictional e-commerce store. Running the `fides deploy up` command builds a Fides project with all you need to run your first Data Subject Request against real databases.

  ```sh
  fides deploy up
  ```



  When your deployment finishes, a welcome screen will explain the key components of Fides and the sample "Cookie House" project.

  If your browser does not open automatically, you should navigate to <http://localhost:3000/landing>.

  The project contains:

  * The Fides Admin UI for managing privacy requests
  * The Fides [Privacy Center](https://ethyca.com/docs/dev-docs/privacy-requests/privacy-center) for submitting requests
  * The sample "Cookie House" eCommerce site for testing
  * A DSR Directory on your computer to view results (`./fides_uploads`)



  Navigate to the Fides Privacy Center (<http://localhost:3001>), submit a "Download your data" request, provide the email address for the sample user (`jane@example.com`), and submit the request.

  Then, navigate to the Fides Admin UI (<http://localhost:8080>) to review the pending privacy request.

  Use username `root_user` and password `Testpassword1!` to login, approve the request, and review the resulting package in your `./fides_uploads` folder!



  Congratulations! You've just run an entire privacy request in under 5 minutes! Fides offers many more tools to help take control of your data privacy. To find out more, you can run a privacy request on [your own infrastructure](https://ethyca.com/docs/tutorials/privacy-requests), discover [data mapping](https://ethyca.com/docs/tutorials/data-mapping), or learn about the [Fides Taxonomy](https://ethyca.github.io/fideslang/).



  The Fides core team is committed to providing a variety of documentation to help get you started using Fides.  As such, all interactions are governed by the [Fides Code of Conduct](https://ethyca.com/docs/community/code_of_conduct).



  For more information on getting started with Fides, how to configure and set up Fides, and more about the Fides ecosystem of open source projects:

  * Documentation: <https://ethyca.com/docs>
  * Website: www.ethyca.com/fides



  Join the conversation on:

  * [Slack](https://fid.es/join-slack)
  * [Twitter](https://twitter.com/ethyca)
  * [Discussions](https://github.com/ethyca/fides/discussions)



  We welcome and encourage all types of contributions and improvements!  Please see our [contribution guide](https://ethyca.com/docs/community) to opening issues for bugs, new features, and security or experience enhancements.

  Read about the [Fides community](https://ethyca.com/docs/community/hints_tips) or dive into the [contributor guides](https://ethyca.com/docs/community/development/overview) for information about contributions, documentation, code style, testing and more. Ethyca is committed to fostering a safe and collaborative environment, such that all interactions are governed by the [Fides Code of Conduct](https://ethyca.com/docs/community/code_of_conduct).



  The [Fides](https://github.com/ethyca/fides) ecosystem of tools are licensed under the [Apache Software License Version 2.0](https://www.apache.org/licenses/LICENSE-2.0).
  Fides tools are built on [fideslang](https://github.com/ethyca/privacy-taxonomy), the Fides language specification, which is licensed under [CC by 4](https://github.com/ethyca/privacy-taxonomy/blob/main/LICENSE).

  Fides is created and sponsored by Ethyca: a developer tools company building the trust infrastructure of the internet. If you have questions or need assistance getting started, let us know at fides@ethyca.com!

  [release-image]: https://img.shields.io/github/release/ethyca/fides.svg
  [release-url]: https://github.com/ethyca/fides/releases
  [docker-workflow-image]: https://github.com/ethyca/fides/workflows/Docker%20Build%20&%20Push/badge.svg
  [docs-workflow-image]: https://github.com/ethyca/fides/workflows/Publish%20Docs/badge.svg
  [release-workflow-image]: https://github.com/ethyca/fides/actions/workflows/publish_package.yaml/badge.svg
  [docker-actions-url]: https://github.com/ethyca/fides/actions/workflows/publish_docker.yaml
  [docs-actions-url]: https://github.com/ethyca/fides/actions/workflows/publish_docs.yaml
  [publish-actions-url]: https://github.com/ethyca/fides/actions/workflows/publish_package.yaml
  [license-image]: https://img.shields.io/:license-Apache%202-blue.svg
  [license-url]: https://www.apache.org/licenses/LICENSE-2.0.txt
  [black-image]: https://img.shields.io/badge/code%20style-black-000000.svg
  [black-url]: https://github.com/psf/black/
  [mypy-image]: http://www.mypy-lang.org/static/mypy_badge.svg
  [mypy-url]: http://mypy-lang.org/
  [twitter-image]: https://img.shields.io/twitter/follow/ethyca?style=social
  [twitter-url]: https://twitter.com/ethyca



  By default, running `pip install ethyca-fides` locally will not install the optional Python libraries needed for Microsoft SQL Server, since these rely on additional system dependencies (`freetds`)! However, if you *do* want to connect to MSSQL, you have two options:
  1. Use our pre-built Docker images which install these optional dependencies automatically: [`ethyca/fides`](https://hub.docker.com/r/ethyca/fides). See our [Deployment Guide](https://ethyca.com/docs/dev-docs/configuration/deployment) for more!
  2. Install the required dependencies on your local development machine and run `pip install "ethyca-fides[all]"` to include "all" the optional libraries. Keep reading to learn more about this!

  For local development setup on macOS, follow these steps:
  1. Install the required development libraries from Homebrew:
  ```bash
  brew install freetds openssl
  ```
  2. Add the following to your shell (i.e. `.zshrc`) to ensure your compiler can access the `freetds` and `openssl` libraries, updating the paths & versions to match your local install:
  ```bash
  export LDFLAGS="-L/opt/homebrew/Cellar/freetds/1.3.18/lib -L/opt/homebrew/Cellar/openssl@1.1/1.1.1u/lib"
  export CFLAGS="-I/opt/homebrew/Cellar/freetds/1.3.18/include"
  ```
  3. Reinstall Fides with MSSQL support by including the `all` extra requirement:
  ```bash
  pip install ethyca-fides[all]
  ```


pkgId: f3d2912922e6b9476fee3ec20886946886b6ccc7bc95a2e0a7cfafdb6efb25d1
name: python-etiopique-lorem-texts-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for etiopique-lorem-texts
url: https://github.com/mitegab/etiopique_lorem_texts.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-etiopique-lorem-texts-0.1.0-1.src.rpm
location_href: Packages/python-etiopique-lorem-texts-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A simple Python package to generate Lorem Ipsum text in both English and Amharic languages.



  ```bash
  pip install etiopique-lorem-texts


pkgId: ceeefd893576a150c3dc5aff74a5ab2494b030084d67e43c747e0f6f450ce369
name: python-etool-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for etool
url: https://github.com/jiangyangcreate/etool
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-etool-0.0.2-1.src.rpm
location_href: Packages/python-etool-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  使用 pip 安装 etool:

  ```bash
  pip install etool
  ```




  Speed 是一个测试网络、磁盘、内存、GPU性能的工具，可以测试网络速度、磁盘速度、内存速度、GPU性能。



  ```python
  from etool import Speed

  Speed.test_network_speed()
  Speed.test_disk_speed()
  Speed.test_memory_speed()
  Speed.test_gpu_performance()
  Speed.run_all_tests()
  ```



  file_ud 是一个文件上传下载工具，可以上传下载文件。



  ```python
  from etool import file_ud

  file_ud(port=8900)
  ```



  ScreenShare 是一个屏幕共享工具，可以共享屏幕。



  ```python
  from etool import screen_share

  screen_share(port=8900)
  ```




  pocwatch 是一个跨平台的 Python 任务调度器，支持丰富的定时执行任务，甚至是嵌套，并通过邮件发送通知：包括代码的报错信息、文件、截图。




  - 简单易用
  - 跨平台支持 (Windows, Linux, macOS)
  - 灵活的任务调度
  - 可配置的邮件通知 (成功和失败)
  - 自动 SMTP 服务器选择
  - 详细的错误报告




  1. 导入 etool 模块:

  ```python
  from etool import pocwatch
  ```

  2. 定义您的任务:

  ```python
  def your_task():
      print("任务执行中...")
  ```

  3. 运行任务调度器:

  ```python:path/to/main.py
  pocwatch(
      job=your_task,
      schedule_time="08:00",
      sender=None,  # 缺省则不发送
      password=None,  # 缺省则不发送
      recipients=[],  # 缺省则不发送
      smtp_server='smtp.exmail.qq.com',  # 缺省值则自动选择
      smtp_port=465,  # 缺省值则自动选择
      smtp_ssl=True,  # 缺省值则自动选择

      success_subject="success",  # 缺省默认值 subject和body只填一个则会subject和body相同
      success_body="success",  # 缺省默认值

      failure_subject="failure",  # 缺省默认值 subject和body只填一个则会subject和body相同
      failure_body="task failure: error_message",  # 缺省默认值
  )
  ```

  - `schedule_time`: 执行时间

  如果是数字则默认单位是秒，每间隔`schedule_time`秒执行一次，例如`120`，则每2分钟执行一次。

  如果是字符串则默认是时间点，请遵从`HH:MM`的格式，例如`08:00`，每天在这个时间点执行一次。

  如果是列表，则默认是多个时间点，例如`["08:00", "12:00", "16:00"]`，每天在这些时间点执行一次。

  如果传入的是字典，则解析字典的键：

  如果字典的键为数字，则默认是日期，对应字典的值遵从上方数字、字符串、列表的判断。

  如果字典的键为字符串，则默认是星期几（以周一为例，支持的写法包括：`1`、`monday`、`Monday`、`MONDAY`、`mon`、`mon.`、`m`，以此类推），对应字典的值遵从上方数字、字符串、列表的判断。

  例如下面是1号的8点、2号的8点、12点、16点、3号每隔一个小时执行一次、每周一的8点执行一次。

  ```python:path/to/main.py
  schedule_time = {
      1: "08:00",
      2: ["08:00", "12:00", "16:00"],
      3: 216000,
      "1": "08:00",
  }
  ```

  - `sender`: 发件人邮箱，如果不想发送邮件，则可以不配置。
  - `password`: 发件人邮箱密码，如果不想发送邮件，则可以不配置。
  - `recipients`: 收件人邮箱列表，如果不想发送邮件，则可以不配置。
  - `smtp_server`: SMTP服务器地址，缺省值则自动选择。
  - `smtp_port`: SMTP服务器端口，缺省值则自动选择。
  - `smtp_ssl`: 是否使用SSL，缺省值则自动选择。
  - `success_subject`: 任务成功时的邮件主题，subject和body只填一个则会subject和body相同
  - `success_body`: 任务成功时的邮件内容，subject和body只填一个则会subject和body相同
  - `failure_subject`: 任务失败时的邮件主题，subject和body只填一个则会subject和body相同
  - `failure_body`: 任务失败时的邮件内容，subject和body只填一个则会subject和body相同

  ```python:path/to/main.py
  from etool import pocwatch

  def your_task():
      print("任务执行中...")

  pocwatch(
      job=your_task,
      schedule_time="08:00",
      sender='your_email@example.com',
      password='your_password',
      recipients=['recipient1@example.com', 'recipient2@example.com'],
      smtp_server='smtp.exmail.qq.com',
      smtp_port=465,
      smtp_ssl=True,
      success_subject="任务成功",
      success_body="任务已成功执行。",
      failure_subject="任务失败",
      failure_body="任务执行失败，错误信息：error_message",
  )
  ```


pkgId: c4bce23fb60cbf6276db44a9b5cbba075cca308adadb8389ec596a30f2cbfa8c
name: python-etplib-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for etplib
url: https://www.embeddedtester.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-etplib-0.2.1-1.src.rpm
location_href: Packages/python-etplib-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  `etplib` allows access to microcontroller peripherals from a host computer. Microcontroller should be running the ETP firmware.


  - Install `etplib` using pip
    ```terminal
    pip install etplib
    ```



  - Download [ETP firmware for Arduino Uno](https://github.com/jabezwinston/etplib/releases/download/v0.2.0/etp_fw_arduino_uno_v0.2.0.hex)
  - Flash ETP firmware to the Arduino Uno using `avrdude` (Get avrdude [here](https://github.com/avrdudes/avrdude/releases/))

    ```terminal
     avrdude -v -p atmega328p -c arduino -P COM4 -b 115200 -D -U flash:w:etp_fw_arduino_uno_v0.1.0.hex:i
    ```
  > NOTE : Replace `COM4` with the port where the Arduino Uno is connected


  - Download [ETP firmware package for ESP32](https://github.com/jabezwinston/etplib/releases/download/v0.2.0/etp_fw_esp32_v0.2.0.zip)
  - Install `esptool` using pip
    ```terminal
    pip install esptool
    ```
  - Run `flash.bat` (Windows) or `flash.sh` (Linux) to flash the ETP firmware to the ESP32
  > NOTE : ETP firmware for ESP32 is experimental !





  ```python
  import etplib
  import time

  etp = etplib.ETP(transport='serial', port='COM4', baudrate=115200)
  etp.open()
  etp.reset()

  etp.gpio.init({"_13": "output"})


  while True:
      etp.gpio_write({"_13": 1})
      time.sleep(1)
      etp.gpio_write({"_13": 0})
      time.sleep(1)

  etp.close()
  ```


pkgId: 56c7090930a5929920b5762eb0c44f59630f4574719785ad8bc0426d5af93623
name: python-eunomia-ai-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for eunomia-ai
url: https://pypi.org/project/eunomia-ai/
rpm_license: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eunomia-ai-0.1.0-1.src.rpm
location_href: Packages/python-eunomia-ai-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  For installation:
  - `poetry install`

  For development:
  - `poetry run black .`
  - `poetry run isort . --profile black`
  - `poetry run pytest`

  For docs:
  - `mkdocs serve`


pkgId: 049cb32ea07089cf0925c4700b59078829fe4cade16d36cbcdcf63c22c9b8bfd
name: python-eval-python-2-mdhcquete-v2-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for eval-python-2-mdhcquete-v2
url: https://github.com/mrcsd-hrrr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eval-python-2-mdhcquete-v2-1.0-1.src.rpm
location_href: Packages/python-eval-python-2-mdhcquete-v2-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  Proyecto - Evaluación. Valor total 100 pts 30%.
  Nota: enviar en una carpeta comprimida con nombre y apellido, los códigos fuentes que se
  solicitan a con�nuación:
  Obje�vo: Evaluar los conocimientos adquiridos en el curso en la realizar de los siguientes códigos:
  1. Realizar un programa que cree un directorio con el nombre Examen + Nombre Estudiante, el cual se debe de crear en la unidad C, es decir, en la raíz. A su vez el programa al crear el directorio debe de desplegar el mensaje “Directorio + nombre directorio creado exitosamente y en caso de error o que no se pudo crear desplegará el mensaje “Directorio + nombre estudiante no se pudo crear”. Valor 5 pts.
  2. Obtener la úl�ma hora del acceso a la ruta de la Carpeta creada en el punto anterior. Valor 5 pts.
  3. Un programa que mediante el uso del subprocess permita mediante la opción de un menú abrir: el Notepad, la calculadora, Word, Excel y Paint. Valor 15 pts.
  4. Un programa que valide el ingreso de un nombre y apellido, número telefónico y de correo, si todos están correctos crear un archivo con el nombre “Datos Persona.txt”, este archivo se guardará en la carpeta creada en el punto número uno. Valor 15 pts.
  5. En la carpeta creada en el punto uno, crear otra carpeta con el nombre Entorno y dentro de esta realizar un entorno virtual que efectué una pe�ción GET a la url = htps://es.wikipedia.org/w/api.php?ac�on=opensearch&search=Python&limit=5&namespace= 0&format=json Valor 15 pts.
  6. Crear una carpeta con el nombre “asset” dentro de la carpeta creada en el punto uno, dentro de la carpeta guardar una imagen con el formato jpg. Luego crear un programa que en la imagen escriba o dibuje su nombre completo con la fecha de creación y luego que lo muestre. El �po de fuente y tamaño de la letra la que guste. Valor 15 pts.
  7. Realizar un scrapy de la �enda Universal del apartado “juegos de mesas” Valor 10 pts.
  8. De los programas creados anteriormente escoger uno y aplicar el “Docstring” y posterior crear
  un paquete instalable y portable. Valor 10 pts.
  9. Graficar los datos de la tasa de mortalidad infan�l, publicada en la página oficial del INEC, cuya información la puede obtener del siguiente link: htps://inec.cr/indicadores/tasa-mortalidad- infan�l Valor 10 pts.


pkgId: ca64e3d8454777118ec53753458ede57b49b495da7c8ae8849c14701d8294711
name: python-eval-python-2-mdhcquete-v4-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for eval-python-2-mdhcquete-v4
url: https://github.com/mrcsd-hrrr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eval-python-2-mdhcquete-v4-1.0-1.src.rpm
location_href: Packages/python-eval-python-2-mdhcquete-v4-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  Academia de Tecnología – Universidad de Costa Rica
  Programación con Python Nivel 2 Inst. Larry Mayorga (XII-2024)

  Proyecto - Evaluación. Valor total 100 pts 30%.
  Nota: enviar en una carpeta comprimida con nombre y apellido, los códigos fuentes que se
  solicitan a continuación:

  Objetvo: Evaluar los conocimientos adquiridos en el curso en la realizar de los siguientes códigos:

  1. Realizar un programa que cree un directorio con el nombre Examen + Nombre Estudiante, el cual se debe de crear en la unidad C, es decir, en la raíz. A su vez el programa al crear el directorio debe de desplegar el mensaje “Directorio + nombre directorio creado exitosamente y en caso de error o que no se pudo crear desplegará el mensaje “Directorio + nombre estudiante no se pudo crear”. Valor 5 pts.

  2. Obtener la última hora del acceso a la ruta de la Carpeta creada en el punto anterior. Valor 5 pts.

  3. Un programa que mediante el uso del subprocess permita mediante la opción de un menú abrir: el Notepad, la calculadora, Word, Excel y Paint. Valor 15 pts.

  4. Un programa que valide el ingreso de un nombre y apellido, número telefónico y de correo, si todos están correctos crear un archivo con el nombre “Datos Persona.txt”, este archivo se guardará en la carpeta creada en el punto número uno. Valor 15 pts.

  5. En la carpeta creada en el punto uno, crear otra carpeta con el nombre Entorno y dentro de esta realizar un entorno virtual que efectué una petición GET a la url = htps://es.wikipedia.org/w/api.php?ac�on=opensearch&search=Python&limit=5&namespace= 0&format=json. Valor 15 pts.

  6. Crear una carpeta con el nombre “asset” dentro de la carpeta creada en el punto uno, dentro de la carpeta guardar una imagen con el formato jpg. Luego crear un programa que en la imagen escriba o dibuje su nombre completo con la fecha de creación y luego que lo muestre. El �po de fuente y tamaño de la letra la que guste. Valor 15 pts.

  7. Realizar un scrapy de la Tenda Universal del apartado “juegos de mesas.” Valor 10 pts.

  8. De los programas creados anteriormente escoger uno y aplicar el “Docstring” y posterior crear
  un paquete instalable y portable. Valor 10 pts.

  9. Graficar los datos de la tasa de mortalidad infan�l, publicada en la página oficial del INEC, cuya información la puede obtener del siguiente link: htps://inec.cr/indicadores/tasa-mortalidad- infantil. Valor 10 pts.


pkgId: ceddfc42bdbbeb6dfc85fe00dae60e8aa63ba0ef18492f9f5b436e6d90db809a
name: python-evalops-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for evalops
url: https://github.com/The-Swarm-Corporation/StatisticalModelEvaluator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-evalops-0.0.3-1.src.rpm
location_href: Packages/python-evalops-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)


  [![Join our Discord](https://img.shields.io/badge/Discord-Join%20our%20server-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/agora-999382051935506503) [![Subscribe on YouTube](https://img.shields.io/badge/YouTube-Subscribe-red?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/@kyegomez3242) [![Connect on LinkedIn](https://img.shields.io/badge/LinkedIn-Connect-blue?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/in/kye-g-38759a207/) [![Follow on X.com](https://img.shields.io/badge/X.com-Follow-1DA1F2?style=for-the-badge&logo=x&logoColor=white)](https://x.com/kyegomezb)

  A robust, production-ready framework for statistically rigorous evaluation of language models, implementing the methodology described in ["A Statistical Approach to Model Evaluations"](https://www.anthropic.com/research/statistical-approach-to-model-evals) (2024).





  - **Statistical Robustness**: Leverages Central Limit Theorem for reliable metrics
  - **Clustered Standard Errors**: Handles non-independent question groups
  - **Variance Reduction**: Multiple sampling strategies and parallel processing
  - **Paired Difference Analysis**: Sophisticated model comparison tools
  - **Power Analysis**: Sample size determination for meaningful comparisons
  - **Production Ready**:
    - Comprehensive logging
    - Type hints throughout
    - Error handling
    - Result caching
    - Parallel processing
    - Modular design




  ```bash
  pip3 install -U evalops
  ```



  ```python
  import os

  from dotenv import load_dotenv
  from swarm_models import OpenAIChat
  from swarms import Agent

  from evalops import StatisticalModelEvaluator

  load_dotenv()


  api_key = os.getenv("OPENAI_API_KEY")
  if not api_key:
      raise ValueError("OPENAI_API_KEY environment variable not set")


  model_gpt4 = OpenAIChat(
      openai_api_key=api_key, model_name="gpt-4o", temperature=0.1
  )

  model_gpt35 = OpenAIChat(
      openai_api_key=api_key, model_name="gpt-4o-mini", temperature=0.1
  )


  agent = Agent(
      agent_name="General-Knowledge-Agent",
      system_prompt="You are a helpful assistant that answers general knowledge questions accurately and concisely.",
      llm=model_gpt4,
      max_loops=1,
      dynamic_temperature_enabled=True,
      saved_state_path="general_agent.json",
      user_name="swarms_corp",
      context_length=200000,
      return_step_meta=False,
      output_type="string",
  )

  evaluator = StatisticalModelEvaluator(cache_dir="./eval_cache")


  general_questions = [
      "What is the capital of France?",
      "Who wrote Romeo and Juliet?",
      "What is the largest planet in our solar system?",
      "What is the chemical symbol for gold?",
      "Who painted the Mona Lisa?",
  ]

  general_answers = [
      "Paris",
      "William Shakespeare",
      "Jupiter",
      "Au",
      "Leonardo da Vinci",
  ]


  result_gpt4 = evaluator.evaluate_model(
      model=agent,
      questions=general_questions,
      correct_answers=general_answers,
      num_samples=5,
  )

  result_gpt35 = evaluator.evaluate_model(
      model=agent,
      questions=general_questions,
      correct_answers=general_answers,
      num_samples=5,
  )


  comparison = evaluator.compare_models(result_gpt4, result_gpt35)


  print(f"GPT-4 Mean Score: {result_gpt4.mean_score:.3f}")
  print(f"GPT-3.5 Mean Score: {result_gpt35.mean_score:.3f}")
  print(
      f"Significant Difference: {comparison['significant_difference']}"
  )
  print(f"P-value: {comparison['p_value']:.3f}")

  ```






  ```python
  class MyLanguageModel:
      def run(self, task: str) -> str:
          
          return "model response"

  evaluator = StatisticalModelEvaluator(
      cache_dir="./eval_cache",
      log_level="INFO",
      random_seed=42
  )


  questions = ["Question 1", "Question 2", ...]
  answers = ["Answer 1", "Answer 2", ...]


  result = evaluator.evaluate_model(
      model=MyLanguageModel(),
      questions=questions,
      correct_answers=answers,
      num_samples=3,  # Number of times to sample each question
      batch_size=32,  # Batch size for parallel processing
      cache_key="model_v1"  # Optional caching key
  )


  print(f"Mean Score: {result.mean_score:.3f}")
  print(f"95% CI: [{result.ci_lower:.3f}, {result.ci_upper:.3f}]")
  ```



  ```python

  cluster_ids = ["passage1", "passage1", "passage2", "passage2", ...]

  result = evaluator.evaluate_model(
      model=MyLanguageModel(),
      questions=questions,
      correct_answers=answers,
      cluster_ids=cluster_ids
  )
  ```



  ```python

  result_a = evaluator.evaluate_model(model=ModelA(), ...)
  result_b = evaluator.evaluate_model(model=ModelB(), ...)


  comparison = evaluator.compare_models(result_a, result_b)

  print(f"Mean Difference: {comparison['mean_difference']:.3f}")
  print(f"P-value: {comparison['p_value']:.4f}")
  print(f"Significant Difference: {comparison['significant_difference']}")
  ```



  ```python
  required_samples = evaluator.calculate_required_samples(
      effect_size=0.05,  # Minimum difference to detect
      baseline_variance=0.1,  # Estimated variance in scores
      power=0.8,  # Desired statistical power
      alpha=0.05  # Significance level
  )

  print(f"Required number of samples: {required_samples}")
  ```




  ```python
  import os

  from dotenv import load_dotenv
  from swarm_models import OpenAIChat
  from swarms import Agent

  from evalops import StatisticalModelEvaluator
  from evalops.huggingface_loader import EvalDatasetLoader

  load_dotenv()


  api_key = os.getenv("OPENAI_API_KEY")
  if not api_key:
      raise ValueError("OPENAI_API_KEY environment variable not set")


  model_gpt4 = OpenAIChat(
      openai_api_key=api_key, model_name="gpt-4o", temperature=0.1
  )


  agent = Agent(
      agent_name="General-Knowledge-Agent",
      system_prompt="You are a helpful assistant that answers general knowledge questions accurately and concisely.",
      llm=model_gpt4,
      max_loops=1,
      dynamic_temperature_enabled=True,
      saved_state_path="general_agent.json",
      user_name="swarms_corp",
      context_length=200000,
      return_step_meta=False,
      output_type="string",
  )

  evaluator = StatisticalModelEvaluator(cache_dir="./eval_cache")


  eval_loader = EvalDatasetLoader(cache_dir="./eval_cache")


  questions, answers = eval_loader.load_dataset(
      dataset_name="truthful_qa",
      subset="multiple_choice",
      split="validation",
      answer_key="best_question",
  )


  result_gpt4 = evaluator.evaluate_model(
      model=agent,
      questions=questions,
      correct_answers=answers,
      num_samples=5,
  )



  print(result_gpt4)


  ```



  `eval` is a simple function that wraps the evaluator class and makes it easy to use.

  ```python
  import os

  from dotenv import load_dotenv
  from swarm_models import OpenAIChat
  from swarms import Agent

  from evalops.wrapper import eval

  load_dotenv()


  api_key = os.getenv("OPENAI_API_KEY")
  if not api_key:
      raise ValueError("OPENAI_API_KEY environment variable not set")


  model_gpt4 = OpenAIChat(
      openai_api_key=api_key, model_name="gpt-4o", temperature=0.1
  )


  agent = Agent(
      agent_name="General-Knowledge-Agent",
      system_prompt="You are a helpful assistant that answers general knowledge questions accurately and concisely.",
      llm=model_gpt4,
      max_loops=1,
      dynamic_temperature_enabled=True,
      saved_state_path="general_agent.json",
      user_name="swarms_corp",
      context_length=200000,
      return_step_meta=False,
      output_type="string",
  )



  general_questions = [
      "What is the capital of France?",
      "Who wrote Romeo and Juliet?",
      "What is the largest planet in our solar system?",
      "What is the chemical symbol for gold?",
      "Who painted the Mona Lisa?",
  ]


  general_answers = [
      "Paris",
      "William Shakespeare",
      "Jupiter",
      "Au",
      "Leonardo da Vinci",
  ]


  print(eval(
      questions = general_questions,
      answers=general_answers,
      agent=agent,
      samples=2,
  ))

  ```



  | Parameter | Description | Default |
  |-----------|-------------|---------|
  | `cache_dir` | Directory for caching results | `None` |
  | `log_level` | Logging verbosity ("DEBUG", "INFO", etc.) | `"INFO"` |
  | `random_seed` | Seed for reproducibility | `None` |
  | `batch_size` | Batch size for parallel processing | `32` |
  | `num_samples` | Samples per question | `1` |





  ```python
  @dataclass
  class EvalResult:
      mean_score: float      # Average score across questions
      sem: float            # Standard error of the mean
      ci_lower: float       # Lower bound of 95% CI
      ci_upper: float       # Upper bound of 95% CI
      raw_scores: List[float]  # Individual question scores
      metadata: Dict        # Additional evaluation metadata
  ```



  ```python
  {
      "mean_difference": float,    # Difference between means
      "correlation": float,        # Score correlation
      "t_statistic": float,       # T-test statistic
      "p_value": float,           # Statistical significance
      "significant_difference": bool  # True if p < 0.05
  }
  ```



  1. **Sample Size**: Use power analysis to determine appropriate sample sizes
  2. **Clustering**: Always specify cluster IDs when questions are grouped
  3. **Caching**: Enable caching for expensive evaluations
  4. **Error Handling**: Monitor logs for evaluation failures
  5. **Reproducibility**: Set random seed for consistent results



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

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



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



  - 📫 Email: kye@swarms.world
  - 💬 Issues: [GitHub Issues](https://github.com/The-Swarm-Corporation/StatisticalModelEvaluator/issues)
  - 📖 Documentation: [Full Documentation](https://docs.swarms.world)



  - Thanks to all contributors
  - Inspired by the paper "A Statistical Approach to Model Evaluations" (2024)


pkgId: 9858e83a9c64aa75f18fb700d067d92484e87a90f59fbf775ab0a8e4e30b1039
name: python-evalscope-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for evalscope
url: https://github.com/modelscope/evalscope
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-evalscope-0.8.0-1.src.rpm
location_href: Packages/python-evalscope-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <br>
      <img src="docs/en/_static/images/evalscope_logo.png"/>
      <br>
  <p>


  <p align="center">
    <a href="README_zh.md">中文</a> &nbsp ｜ &nbsp English &nbsp
  </p>

  <p align="center">
  <img src="https://img.shields.io/badge/python-%E2%89%A53.8-5be.svg">
  <a href="https://badge.fury.io/py/evalscope"><img src="https://badge.fury.io/py/evalscope.svg" alt="PyPI version" height="18"></a>
  <a href="https://pypi.org/project/evalscope"><img alt="PyPI - Downloads" src="https://static.pepy.tech/badge/evalscope"></a>
  <a href="https://github.com/modelscope/evalscope/pulls"><img src="https://img.shields.io/badge/PR-welcome-55EB99.svg"></a>
  <a href='https://evalscope.readthedocs.io/en/latest/?badge=latest'><img src='https://readthedocs.org/projects/evalscope/badge/?version=latest' alt='Documentation Status' /></a>
  <p>

  <p align="center">
  <a href="https://evalscope.readthedocs.io/zh-cn/latest/"> 📖  中文文档</a> &nbsp ｜ &nbsp <a href="https://evalscope.readthedocs.io/en/latest/"> 📖  English Documents</a>
  <p>

  > ⭐ If you like this project, please click the "Star" button at the top right to support us. Your support is our motivation to keep going!


  - [Introduction](#introduction)
  - [News](#News)
  - [Installation](#installation)
  - [Quick Start](#quick-start)
  - [Evaluation Backend](#evaluation-backend)
  - [Custom Dataset Evaluation](#custom-dataset-evaluation)
  - [Model Serving Performance Evaluation](#Model-Serving-Performance-Evaluation)
  - [Arena Mode](#arena-mode)




  EvalScope is [ModelScope](https://modelscope.cn/)'s official framework for model evaluation and benchmarking, designed for diverse assessment needs. It supports various model types including large language models, multimodal, embedding, reranker, and CLIP models.

  The framework accommodates multiple evaluation scenarios such as end-to-end RAG evaluation, arena mode, and inference performance testing. It features built-in benchmarks and metrics like MMLU, CMMLU, C-Eval, and GSM8K. Seamlessly integrated with the [ms-swift](https://github.com/modelscope/ms-swift) training framework, EvalScope enables one-click evaluations, offering comprehensive support for model training and assessment 🚀

  <p align="center">
    <img src="docs/en/_static/images/evalscope_framework.png" width="70%">
    <br>EvalScope Framework.
  </p>

  The architecture includes the following modules:
  1. **Model Adapter**: The model adapter is used to convert the outputs of specific models into the format required by the framework, supporting both API call models and locally run models.
  2. **Data Adapter**: The data adapter is responsible for converting and processing input data to meet various evaluation needs and formats.
  3. **Evaluation Backend**:
      - **Native**: EvalScope’s own **default evaluation framework**, supporting various evaluation modes, including single model evaluation, arena mode, baseline model comparison mode, etc.
      - **OpenCompass**: Supports [OpenCompass](https://github.com/open-compass/opencompass) as the evaluation backend, providing advanced encapsulation and task simplification, allowing you to submit tasks for evaluation more easily.
      - **VLMEvalKit**: Supports [VLMEvalKit](https://github.com/open-compass/VLMEvalKit) as the evaluation backend, enabling easy initiation of multi-modal evaluation tasks, supporting various multi-modal models and datasets.
      - **RAGEval**: Supports RAG evaluation, supporting independent evaluation of embedding models and rerankers using [MTEB/CMTEB](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/mteb.html), as well as end-to-end evaluation using [RAGAS](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/ragas.html).
      - **ThirdParty**: Other third-party evaluation tasks, such as ToolBench.
  4. **Performance Evaluator**: Model performance evaluation, responsible for measuring model inference service performance, including performance testing, stress testing, performance report generation, and visualization.
  5. **Evaluation Report**: The final generated evaluation report summarizes the model's performance, which can be used for decision-making and further model optimization.
  6. **Visualization**: Visualization results help users intuitively understand evaluation results, facilitating analysis and comparison of different model performances.



  - 🔥 **[2024.12.13]** Model evaluation optimization: no need to pass the `--template-type` parameter anymore; supports starting evaluation with `evalscope eval --args`. Refer to the [📖 User Guide](https://evalscope.readthedocs.io/en/latest/get_started/basic_usage.html) for more details.
  - 🔥 **[2024.11.26]** The model inference service performance evaluator has been completely refactored: it now supports local inference service startup and Speed Benchmark; asynchronous call error handling has been optimized. For more details, refer to the [📖 User Guide](https://evalscope.readthedocs.io/en/latest/user_guides/stress_test/index.html).
  - 🔥 **[2024.10.31]** The best practice for evaluating Multimodal-RAG has been updated, please check the [📖 Blog](https://evalscope.readthedocs.io/zh-cn/latest/blog/RAG/multimodal_RAG.html#multimodal-rag) for more details.
  - 🔥 **[2024.10.23]** Supports multimodal RAG evaluation, including the assessment of image-text retrieval using [CLIP_Benchmark](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/clip_benchmark.html), and extends [RAGAS](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/ragas.html) to support end-to-end multimodal metrics evaluation.
  - 🔥 **[2024.10.8]** Support for RAG evaluation, including independent evaluation of embedding models and rerankers using [MTEB/CMTEB](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/mteb.html), as well as end-to-end evaluation using [RAGAS](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/ragas.html).
  - 🔥 **[2024.09.18]** Our documentation has been updated to include a blog module, featuring some technical research and discussions related to evaluations. We invite you to [📖 read it](https://evalscope.readthedocs.io/en/refact_readme/blog/index.html).
  - 🔥 **[2024.09.12]** Support for LongWriter evaluation, which supports 10,000+ word generation. You can use the benchmark [LongBench-Write](evalscope/third_party/longbench_write/README.md) to measure the long output quality as well as the output length.
  - 🔥 **[2024.08.30]** Support for custom dataset evaluations, including text datasets and multimodal image-text datasets.
  - 🔥 **[2024.08.20]** Updated the official documentation, including getting started guides, best practices, and FAQs. Feel free to [📖read it here](https://evalscope.readthedocs.io/en/latest/)!
  - 🔥 **[2024.08.09]** Simplified the installation process, allowing for pypi installation of vlmeval dependencies; optimized the multimodal model evaluation experience, achieving up to 10x acceleration based on the OpenAI API evaluation chain.
  - 🔥 **[2024.07.31]** Important change: The package name `llmuses` has been changed to `evalscope`. Please update your code accordingly.
  - 🔥 **[2024.07.26]** Support for **VLMEvalKit** as a third-party evaluation framework to initiate multimodal model evaluation tasks.
  - 🔥 **[2024.06.29]** Support for **OpenCompass** as a third-party evaluation framework, which we have encapsulated at a higher level, supporting pip installation and simplifying evaluation task configuration.
  - 🔥 **[2024.06.13]** EvalScope seamlessly integrates with the fine-tuning framework SWIFT, providing full-chain support from LLM training to evaluation.
  - 🔥 **[2024.06.13]** Integrated the Agent evaluation dataset ToolBench.





  We recommend using conda to manage your environment and installing dependencies with pip:

  1. Create a conda environment (optional)
     ```shell
     
     conda create -n evalscope python=3.10
     
     conda activate evalscope
     ```

  2. Install dependencies using pip
     ```shell
     pip install evalscope                # Install Native backend (default)
     
     pip install evalscope[opencompass]   # Install OpenCompass backend
     pip install evalscope[vlmeval]       # Install VLMEvalKit backend
     pip install evalscope[rag]           # Install RAGEval backend
     pip install evalscope[perf]          # Install Perf dependencies
     pip install evalscope[all]           # Install all backends (Native, OpenCompass, VLMEvalKit, RAGEval)
     ```

  > [!WARNING]
  > As the project has been renamed to `evalscope`, for versions `v0.4.3` or earlier, you can install using the following command:
  > ```shell
  > pip install llmuses<=0.4.3
  > ```
  > To import relevant dependencies using `llmuses`:
  > ``` python
  > from llmuses import ...
  > ```


  1. Download the source code
     ```shell
     git clone https://github.com/modelscope/evalscope.git
     ```

  2. Install dependencies
     ```shell
     cd evalscope/
     pip install -e .                  # Install Native backend
     
     pip install -e '.[opencompass]'   # Install OpenCompass backend
     pip install -e '.[vlmeval]'       # Install VLMEvalKit backend
     pip install -e '.[rag]'           # Install RAGEval backend
     pip install -e '.[perf]'          # Install Perf dependencies
     pip install -e '.[all]'           # Install all backends (Native, OpenCompass, VLMEvalKit, RAGEval)
     ```




  To evaluate a model on specified datasets using default configurations, this framework supports two ways to initiate evaluation tasks: using the command line or using Python code.



  Execute the `eval` command in any directory:
  ```bash
  evalscope eval \
   --model Qwen/Qwen2.5-0.5B-Instruct \
   --datasets gsm8k arc \
   --limit 5
  ```



  When using Python code for evaluation, you need to submit the evaluation task using the `run_task` function, passing a `TaskConfig` as a parameter. It can also be a Python dictionary, yaml file path, or json file path, for example:

  **Using Python Dictionary**

  ```python
  from evalscope.run import run_task

  task_cfg = {
      'model': 'Qwen/Qwen2.5-0.5B-Instruct',
      'datasets': ['gsm8k', 'arc'],
      'limit': 5
  }

  run_task(task_cfg=task_cfg)
  ```

  <details><summary>More Startup Methods</summary>

  **Using `TaskConfig`**

  ```python
  from evalscope.run import run_task
  from evalscope.config import TaskConfig

  task_cfg = TaskConfig(
      model='Qwen/Qwen2.5-0.5B-Instruct',
      datasets=['gsm8k', 'arc'],
      limit=5
  )

  run_task(task_cfg=task_cfg)
  ```

  **Using `yaml` file**

  `config.yaml`:
  ```yaml
  model: Qwen/Qwen2.5-0.5B-Instruct
  datasets:
    - gsm8k
    - arc
  limit: 5
  ```

  ```python
  from evalscope.run import run_task

  run_task(task_cfg="config.yaml")
  ```

  **Using `json` file**

  `config.json`:
  ```json
  {
      "model": "Qwen/Qwen2.5-0.5B-Instruct",
      "datasets": ["gsm8k", "arc"],
      "limit": 5
  }
  ```

  ```python
  from evalscope.run import run_task

  run_task(task_cfg="config.json")
  ```
  </details>


  - `--model`: Specifies the `model_id` of the model in [ModelScope](https://modelscope.cn/), which can be automatically downloaded, e.g., [Qwen/Qwen2.5-0.5B-Instruct](https://modelscope.cn/models/Qwen/Qwen2.5-0.5B-Instruct/summary); or use the local path of the model, e.g., `/path/to/model`
  - `--datasets`: Dataset names, supports inputting multiple datasets separated by spaces. Datasets will be automatically downloaded from modelscope. For supported datasets, refer to the [Dataset List](https://evalscope.readthedocs.io/en/latest/get_started/supported_dataset.html)
  - `--limit`: Maximum amount of evaluation data for each dataset. If not specified, it defaults to evaluating all data. Can be used for quick validation


  ```
  +-----------------------+-------------------+-----------------+
  | Model                 | ai2_arc           | gsm8k           |
  +=======================+===================+=================+
  | Qwen2.5-0.5B-Instruct | (ai2_arc/acc) 0.6 | (gsm8k/acc) 0.6 |
  +-----------------------+-------------------+-----------------+
  ```


  For more customized evaluations, such as customizing model parameters or dataset parameters, you can use the following command. The evaluation startup method is the same as simple evaluation. Below shows how to start the evaluation using the `eval` command:

  ```shell
  evalscope eval \
   --model Qwen/Qwen2.5-0.5B-Instruct \
   --model-args revision=master,precision=torch.float16,device_map=auto \
   --generation-config do_sample=true,temperature=0.5 \
   --dataset-args '{"gsm8k": {"few_shot_num": 0, "few_shot_random": false}}' \
   --datasets gsm8k \
   --limit 10
  ```


  - `--model-args`: Model loading parameters, separated by commas in `key=value` format. Default parameters:
    - `revision`: Model version, default is `master`
    - `precision`: Model precision, default is `auto`
    - `device_map`: Model device allocation, default is `auto`
  - `--generation-config`: Generation parameters, separated by commas in `key=value` format. Default parameters:
    - `do_sample`: Whether to use sampling, default is `false`
    - `max_length`: Maximum length, default is 2048
    - `max_new_tokens`: Maximum length of generation, default is 512
  - `--dataset-args`: Configuration parameters for evaluation datasets, passed in `json` format. The key is the dataset name, and the value is the parameters. Note that it needs to correspond one-to-one with the values in the `--datasets` parameter:
    - `few_shot_num`: Number of few-shot examples
    - `few_shot_random`: Whether to randomly sample few-shot data, if not set, defaults to `true`

  Reference: [Full Parameter Description](https://evalscope.readthedocs.io/en/latest/get_started/parameters.html)



  EvalScope supports using third-party evaluation frameworks to initiate evaluation tasks, which we call Evaluation Backend. Currently supported Evaluation Backend includes:
  - **Native**: EvalScope's own **default evaluation framework**, supporting various evaluation modes including single model evaluation, arena mode, and baseline model comparison mode.
  - [OpenCompass](https://github.com/open-compass/opencompass): Initiate OpenCompass evaluation tasks through EvalScope. Lightweight, easy to customize, supports seamless integration with the LLM fine-tuning framework ms-swift. [📖 User Guide](https://evalscope.readthedocs.io/en/latest/user_guides/backend/opencompass_backend.html)
  - [VLMEvalKit](https://github.com/open-compass/VLMEvalKit): Initiate VLMEvalKit multimodal evaluation tasks through EvalScope. Supports various multimodal models and datasets, and offers seamless integration with the LLM fine-tuning framework ms-swift. [📖 User Guide](https://evalscope.readthedocs.io/en/latest/user_guides/backend/vlmevalkit_backend.html)
  - **RAGEval**: Initiate RAG evaluation tasks through EvalScope, supporting independent evaluation of embedding models and rerankers using [MTEB/CMTEB](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/mteb.html), as well as end-to-end evaluation using [RAGAS](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/ragas.html): [📖 User Guide](https://evalscope.readthedocs.io/en/latest/user_guides/backend/rageval_backend/index.html)
  - **ThirdParty**: Third-party evaluation tasks, such as [ToolBench](https://evalscope.readthedocs.io/en/latest/third_party/toolbench.html) and [LongBench-Write](https://evalscope.readthedocs.io/en/latest/third_party/longwriter.html).



  A stress testing tool focused on large language models, which can be customized to support various dataset formats and different API protocol formats.

  Reference: Performance Testing [📖 User Guide](https://evalscope.readthedocs.io/en/latest/user_guides/stress_test/index.html)

  **Supports wandb for recording results**

  ![wandb sample](https://modelscope.oss-cn-beijing.aliyuncs.com/resource/wandb_sample.png)

  **Supports Speed Benchmark**

  It supports speed testing and provides speed benchmarks similar to those found in the [official Qwen](https://qwen.readthedocs.io/en/latest/benchmark/speed_benchmark.html) reports:

  ```text
  Speed Benchmark Results:
  +---------------+-----------------+----------------+
  | Prompt Tokens | Speed(tokens/s) | GPU Memory(GB) |
  +---------------+-----------------+----------------+
  |       1       |      50.69      |      0.97      |
  |     6144      |      51.36      |      1.23      |
  |     14336     |      49.93      |      1.59      |
  |     30720     |      49.56      |      2.34      |
  +---------------+-----------------+----------------+
  ```


  EvalScope supports custom dataset evaluation. For detailed information, please refer to the Custom Dataset Evaluation [📖User Guide](https://evalscope.readthedocs.io/en/latest/advanced_guides/custom_dataset/index.html)



  The Arena mode allows multiple candidate models to be evaluated through pairwise battles, and can choose to use the AI Enhanced Auto-Reviewer (AAR) automatic evaluation process or manual evaluation to obtain the evaluation report.

  Refer to: Arena Mode [📖 User Guide](https://evalscope.readthedocs.io/en/latest/user_guides/arena.html)





  - [x] RAG evaluation
  - [x] VLM evaluation
  - [x] Agents evaluation
  - [x] vLLM
  - [ ] Distributed evaluating
  - [x] Multi-modal evaluation
  - [ ] Benchmarks
    - [ ] GAIA
    - [ ] GPQA
    - [x] MBPP
  - [ ] Auto-reviewer
    - [ ] Qwen-max




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


pkgId: fddf08ecac589c8c6061515a3c67009fd48f715e8e97fc35e66b1245a681593a
name: python-evc_manager-help
arch: noarch
version: 1.3.15
epoch: 0
release: 1
summary: Development documents and examples for evc_manager
url: https://pypi.org/project/evc_manager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-evc_manager-1.3.15-1.src.rpm
location_href: Packages/python-evc_manager-help-1.3.15-1.noarch.rpm
checksum_type: sha256
description:
  The AmLight EVC Manager is a command line tool to help SDN operators in
  managing Ethernet Virtual Circuits (EVC), such as
  creating/deleting/changing multiple EVCs at a time. It was created to
  help AmLight network engineers in the daily operation of the AmLight SDN
  network, which currently has more than one thousands flows and more than
  ten OpenFlow switches in North and South America.

  The AmLight EVC\_Manager requires Python 3.6+



  The EVC Manager was created with the following major goals:

  >   - Supporting multiple backends, such as OESS and Kytos E-Line.
  >   - Supporting exporting EVCs to YAML or JSON files
  >   - Supporting creating/changing/deleting multiple EVCs via YAML files
  >   - Supporting moving EVCs out a specific link (or NNI)
  >   - Supporting forcing circuit reprovisioning
  >   - Supporting changing EVCs' paths
  >   - Supporting exporting monitoring data using Zabbix LLD format for
  >     integration with Zabbix
  >   - Supporting multiple queries:
  >       - Get VLANs in use in a specific UNI or NNI
  >       - Get EVCs using a specific UNI or NNI
  >       - Get EVC utilization
  >       - Get list of EVCs with under-provisioned paths
  >       - Get EVCs using backup paths
  >       - Get list of devices and links
  >       - Compare and report two EVC dumps



  The current version of EVC Manager is `1.3`. The following major features are supported:

  >   - Supporting for OESS 1.0.9 backend
  >   - Supporting exporting all EVCs to YAML or JSON files
  >   - Supporting creating/changing/deleting multiple EVCs via YAML files
  >   - Supporting for EVC creation using VLAN ranges
  >   - Supporting moving EVC out a specific link (or NNI)
  >   - Supporting changing EVCs' paths
  >   - Supporting multiple queries:
  >       - Get EVC using a specific UNI
  >       - Get EVC using a specific NNI
  >       - Get EVC using backup paths
  >   - Supporting exporting monitoring data using Zabbix LLD format for
  >     integration with Zabbix
  >   - Supporting for Kytos MEF E-Line backend
  >   - Supporting forcing EVC reprovisioning
  >   - Supporting multiple queries:
  >       - Get VLANs in use in a specific UNI
  >       - Get circuit utilization
  >       - Get circuit with under-provisioned paths
  >       - Get list of devices and links



  The EVC Manager should run as a Python module and installed directly from pip repository. The
  following are directions for `Python >= 3.9` and `Python < 3.6`



  EVC manager can be installed using `pip install evc_manager`. Please verify the installed version against the current version of EVC manager.



  If you run `pip install evc_manager` and the version given is wrong, you have two options:

  > 1: Run `pip install --no-cache-dir evc_manager`

  > 2: Run `pip install evc_manager==x.x.x`, where x.x.x is the current working version of `evc_manager`



  EVC manager does not support `pip install` for Python versions lower than 3.9. Do achieve this, please clone the GitLab repository and run:

  ```
  cd evc_manager/

  cp -f pyproject-36.toml pyproject.toml

  python3 -m pip install .
  ```



  Before using the EVC Manager, make sure you have Python3 and PIP for your environment.
  Then, prepare the environment using the following steps:

  Create a Python virtual environment:

      python3 -m venv py3-evc_manager
      source py3-evc_manager/bin/activate

  Install git. Then, close the repo and install all requirements

      pip install evc_manager

  There are two options to run EVC Manager. As a script at the Shell or as a module in your
  application.

  To run EVC Manager as a script, just run using the syntax below:

      python3.6 -m evc_manager [-h]
                               (-L | -A | -R | -D | -M MOVE_EVC) [-f SOURCE_FILE]
                               [-F DESTINATION_FILE]
                               [--has-uni-device HAS_UNI_DEVICE]
                               [--has-uni-interface HAS_UNI_INTERFACE]
                               [--has-uni-tag-value HAS_UNI_TAG_VALUE]
                               [--has-uni-tag-values HAS_UNI_TAG_VALUES]
                               [--has-nni-name HAS_NNI_NAME]
                               [--has-nni-name-primary HAS_NNI_NAME_PRIMARY]
                               [--has-nni-name-backup HAS_NNI_NAME_BACKUP]
                               [--has-evc-name HAS_EVC_NAME]
                               [--has-partial-evc-name HAS_PARTIAL_EVC_NAME]
                               -u USER [-t TENANT]
                               [-p PASSWORD | -P]
                               (-O OESS_URL | -K KYTOS_URL)
                               [-V]
                               [-v {info,warning,debug}]
                               [-q]
                               [-y | -Y | -j | -z]
                               [-T TO_TABLE]
                               [-s GEN_STATS_PER_NNI]

      optional arguments:
        -h, --help            show this help message and exit
        -L, --list-evc        List all EVCs and output them using YAML
        -A, --add-evc         Add EVCs provided in the YAML file
        -R, --add-range-evcs  Add a range of EVCs provided in the YAML file
        -C, --change-evc      Change EVCs provided in the YAML file
        -D, --delete-evc      Delete all EVCs provided in the YAML file
        -M, --move-evc        Move one or all EVCs out the NNI provided.
        -X, --template        Create a template folder with YAML files to help.
        --move-from-nni MOVE_FROM_NNI
                              Move out of the provided NNI
        -f SOURCE_FILE, --source-file SOURCE_FILE
                              Source YAML file used by options -A, -R, -C, -D or -M
        -F DESTINATION_FILE, --destination-file DESTINATION_FILE
                              Destination YAML file used by options -L
        -p PASSWORD, --password PASSWORD
                              Provide pass for authentication
        -P, --prompt_password
                              Prompt pass for authentication
        -O OESS_URL, --oess-url OESS_URL
                              Use OESS backend. Provide OESS's URL
        -K KYTOS_URL, --kytos-url KYTOS_URL
                              Use Kytos E-Line backend's URL.
        -V, --version         show program's version number and exit
        -v {info,warning,debug}, --verbose {info,warning,debug}
                              Set Verbose Level (info|warning|debug)
        -q, --quiet           Set Quiet Mode
        -y, --to-yaml         Print using YAML.
        -Y, --to-yaml-minimal
                              Print using YAML but only the smallest set of mandatory attrs.
        -j, --to-json         Print using JSON.
        -z, --to_zabbix       Converts output to Zabbix LLD format
        -n, --to-screen       Print EVC's names to screen instead of to files
        -T TO_TABLE, --to_table TO_TABLE
                              Converts output to a table format. Use Syntax: Primary|Backup|Any:Circuit_Name
        -s GEN_STATS_PER_NNI, --gen_stats_per_nni GEN_STATS_PER_NNI
                              List number of EVCs per NNI-s Any: list all NNIs To filter use -s NNI[:JSON]
        -S SHORTCUT_FILE, --shortcut-file SHORTCUT_FILE
                              Use a provided shortcut file. Default is .evc_manager

      filters:
        --has-uni-device HAS_UNI_DEVICE
                              Filter output based on the UNI's device
        --has-uni-interface HAS_UNI_INTERFACE
                              Filter output based on the UNI's interface
        --has-uni-tag-value HAS_UNI_TAG_VALUE
                              Filter output based on the UNI's tag value (VLAN ID). Possible filter values include integers, 'untagged', or a range of integers in increasing value, such as 10-12.
        --has-uni-tag-values HAS_UNI_TAG_VALUES
                              Filter output based on the UNI's tag value (VLAN ID) using comma separated values. Possible filter values include integers, 'untagged', or a range of integers in increasing value. Example: To search for EVCS with 'untagged', 10,
                              or values between 20-30, use --has-uni-tag-values untagged,10,20-30
        --has-nni-name HAS_NNI_NAME
                              Filter output based on the NNI's name
        --has-nni-name-primary HAS_NNI_NAME_PRIMARY
                              Filter output when NNI's name is in primary path
        --has-nni-name-backup HAS_NNI_NAME_BACKUP
                              Filter output when NNI's name is in backup path
        --has-evc-name HAS_EVC_NAME
                              Filter output based on the EVC's name
        --has-partial-evc-name HAS_PARTIAL_EVC_NAME
                              Filter output based on the EVC's name or regex operation.If you're receiving an error, try putting your value in quotes ('')

      authentication:
        -u USER, --user USER  Backend user for authentication
        -t TENANT, --tenant TENANT
                              Backend user group for authentication

  To use EVC_Manager as a Python module, follow these steps. The INPUT is just an example and
  represents the input you mean to submit to the evc_manager (use option -h to discover all options):

      from evc_manager import EvcManager, get_cli
      INPUT = ['-u', 'admin',
           '-t', 'admin',
           '-p', 'sparc123',
           '-O', 'https://192.168.56.10/oess/',
           '-v', 'info',
           '-q',
           '-f', './add_evcs.yaml',
           '-A']
      evc_mgr = EvcManager(get_cli(INPUT))
      final_result = evc_mgr.run()
      print(final_result)

  Attention: Avoid using option --password with admin accounts. Your password might be stored
  in your Bash history\!\!



  EVC Manager is built to be installed through pip, but to develop through Git you need to follow the following steps:



  In a previous section it was advised that you create a virtual environment to install your dev dependencies. We accomplish this by doing:

  ```
  python3 -m venv py3-evc_manager
  source py3-evc_manager/bin/activate
  ```



  Now that we have the virtual environment running, install poetry through pip:

  ```
  pip install poetry
  ```



  Change your directory into evc_manager, where you should see poetry.lock and pyproject.toml. Here you need to install poetry's dependencies:

  ```
  poetry install --with dev --no-root
  ```



  After installing poetry's dependencies, we can run any development related task with simple commands. Here are a list of necessary commands:

  - `poetry run tox`
  	- Runs ALL tests found in `tox.ini`.

  - `poetry run tox -e <TEST1,TEST2,TEST3,...>`
    - This runs specific tests run specific tests.
    - Example:
      - `poetry run tox -e unit-tests,integration-tests,coverage`

  - `poetry run tox -p`
    - This runs tests in parallel
    - Works with `-e`

  - `poetry install`
  	- Installs all the dependencies listed in `pyproject.toml` and `poetry.lock`

  - `poetry install --without <group>`
  	- When installing it excludes the groups you specify, such as `dev`.

  - `poetry install --with <group>`
    - When installing it includes the groups you specify, such as `dev`.

  - `poetry install --no-root`
  	- When installing it excludes downloading the package itself

  Here is the rest of the commands, but it is unlikely that these commands would be used.

  - `poetry add <package>`
  	- Adds a package (such as `coverage`, `pytest`, ...) to `pyproject.toml` and `poetry.lock`

  - `poetry update`
  	- Updates the project dependencies to their latest compatible versions

  - `poetry lock`
    - Updates the lock file if pyproject.toml changes



  To help modeling EVCs, the following data model was created:

      version: 1.0
      name: Circuit Name
      unis: List of User-to-Network Interfaces
        - device: network device's name
          interface_name: network device's interface_name
          interface_description: network device's interface_description
          mac_addresses: list of MAC addresses connected to the network interface
            -
          tag: interface TAG type
            type: Type could be MPLS or VLAN
            value: VLAN ID or MPLS tag or [start, end] for VLAN ranges.
      metrics: Circuit required metrics
        min_bw: minimum bandwidth
        max_delay: maximum delay acceptable in milliseconds
        max_hops: max number of hops
        avoid_shared: if circuit should avoid shared links
      provisioning_time: when the circuit should be created
      decommissioning_time: when the circuit should be terminated
      requested_paths: list of paths, in a priority list. 'Any' if no physical path is required.
      tenant: group name
      priority: circuit priority
      external_id: any external ID if needed
      monitoring: monitoring requirements
        dataplane:
          trace: if data plane path tracing is required
            active: True or False
            interval: interval between tests
        controlplane:
          trace: if control plane path tracing is enough
            active: True or False
            interval: interval between tests
      notification: notification requirements
        slack_channel:
          - workgroup1
            channel1
          - workgroup2
            channel2
        emails:
          - user1@email
          - user2@email
      current_config: Current configuration
        backend: backend or technology being used
        current_path: # list of links being used
        is_backup: is it using a backup path?
        is_optimized: is it using under-provisioned links? (not enough BW, delay higher that required, etc.)
        to_provisioned:
        is_expired:
        is_up:
        is_active: True if between provisioning time and decommissioning time

  Data models are provided on folder libs.models.





  - Added support for installing evc_manager for Python < 3.9



  - Added testing and linting for Python 3.12, 3.11, 3.10, and 3.9
  - Fixed deprecated methods producing errors on Python 3.12



  - Added unit tests
  - Fixed a bug where the paths attribute was incorrectly displaying for some EVCs


pkgId: 8b00f93909d14999a3336d504c7e7858523372bc388aa3d708c9135c33b47f6b
name: python-eventlet-help
arch: noarch
version: 0.38.2
epoch: 0
release: 1
summary: Development documents and examples for eventlet
url: https://github.com/eventlet/eventlet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-eventlet-0.38.2-1.src.rpm
location_href: Packages/python-eventlet-help-0.38.2-1.noarch.rpm
checksum_type: sha256
description:
  **New usages of eventlet are now heavily discouraged! Please read the
  following.**
  Eventlet was created almost 18 years ago, at a time where async
  features were absent from the CPython stdlib. With time eventlet evolved and
  CPython too, but since several years the maintenance activity of eventlet
  decreased leading to a growing gap between eventlet and the CPython
  implementation.
  This gap is now too high and can lead you to unexpected side effects and bugs
  in your applications.
  Eventlet now follows a new maintenance policy. **Only maintenance for
  stability and bug fixing** will be provided. **No new features will be
  accepted**, except those related to the asyncio migration. **Usages in new
  projects are discouraged**. **Our goal is to plan the retirement of eventlet**
  and to give you ways to move away from eventlet.
  If you are looking for a library to manage async network programming,
  and if you do not yet use eventlet, then, we encourage you to use `asyncio`_,
  which is the official async library of the CPython stdlib.
  If you already use eventlet, we hope to enable migration to asyncio for some use
  cases; see `Migrating off of Eventlet`_. Only new features related to the migration
  solution will be accepted.
  If you have questions concerning maintenance goals or concerning
  the migration do not hesitate to `open a new issue`_, we will be happy to
  answer them.


pkgId: a0cf1a21c468223beaacf64d9aefc8e832bbeec7079513db88d79df6dd78909d
name: python-everviz-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for everviz
url: https://pypi.org/project/everviz/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-everviz-0.1.1-1.src.rpm
location_href: Packages/python-everviz-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Publish Python 🐍 distributions 📦 to PyPI](https://github.com/equinor/everviz/workflows/Publish%20Python%20%F0%9F%90%8D%20distributions%20%F0%9F%93%A6%20to%20PyPI/badge.svg)
  ![Python package](https://github.com/equinor/everviz/workflows/Python%20package/badge.svg)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: AGPL v3](https://img.shields.io/badge/License-AGPL%20v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)




  everviz is a visualization plugin for everest based on [dash](https://github.com/plotly/dash)
  and [webviz-config](https://github.com/equinor/webviz-config).


  The code is hosted on GitHub:
  https://github.com/equinor/everviz

  The latest version is available on [pypi](https://pypi.org/project/everviz).

  ```sh

  pip install everviz
  ```



  ```sh

  wget https://chromedriver.storage.googleapis.com/$(wget https://chromedriver.storage.googleapis.com/LATEST_RELEASE -q -O -)/chromedriver_linux64.zip
  unzip chromedriver_linux64.zip
  export PATH=$PATH:$PWD
  python -m pip install ".[test]"
  pytest --headless
  ```


pkgId: cec14d28d43f8176b233d0ddd81cd8cfb70628642e82cfd725d7638973b7ae53
name: python-everysk-beta-help
arch: noarch
version: 1.6.1381
epoch: 0
release: 1
summary: Development documents and examples for everysk-beta
url: https://everysk.com/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-everysk-beta-1.6.1381-1.src.rpm
location_href: Packages/python-everysk-beta-help-1.6.1381-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to the documentation for the Everysk Library!

  Everysk's library was developed with the aim of unifying python
  codes to be used in various company projects.



  The [Everysk API](https://everysk.com/api/docs) is build around the standard [REST](https://en.wikipedia.org/wiki/REST) protocol and contains multiple endpoints to perform calculations, create portfolios, create workspaces where you can manage datastores, reports, files, workflows, and much more.



  Docker is used to create, run, and manage containers. In this project, Docker is used to set up a **PyPi** server and built the **Everysk library**.



  To run the pypi server, first you will need to build a Docker image and then run a container from that image.



  The command below builds a Docker image using the Dockerfile located in the `./docker/` directory. The `--target` option specifies the build stage, which in this case is `everysk_pypi_server`. The `--tag` option assigns a name and tag to the image, `everysk_pypi_server:latest`.

  ```bash
    docker build --file ./docker/Dockerfile --target everysk_pypi_server --tag everysk_pypi_server:latest .
  ```



  After that, you will need to run the Docker container from the image built in the previous step. The `--rm` option removes the container when it exits. The `-it` option allows you to interact with the container. The `-e` option sets the environment variable `PYPI_PASSWORD` to '123123'. The `-p` options map the host ports 8080 and 2020 to the container ports 80 and 22 respectively.

  ```
    docker run --rm -it -e PYPI_PASSWORD='123123' -p 0.0.0.0:8080:80 -p 0.0.0.0:2020:22 everysk_pypi_server:latest
  ```



  To build the library and send to Pypi server, you will need to build another Docker image and run, once again, a container from that image.



  We use a command that is similar to the one used to build the PyPI server image, the only thing that differs is the target build stage and tag.

  ```bash
    docker build --file ./docker/Dockerfile --target everysk_lib_build --tag everysk_lib_build:latest .
  ```



  After building the docker image, we run a Docker container from the image built in the previous step. The environment variables `PYPI_PASSWORD` and `PYPI_HOST` are set to '123123' and '192.168.0.116' respectively.

  ```
    docker run --rm -it -e PYPI_PASSWORD='123123' -e PYPI_HOST='192.168.0.116' everysk_lib_build:latest
  ```



  Let's have a look at the different modules available from the everysk library



  The **compress** module from `everysk.core` allows the compression and decompression of JSON files and Python objects. It includes functions to serialize objects into JSON strings or pickle objects, then it compresses or decompresses them using the zlib or gzip module.

  Below we have an implementation example of one of the methods inside the module.

  ```python
      >>> from everysk.core.compress import compress
      >>> data = {'key' : 'value'}
      >>> compressed_data = compress(data)
      b'x\x9c\xcbH\xcd\xc9\xc9W(....) # example of the compressed data
  ```



  This module is a collection of custom exception classes designed to handle errors then raise specific exceptions based on those errors. They also provide attributes and methods to improve the debugging experience.

  Below we have an example of the `DateError` exception being raised after we passed an invalid input to a hypothetical function.

  ```python
      >>> from everysk.core.exceptions import DateError
      >>> try:
      ...     result = validate_month_day('2024-01-01')
      ...     return result
      >>> except:
    ...       raise DateError('invalid date format')
  ```



  The **object** and **fields** modules from the `everysk.core` package are used to create classes with consistent and type-checked data.

  Here's an example of how to use them:

  ```python
      >>> from everysk.core.fields import BoolField
      >>> from everysk.core.object import BaseDict
      >>>
      >>> class MyClass(BaseDict):
      ...     field: BoolField(required=True)
      >>>
      >>> obj = MyClass(field=True)
      >>> obj.field is True
      ... True
      >>> obj.field == obj['field']
      ... True
  ```



  Module **http.py** module provides a set of classes for handling HTTP requests within the `everysk` framework, it is designed to facilitate HTTP communications, including specific error checking and functionalities for dealing with authentication.

  ```python
      >>> from everysk.core.http import HttpGETConnection
      >>>
      >>> class MyConnection(HttpGETConnection):
      ...     url: StrField(default='https://example.com', readonly=True)
      ...     def get_params(self) -> dict:
      ...         # Will be added to url p=1&p=2
      ...         return {'p': 1, 'p': 2}
      ...
      ...     def message_error_check(self, message: str, status_code: int) -> bool:
      ...         # If this message appear on HttpError then we try again.
      ...         return 'server is busy' in message
      >>>
      >>> response = MyConnection().get_response()
  ```



  Module **settings** is the sum of all settings.py created on the project.
  Every setting will have it's value first from env otherwise from the attribute.

  ```python
      >>> from everysk.config import settings
      >>> settings.DEBUG
      True
  ```



  The **log** module from `log.py` includes a collection of methods and classes designed to handle logging operations.

  ```python
      >>> from everysk.core.log import Logger
      >>> log = Logger(name='log-test')
      >>> log.debug('Test')
      '2024-02-07 12:49:10,640 - DEBUG - {} - Test'
  ```

  The log module also has useful methods like the `slack()` method from the `Logger` class which can send slack messages to a channel using the **Slack WebHooks**. Check out their [documentation](https://api.slack.com/messaging/webhooks).

  Let's have a look at how the `slack()` method is used:

  ```python
      >>> from everysk.core.log import Logger
      >>> slack_instantiation = Logger()
      >>> slack_instantiation.slack(title='title of the message', message='body of the message', color='danger')
      '2024-05-23 13:17:22,734 - Slack message: title of the message -> body of the message'
  ```



  The `workers.py` file provides a framework for managing and executing tasks using Google Cloud Tasks within the `everysk` ecosystem. It utilizes Google Cloud Tasks to enqueue and process asynchronous tasks, suitable for handling operations that require delay or scheduling.

  Below we have an usage example of deploying tasks using the `TaskGoogle` class:

  ```python
      >>> from everysk.core.workers import TaskGoogle
      >>> task = TaskGoogle(worker_url='https://example.com/worker', worker_id='example_worker_id')
      >>> task.save(timeout=30.0, retry_times=3)
  ```

  This example shows how to initialize a task with a specific worker URL and worker ID, then save it to [**Google Cloud Tasks**](https://cloud.google.com/tasks/docs).



  Module **firestore.DocumentCached** is a Redis/Firestore document. This uses Redis for
  read the data and Redis/Firestore to store the data. To keep the cache synchronized
  with Firestore, use everysk/cloud_function. With this when we alter the data using
  Firestore interface the cache will be updated.

  ```python
      >>> from everysk.core.firestore import DocumentCached
      >>> doc = Document(_collection_name='collection', firestore_id='firestore_id')
      >>> doc.firestore_id
      'firestore_id'
  ```



  The `string.py` module in the `everysk` library provides a handful of utility functions designed for string manipulation and validation, this is useful for handling text data in a variety of programming and data processing contexts.

  Below we have an example of the `pluralize()` method that transforms the string into it's pluralized version

  ```python
      >>> from everysk.core.string import pluralize
      >>> pluralize('system')
      'systems'
  ```

  Below is another example of a method that converts the current string into the snake case format.

  ```python
      >>> from everysk.core.string import snake_case
      >>> snake_case('CustomIndex')
      'custom_index'
  ```



  The `threads.py` module offers different methods for managing [concurrent execution](https://en.wikipedia.org/wiki/Concurrent_computing) using threads, tailored specifically for environments that require parallel processing.

  Below we have an example of code that executes a task asynchronously with a simple thread management.

  ```python
      >>> from everysk.core.threads import Thread

      >>> def sum(a: int, b: int) -> int:
      ...     return a + b
      ...
      >>> thread = Thread(target=sum, args=(1, 2))
      >>> task.start()
      >>> task.join()
      3
  ```

  This module is proved to be useful for applications within the `everysk` infrastructure that require parallel computation or asynchronous task management.



  The serialize module is designed to handle serialization and deserialization of complex Python objects to and from JSON format, with specific support for dates, custom objects, and structured data.

  Here is an example for serializing a Python object to a JSON string in bytes:

  ```python
      >>> from everysk.core.serialize import dumps
      >>> class MyClass:
      ...     def __init__(self, worker_name, worker_id):
      ...         self.worker_name = worker_name
      ...         self.worker_id = worker_id
      ...
      >>> def _default(obj):
      ...     if isinstance(obj, MyClass):
      ...         return obj.__dict__
      ...     raise TypeError(f'Type {type(obj)} is not serializable')
      ...
      >>> my_obj = MyClass('sample_worker', 'sample_worker_id')
      >>> serialized_data = dumps(my_obj, default=_default)
  ```



  The `number.py` module is designed to provide utility functions related to numerical operations.

  Below we have an implementation of the function `is_float_convertible` that returns a boolean indicating whether the value can be converted to a float point value or not.
  ```python
      >>> from everysk.core.numbers import is_float_convertible
      >>> is_float_convertible('3.14')
      True

      >>> is_float_convertible(5)
      True

      >>> is_float_convertible('not a float')
      False
  ```



  The **Redis** module is designed to interact with a Redis server to store, retrieve and manage cached data.

  Below is an example of how to use the `acquire()` method to verify if a key is locked by the current lock.

  ```python
      >>> from everysk.core.redis import RedisLock
      >>> redis_lock = RedisLock(name='test_name', timeout=1, host='1.0.0.0', port=4435)
      >>> redis_lock.acquire('example_lock_key')
      'Lock acquired for key "example lock_key"'
  ```



  Here you can access the instructions on how to install the `everysk-beta` library using pip.

  To install the `everysk-beta` library, you will need to use pip's `install` command along with the `--index-url` option that allows you to specify the PyPI server from which to install the package.

  Replace `PYPI_HOST` with the actual host of your PyPI server. Then run the following command:

  ```bash
    pip install --index-url https://PYPI_HOST everysk-beta
  ```



  After installing the library, it's a good practice to verify if the installation was successful. Here is how to achieve this:







  ```python
    import everysk
  ```

  If the library has been installed correctly, this command should complete without any errors. If the library is not installed or there's a problem with the installation, Python will raise a `ModuleNotFoundError`




  This section provides instructions on how to run tests for the project. There are two scenarios, the first one is running tests in a development environment and the second one is running tests after the library has been installed from PyPI.



  In a development environment you can use the provided shell script to run the tests. The script sets up the necessary environment and then run the tests. To execute the tests, open a bash terminal and run the following command.

  ```bash
    ./run.sh tests
  ```



  After the library has been installed in your project from PyPI, you can start running tests using Python's built-in unittest module. To run tests use the following command:


  ```bash
    python3 -m unittest everysk.core.tests
  ```

  The command uses Python's unittest module as mentioned above as a script, which then runs the test in the `everysk.core.tests` package.




  Code coverage us a way of measuring how many lines of code are executed while the automated tests are running.

  To run tests along with a coverage report, you can use the provided shell script. The script will not only run the tests but also generate a coverage report that shows the percentage of code that was executed during the tests.

  This is useful to identify sections of your code that are not being tested and may need additional tests.





  ```bash
    ./run.sh coverage
  ```

  This command executes the `run.sh` script with the `coverage` argument. The report will be displayed in the terminal after the script completed the tests.

  **Remember:** a high coverage percentage is generally good, but 100% coverage does not ensures that your code is free from bugs or any other problem that might occur in your code. The full coverage just means that all the lines in your code were executed during the tests.




  Contributions are always welcome and greatly appreciated!

  Go to the repository [link](https://github.com/Everysk/everysk-lib) and click on the `Fork` button to create your own copy of the everysk library.

  Then clone the project in your own local machine by running the command below or using the **GitHub Desktop**.

  ```bash
    git clone https://github.com/<your-username>/everysk-lib.git everysk-yourusername
  ```

  This section creates a directory called `everysk-yourusername` to center all your code.

  After that you can change the directory by:

  ```bash
    cd everysk-yourusername
  ```

  Create the **upstream** repository which will refer to the main repository that you just forked.

  ```bash
    git remote add upstream https://github.com/Everysk/everysk-lib.git
  ```

  Now run the following commands to make sure that your clone is up-to-date with main everysk repository

  ```bash
    git checkout main
    git pull upstream main
  ```

  Shortly after, create a new branch to add your code

  ```bash
    git checkout -b brand-new-feature
  ```

  The command above will automatically switch to this newly created branch. At this moment your are able to make your modifications to the code and commit locally as you progress.

  After all the code changes, you can submit your contribution by pushing the changes to your fork on GitHub:

  ```bash
    git push origin brand-new-feature
  ```

  The command above ensures that all the modifications that you've made are up-to-date with your current branch.

  At the end of this process you will need to make a **Pull Request** to the main branch.

  To achieve this, go to the GitHub page of the project and click on the `Pull requests` tab, then click on `New pull request` button.

  This will open a new section used to compare branches, now choose your branch for merging into the main branch and hit the `Create pull request` button.



  (C) Copyright 2023 EVERYSK TECHNOLOGIES

  This is an unpublished work containing confidential and proprietary
  information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
  without authorization of EVERYSK TECHNOLOGIES is prohibited.

  Date: Jan 2023

  Contact: contact@everysk.com

  URL: https://everysk.com/

rpm_license:
  (C) Copyright 2023 EVERYSK TECHNOLOGIES  This is an unpublished work containing confidential and proprietary information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction without authorization of EVERYSK TECHNOLOGIES is prohibited.  Date: Jan 2023 Contact: fscariott@everysk.com URL: https://everysk.com/


