# packages

pkgId: d342ee6e379594f13dd931899807f9262cea1b8fa0a9ed183753f6337e254a61
name: python-GraphVelo-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for GraphVelo
url: https://pypi.org/project/GraphVelo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GraphVelo-0.1.0-1.src.rpm
location_href: Packages/python-GraphVelo-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  GraphVelo is a graph-based machine learning procedure that uses RNA velocities inferred from existing methods as input and infers velocity vectors lie in the tangent space of the low-dimensional manifold formed by the single cell data. GraphVelo preserves vector magnitude and direction information during transformations across different data representations. If you use our tool in your own work, please cite it as

  ```
  @article {Chen2024.12.03.626638,
  	author = {Chen, Yuhao and Zhang, Yan and Gan, Jiaqi and Ni, Ke and Chen, Ming and Bahar, Ivet and Xing, Jianhua},
  	year = {2024},
  	doi = {10.1101/2024.12.03.626638},
  	publisher = {Cold Spring Harbor Laboratory},
  	URL = {https://www.biorxiv.org/content/early/2024/12/07/2024.12.03.626638},
  	journal = {bioRxiv}
  }
  ```


pkgId: 1ba7bfd5ade5429c8ce9de538e81ec88cf768603f9cf0276a0bfe23f1d6b18e1
name: python-Grayven-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for Grayven
url: https://pypi.org/project/Grayven
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Grayven-0.1.0-1.src.rpm
location_href: Packages/python-Grayven-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Python](https://img.shields.io/pypi/pyversions/Grayven.svg?logo=Python&label=Python&style=flat-square)](https://pypi.python.org/pypi/Grayven/)
  [![PyPI - Status](https://img.shields.io/pypi/status/Grayven.svg?logo=Python&label=Status&style=flat-square)](https://pypi.python.org/pypi/Grayven/)
  [![PyPI - Version](https://img.shields.io/pypi/v/Grayven.svg?logo=Python&label=Version&style=flat-square)](https://pypi.python.org/pypi/Grayven/)
  [![PyPI - License](https://img.shields.io/pypi/l/Grayven.svg?logo=Python&label=License&style=flat-square)](https://opensource.org/licenses/MIT)

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-informational?logo=pre-commit&style=flat-square)](https://github.com/pre-commit/pre-commit)
  [![Ruff](https://img.shields.io/badge/ruff-enabled-informational?logo=ruff&style=flat-square)](https://github.com/astral-sh/ruff)

  [![Github - Contributors](https://img.shields.io/github/contributors/Buried-In-Code/Grayven.svg?logo=Github&label=Contributors&style=flat-square)](https://github.com/Buried-In-Code/Grayven/graphs/contributors)
  [![Github Action - Testing](https://img.shields.io/github/actions/workflow/status/Buried-In-Code/Grayven/testing.yaml?branch=main&logo=Github&label=Testing&style=flat-square)](https://github.com/Buried-In-Code/Grayven/actions/workflows/testing.yaml)
  [![Github Action - Publishing](https://img.shields.io/github/actions/workflow/status/Buried-In-Code/Grayven/publishing.yaml?branch=main&logo=Github&label=Publishing&style=flat-square)](https://github.com/Buried-In-Code/Grayven/actions/workflows/publishing.yaml)

  [![Read the Docs](https://img.shields.io/readthedocs/grayven?label=Read-the-Docs&logo=Read-the-Docs&style=flat-square)](https://grayven.readthedocs.io/en/stable)

  A [Python](https://www.python.org/) wrapper for the [Grand Comics Database API](https://github.com/GrandComicsDatabase/gcd-django/wiki/API).



  ```console
  pip install --user Grayven
  ```



  ```python
  from grayven.grand_comics_database import GrandComicsDatabase
  from grayven.sqlite_cache import SQLiteCache

  session = GrandComicsDatabase(cache=SQLiteCache())


  results = session.list_series(name="Green Lantern")
  for series in results:
      print(f"{series.id} | {series.name} ({series.year_began})")


  result = session.get_issue(id=242700)
  print(result.on_sale_date)
  ```



  - [Grayven](https://grayven.readthedocs.io/en/stable)
  - [GrandComicsDatabase API](https://github.com/GrandComicsDatabase/gcd-django/wiki/API)



  Please use the [GitHub issue tracker](https://github.com/Buried-In-Code/Grayven/issues) to submit bugs or request features.



  [![Social - Matrix](https://img.shields.io/matrix/metron-general:matrix.org?label=Metron%20General&logo=matrix&style=for-the-badge)](https://matrix.to/#/#metron-general:matrix.org)
  [![Social - Matrix](https://img.shields.io/matrix/metron-devel:matrix.org?label=Metron%20Development&logo=matrix&style=for-the-badge)](https://matrix.to/#/#metron-development:matrix.org)


pkgId: 9b8dfb6b99938f7ad9e20b5f175a3c0b7068c5cca31ce7e269e728a62a50fff9
name: python-Grid2Op-help
arch: noarch
version: 1.10.5
epoch: 0
release: 1
summary: Development documents and examples for Grid2Op
url: https://github.com/Grid2Op/grid2op
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Grid2Op-1.10.5-1.src.rpm
location_href: Packages/python-Grid2Op-help-1.10.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/grid2op)](https://pepy.tech/project/grid2op)
  [![PyPi_Version](https://img.shields.io/pypi/v/grid2op.svg)](https://pypi.org/project/Grid2Op/)
  [![PyPi_Compat](https://img.shields.io/pypi/pyversions/grid2op.svg)](https://pypi.org/project/Grid2Op/)
  [![LICENSE](https://img.shields.io/pypi/l/grid2op.svg)](https://www.mozilla.org/en-US/MPL/2.0/)
  [![Documentation Status](https://readthedocs.org/projects/grid2op/badge/?version=latest)](https://grid2op.readthedocs.io/en/latest/?badge=latest)
  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/Grid2op/grid2op/tree/master.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/Grid2op/grid2op/tree/master)
  [![discord](https://discord.com/api/guilds/698080905209577513/embed.png)](https://discord.gg/cYsYrPT)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/grid2op/grid2op.git/master)

  Grid2Op is a platform, built with modularity in mind, that allows to perform powergrid operation.
  And that's what it stands for: Grid To Operate.
  It is used as a library used for the Learning To Run Power Network [L2RPN](https://l2rpn.chalearn.org/),
  but also for research purpose (especially by the Reinforcement Learning community applied to power system)

  This framework allows to perform most kind of powergrid operations, from modifying the setpoint of generators,
  to load shedding, performing maintenance operations or modifying the *topology* of a powergrid
  to solve security issues.

  Official documentation: the official documentation is available at
  [https://grid2op.readthedocs.io/](https://grid2op.readthedocs.io/).

  * [1 Installation](#installation)
    * [1.1 Setup a Virtualenv (optional)](#setup-a-virtualenv-optional)
    * [1.2 Install from source](#install-from-source)
    * [1.3 Install from PyPI](#install-from-pypi)
    * [1.4 Install for contributors](#install-for-contributors)
    * [1.5 Docker](#docker)
  * [2 Main features of Grid2Op](#main-features-of-grid2op)
  * [3 Getting Started](#getting-started)
    * [0 Basic features](getting_started/0_basic_functionalities.ipynb)
    * [1 BaseObservation Agents](getting_started/1_Observation_Agents.ipynb)
    * [2 BaseAction Grid Manipulation](getting_started/2_Action_GridManipulation.ipynb)
    * [3 Training An BaseAgent](getting_started/3_TrainingAnAgent.ipynb)
    * [4 Study Your BaseAgent](getting_started/4_StudyYourAgent.ipynb)
  * [4 Citing](#citing)
  * [5 Documentation](#documentation)
  * [6 Contribute](#contributing)
  * [7 Test and known issues](#tests-and-known-issues)
  * [8 License information](#license-information)





  * Python >= 3.6





  ```commandline
  cd my-project-folder
  pip3 install -U virtualenv
  python3 -m virtualenv venv_grid2op
  ```



  ```commandline
  source venv_grid2op/bin/activate
  ```



  ```commandline
  pip3 install grid2op
  ```



  ```commandline
  git clone https://github.com/grid2op/Grid2Op.git
  cd Grid2Op
  pip3 install -U .
  cd ..
  ```



  ```commandline
  git clone https://github.com/grid2op/Grid2Op.git
  cd Grid2Op
  pip3 install -e .
  pip3 install -e .[optional]
  pip3 install -e .[docs]
  ```



  Grid2Op docker containers are available on [dockerhub](https://hub.docker.com/r/bdonnot/grid2op/tags).

  To install the latest Grid2Op container locally, use the following:

  ```commandline
  docker pull bdonnot/grid2op:latest
  ```





  Built with modulartiy in mind, Grid2Op is a library used for the "Learning To Run Power Network" [L2RPN](https://l2rpn.chalearn.org/)
  competitions series. It can also

  Its main features are:

  * emulates the behavior of a powergrid of any size at any format (provided that a *backend* is properly implemented)
  * allows for grid modifications (active and reactive load values, generator voltages setpoints, active production but most
    importantly grid topology beyond powerline connection / disconnection)
  * allows for maintenance operations and powergrid topological changes
  * can adopt any powergrid modeling, especially Alternating Current (AC) and Direct Current (DC) approximation to
    when performing the compitations
  * supports changes of powerflow solvers, actions, observations to better suit any need in performing power system operations modeling
  * has an RL-focused interface, compatible with [OpenAI-gym](https://gym.openai.com/): same interface for the
    Environment class.
  * parameters, game rules or type of actions are perfectly parametrizable
  * can adapt to any kind of input data, in various format (might require the rewriting of a class)



  Grid2Op relies on an open source powerflow solver ([PandaPower](https://www.pandapower.org/)),
  but is also compatible with other *Backend*. If you have at your disposal another powerflow solver,
  the documentation of [grid2op/Backend](grid2op/Backend/Backend.py) can help you integrate it into a proper "Backend"
  and have Grid2Op using this powerflow instead of PandaPower.



  Some Jupyter notebook are provided as tutorials for the Grid2Op package. They are located in the
  [getting_started](getting_started) directories.

  TODO: this needs to be redone, refactorize and better explained for some of them.

  These notebooks will help you in understanding how this framework is used and cover the most
  interesting part of this framework:

  * [00_Introduction](getting_started/00_Introduction.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/00_Introduction.ipynb)
    and [00_SmallExample](getting_started/00_SmallExample.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/00_SmallExample.ipynb)
    describe what is
    adressed by the grid2op framework (with a tiny introductions to both power systems and reinforcement learning)
    and give and introductory example to a small powergrid manipulation.
  * [01_Grid2opFramework](getting_started/01_Grid2opFramework.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/01_Grid2opFramework.ipynb)
    covers the basics
    of the
    Grid2Op framework. It also covers how to create a valid environment and how to use the
    `Runner` class to assess how well an agent is performing rapidly.
  * [02_Observation](getting_started/02_Observation.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/02_Observation.ipynb)
    details how to create
    an "expert agent" that will take pre defined actions based on the observation it gets from
    the environment. This Notebook also covers the functioning of the BaseObservation class.
  * [03_Action](getting_started/03_Action.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/03_Action.ipynb)
    demonstrates
    how to use the BaseAction class and how to manipulate the powergrid.
  * [04_TrainingAnAgent](getting_started/04_TrainingAnAgent.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/04_TrainingAnAgent.ipynb)
    shows how to get started with
    reinforcement learning with the grid2op environment. It shows the basic on how to train a "PPO" model operating the grid relying on "stable baselines 3" PPO implementation.
  * [05_StudyYourAgent](getting_started/05_StudyYourAgent.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/05_StudyYourAgent.ipynb)
    shows how to study an BaseAgent, for example
    the methods to reload a saved experiment, or to plot the powergrid given an observation for
    example. This is an introductory notebook. More user friendly graphical interface should
    come soon.
  * [06_Redispatching_Curtailment](getting_started/06_Redispatching_Curtailment.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/06_Redispatching_Curtailment.ipynb)
    explains what is the
    "redispatching" and curtailment from the point
    of view of a company who's in charge of keeping the powergrid safe (aka a Transmission System Operator) and how to
    manipulate this concept in grid2op. Redispatching (and curtailment) allows you to perform **continuous**
    actions on the powergrid
    problem.
  * [07_MultiEnv](getting_started/07_MultiEnv.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/07_MultiEnv.ipynb)
    details how grid2op natively support a single agent interacting
    with multiple environments at the same time. This is particularly handy to train "asynchronous" agent in the
    Reinforcement Learning community for example.
  * [08_PlottingCapabilities](getting_started/08_PlottingCapabilities.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/08_PlottingCapabilities.ipynb)
    shows you the different ways with which you
    can represent (visually) the grid your agent interact with. A renderer is available like in many open AI gym
    environment. But you also have the possibility to post process an agent and make some movies out of it, and we also
    developed a Graphical User Interface (GUI) called "[grid2viz](https://github.com/mjothy/grid2viz)" that allows
    to perform in depth study of your agent's behaviour on different scenarios and even to compare it with baselines.
  * [09_EnvironmentModifications](getting_started/09_EnvironmentModifications.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/09_EnvironmentModifications.ipynb)
    elaborates on the maintenance,
    hazards
    and attacks. All three of these represents external events that can disconnect some powerlines. This notebook
    covers how to spot when such things happened and what can be done when the maintenance or the attack is over.
  * [10_StorageUnits](getting_started/10_StorageUnits.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/10_StorageUnits.ipynb)
    details the usage and behaviour of the storage units
    in grid2op.
  * [11_IntegrationWithExistingRLFrameworks](getting_started/11_IntegrationWithExistingRLFrameworks.ipynb)
    [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Grid2Op/grid2op/blob/master/getting_started/11_IntegrationWithExistingRLFrameworks.ipynb)
    explains how to use grid2op with other reinforcement learning framework. TODO: this needs to be redone

  Try them out in your own browser without installing
  anything with the help of mybinder:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Grid2Op/grid2op/master)

  Or thanks to google colab (all links are provided near the notebook description)



  If you use this package in one of your work, please cite:

  ```text
  @software{grid2op,
      author = {B. Donnot},
      title = {{Grid2op- A testbed platform to model sequential decision making in power systems. }},
      url = {\url{https://GitHub.com/Grid2Op/grid2op}},
      year = {2020},
      publisher = {GitHub},
  }
  ```



  The official documentation is available at
  [https://grid2op.readthedocs.io/](https://grid2op.readthedocs.io/).



  A copy of the documentation can be built if the project is installed *from source*:
  you will need Sphinx, a Documentation building tool, and a nice-looking custom
  [Sphinx theme similar to the one of readthedocs.io](https://sphinx-rtd-theme.readthedocs.io/en/latest/). These
  can be installed with:

  ```commandline
  pip3 install -U grid2op[docs]
  ```

  This installs both the Sphinx package and the custom template.

  Then, on systems where `make` is available (mainly gnu-linux and macos) the documentation can be built with the command:

  ```commandline
  make html
  ```

  For windows, or systems where `make` is not available, the command:

  ```commandline
  sphinx-build -b html docs documentation
  ```

  This will create a "documentation" subdirectory and the main entry point of the document will be located at
  [index.html](documentation/html/index.html).

  It is recommended to build this documentation locally, for convenience.
  For example, the  "getting started" notebooks referenced some pages of the help.

  <!-- sphinx-build -b html docs documentation-->



  Please consult the "CONTRIBUTING.md" file for extra information. This is a summary and
  in case of conflicting instructions, follow the one given in the `CONTRIBUTING.md` file
  and discard these ones.


  We welcome contributions from everyone. They can take the form of pull requests for smaller changed.
  In case of a major change (or if you have a doubt on what is "a small change"), please open an issue first
  to discuss what you would like to change.

  To contribute to this code, you need to:

  1. fork the repository located at <https://github.com/Grid2Op/grid2op>
  2. synch your fork with the "latest developement branch of grid2op". For example, if the latest grid2op release
     on pypi is `1.6.5` you need to synch your repo with the branch named `dev_1.6.6` or `dev_1.7.0` (if
     the branch `dev_1.6.6` does not exist). It will be the highest number in the branches `dev_*` on
     grid2op official github repository.
  3. implement your functionality / code your modifications or anything else
  4. make sure to add tests and documentation if applicable
  5. once it is developed, synch your repo with the last development branch again (see point 2 above) and
     make sure to solve any possible conflicts
  6. write a pull request and make sure to target the right branch (the "last development branch")

  Code in the contribution should pass all the tests, have some dedicated tests for the new feature (if applicable)
  and documentation (if applicable).

  Before implementing any major feature, please write a github issue first.





  Grid2op is currently tested on windows, linux and macos.

  The unit tests includes testing, on linux machines the correct integration of grid2op with:

  * python 3.8
  * python 3.9
  * python 3.10
  * python 3.11
  * python 3.12

  On all of these cases, we tested grid2op on all available numpy versions >= 1.20 (**nb** available numpy versions depend
  on python version).

  The complete test suit is run on linux with the latest numpy version on python 3.10.





  Due to the underlying behaviour of the "multiprocessing" package on windows based python versions,
  the "multiprocessing" of the grid2op "Runner" is not supported on windows. This might change in the future,
  but it is currently not on our priorities.

  A quick fix that is known to work include to set the `experimental_read_from_local_dir` when creating the
  environment with `grid2op.make(..., experimental_read_from_local_dir=True)` (see doc for more information)

  Sometimes, on some configuration (python version) we do not recommend to use grid2op with pandas>=2.2
  If you encounter any trouble, please downgrade to pandas<2.2. This behaviour occured in our continuous
  integration environment for python >=3.9 but could not be reproduced locally.


  Some version of grid2op (*eg* 1.6.3) are not compatible with python 3.10 or 3.11.

  Either use python version 3.8 or 3.9 or upgrade grid2op (1.6.5 works) if that is the case.



  Provided that Grid2Op is installed *from source*:



  ```commandline
  pip3 install -U grid2op[optional]
  ```



  ```commandline
  cd grid2op/tests
  python3 -m unittest discover
  ```



  Copyright 2019-2020 RTE France
  RTE: <http://www.rte-france.com>

  This Source Code is subject to the terms of the Mozilla Public License (MPL) v2 also available
  [here](https://www.mozilla.org/en-US/MPL/2.0/)


pkgId: 2e6e874e6cd9f2d9ecb1d4077c8ceac0bbfb35326892cfa16cde8eb5e15f286d
name: python-GridCal-help
arch: noarch
version: 5.2.10
epoch: 0
release: 1
summary: Development documents and examples for GridCal
url: https://github.com/SanPen/GridCal
rpm_license: MPL2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GridCal-5.2.10-1.src.rpm
location_href: Packages/python-GridCal-help-5.2.10-1.noarch.rpm
checksum_type: sha256
description:
  This software aims to be a complete platform for power systems research and simulation.)

  [Watch the video https](https://youtu.be/SY66WgLGo54)
  [Check out the documentation](https://gridcal.readthedocs.io)



  pip install GridCal

  For more options (including a standalone setup one), follow the
  [installation instructions]( https://gridcal.readthedocs.io/en/latest/getting_started/install.html)
  from the project's [documentation](https://gridcal.readthedocs.io)


pkgId: a8f2c0a63dd77e1638228df6ba0ca3fcd7fac5c38dfc275d54e9a5311264cd22
name: python-HNLimits-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for HNLimits
url: https://github.com/mhostert/heavy-neutrino-limits
rpm_license: "MIT"
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-HNLimits-1.2.0-1.src.rpm
location_href: Packages/python-HNLimits-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  **Citation info:**
  ``arxiv.org/abs/2304.06772``
  ```
  @article{Fernandez-Martinez:2023phj,
      author = "Fern\'andez-Mart\'\i{}nez, Enrique and Gonz\'alez-L\'opez, Manuel and Hern\'andez-Garc\'\i{}a, Josu and Hostert, Matheus and L\'opez-Pav\'on, Jacobo",
      title = "{Effective portals to heavy neutral leptons}",
      eprint = "2304.06772",
      archivePrefix = "arXiv",
      primaryClass = "hep-ph",
      reportNumber = "FTUV-23-0303.1224, IFIC/23-09",
      doi = "10.1007/JHEP09(2023)001",
      journal = "JHEP",
      volume = "09",
      pages = "001",
      year = "2023"
  }


pkgId: 2af96629622b0ee8201603123b0dd131d0a1bf24bc516587517fde95b942f3fc
name: python-Heron-42ad-help
arch: noarch
version: 0.8.3
epoch: 0
release: 1
summary: Development documents and examples for Heron-42ad
url: https://github.com/Heron-Repositories/Heron/tree/main
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Heron-42ad-0.8.3-1.src.rpm
location_href: Packages/python-Heron-42ad-help-0.8.3-1.noarch.rpm
checksum_type: sha256
description:
  Heron is an open source software conceived as an experiment (and general data) pipeline implementation tool. It allows users to realise their conceptual experimental designs such that the final result, i.e. the implementation running the experiment, visually and structurally bears a significant resemblance to its mental schema, i.e. the idea of the experiment in the experimenter’s imagination.

  Heron combines a Node based experiment designer with a Python API allowing users to quicly construct and add their own Nodes. It fully obfuscates the Node communication from the user and offers seamless communication between separate machines running different operating systems.

  A more thorough description of both why Heron exists in the first place and some info on how to use it can be found in [this document](https://medium.com/@gdimitri/heron-a-hybrid-approach-to-data-pipelines-in-python-aa7719fe8f2e).

  The manual is [here](https://heron-42ad.readthedocs.io/en/latest/index.html).



  A summer 2022 talk at the Sainsbury Wellcome Centre introducing Heron:
  https://www.youtube.com/watch?v=o6Pz-1uaJjY

  A quick overview of using Heron through an example of putting together a pipeline involving Single Board Computers, Deep Convolutional Networks and a game of Snake.
  https://www.youtube.com/watch?v=dRXeFBYG50Q



  Heron is a Python only graphical editor designed to initiate, connect and orchestrate multiple processes, passing data between each other, potentially running on multiple computers. Each process is graphically represented as a node with inputs and outputs. Connecting an output of one process to the input of another will result in the data generated by the output process to be passed to the input one, subsequently triggering the input processes functionality.

  Heron has originally been conceptualised as a framework to allow modular and fast experimental setup. It is designed to connect multiple pieces of hardware with analysis and data collection code in a versatile / experiment specific matter. Its main goal is to abstract away the need to pass data through the different parts of a pipeline with specific data collection and on the fly analysis requirements, an effort which more often than not, results in single use, spaghetti code.

  Heron is not another visual programming language. It is just a graphical abstraction of the way individual pieces of code, each running in its own process, communicate with each other in an experimental pipeline. The code that does the actual work is Python code and the user is expected to construct their own pieces of code (that can be trivially wrapped into the code necessary to have them represented as Heron nodes).

  Here is an example of the Heron editor running a simple pipeline


  ![Heron at work](https://github.com/Heron-Repositories/Heron/assets/12892531/8c5f15cd-f77b-4263-87e2-30e4e6b8c5f0)


  More information on the parts of the Heron editor and its use see the Use paragraph.




  One way is pip:

  ```
  python -m pip install heron-42ad
  ```

  Yet, Heron does not require any type of installation. One can just download the repo, put it somewhere and then run the editor.py script found in the Heron/Heron/gui folder.

  Important note. The whole of the Heron repo must be found in all the computers that run nodes in a pipeline. The editor will only run in one of the computers but the whole repo needs to be present in all computers (since this defines Heron's communication protocol). Any code that runs in a machine separate to the computer running the editor must be part of the Heron directory structure wrapped appropriately in the code that creates the Heron nodes.

  The Heron repository comes installed with a small number of Nodes that are generic enough to be useful to most users. This set will over time increase. Yet, for more specialised Nodes Heron allows users to create in Heron's folder structure symbolic links to any directory on their hard disks that has a set of Heron Nodes. For a user to do this they will either have to create their own Nodes or download from an online repository hub (e.g. GitHub) a set of Nodes. To begin with look into https://github.com/Heron-Repositories. Once the code for one or more Nodes is on a user's hard disk then one should access the Operations button on the toolbar, press Add a new Operations Folder (as Symbolic Link from Existing Repo) button and navigate to the folder that carries the Sources, Transforms and/or Sinks folders inside of which the new Nodes exist. That will create a symbolic link of the correct directory strucre inside Heron's folder structure and Heron will from that point on be able to use the new Nodes. If one wants to remove the Nodes all they have to do is delete the symbolic link from Heron's Operations/XXX directory (where XXX = Sources or Transforms or Sinks). That will not affect the actual repository of the new Nodes.



  The library requirements of Heron are:

  python >=3.11

  pyzmq >= 22.x

  numpy

  pandas

  dearpygui >= 1.2

  paramiko

  tornado

  psutil

  pyinput

  pyserial

  h5py

  Unfortunately the in-Node visualisation capabilities and a good few Nodes (Visualiser, Cameras, OpenCV filters) repy on opencv = 4.x (3.x should work but not tested). Sorry about that! In the future there will be an effort to remove basic dependency on opencv but for now, it is what it is.
  At the time of writting (Feb. 2022) conda will not install opencv for python > 3.8, so if you are using python 3.11 or newer you have to install opencv through pip.

  If you use conda then dearpygui has to also be installed by pip (no conda packages yet).

  So once you have a conda environment up and running (and you have added the conda-forge channel to your config as mentioned here https://ostechnix.com/enable-conda-forge-channel-for-conda-package-manager/) and you are in the environment in your command prompt you need to do the following:
  ```
  conda install numpy
  conda install pandas
  conda install tornado
  conda install pyzmq
  conda install paramiko
  conda install psutil

  pip install dearpygui
  pip install opencv-python
  ```

  To test that everything works start Heron. That is done by running
  ```python folder_of_Heron/Heron/gui/editor.py```

  Other libraries, which are used in specific Nodes only, can be installed as needs be. One can check the import statements of the Worker scripts of the specific Operations to see what libraries they import.

  For optional libraries that are called by often used Nodes do
  ```
  conda install scipy
  conda install h5py
  conda install pynput
  conda install pyserial
  ```



  The left hand side table in the editor is a list of all available nodes. The user clicks on the ones they need and then proceeds to connect the outputs to the inputs and sets up the parameters values. Once this is done, the user starts the Graph that has been generated. The result is the initialisation of a series of processes (double the number of nodes plus one) which then pass data between them as the connectivity of their nodes prescribes.

  There are three types of nodes:

  The Source nodes which are meant to bring data from the outside world into the pipeline. Examples of these are cameras, microphones, data acquisition devices and in general any type of hardware that will generate data. For example, in the pipeline shown above, there is a single Source node live capturing camera frames. Source nodes have only outputs.

  Then there are the Transform nodes which grab data from one of their inputs, transform it and then pass it to their output. Heron supports both one output to one input and one output to many inputs connectivity. It also supports Nodes with multiple inputs and multiple outputs. In the above example, each captured frame is passed through a canny filter.

  Finally there are Sink nodes which only have inputs and which are meant as final saving points for the data. In the above example this is the Save FFMPEG video which takes the canny transformed frame and adds it to a video file (through running ffmpeg).

  In the future there will be Kernel nodes with no inputs or outputs (self sufficient processes that do stuff without requiring input or generating output).

  ![Alt - text](https://github.com/georgedimitriadis/large_gifs_for_other_repos/blob/main/Heron_GIF_MidRes_5FPS.gif)


  The below picture gives the overview of the communication protocol Heron uses.

  ![Heron-data-diagram](https://user-images.githubusercontent.com/12892531/124312326-065ffb00-db67-11eb-9fe5-9ed214d6d930.png)


pkgId: 5ed6d4014ad0d584376db22fb2011dab113aba50fe3e749b0ed0babb9638ebd8
name: python-ICIW-Plots-help
arch: noarch
version: 1.0.41
epoch: 0
release: 1
summary: Development documents and examples for ICIW-Plots
url: https://pypi.org/project/ICIW-Plots/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ICIW-Plots-1.0.41-1.src.rpm
location_href: Packages/python-ICIW-Plots-help-1.0.41-1.noarch.rpm
checksum_type: sha256
description:
  Install the package by running the following command:

  ```bash
  pip install iciw-plots
  ```

  or

  ```bash
  pip install iciw-plots -U
  ```



  Although I show the usage of the package in the context of a Jupyter notebook, the package can be used in any Python environment.
  Also, the style has to be used only once, at the beginning of the plotting file or notebook.
  **In this document I write it in nearly every box just to show th use. This is not necessary!**


  The default style defines convenient presets for the following settings:
  - Font size
  - Font family
  - Line width
  - Marker size
  - Color palette
  - Grid style
  - Legend style


  ```python
  import matplotlib.pyplot as plt
  import numpy as np

  plt.style.use("ICIWstyle")

  x = np.linspace(0, 2 * np.pi, 100)

  for i in range(7):
      plt.plot(x, np.sin(x + (i * (4 * np.pi / 7))), label=f"Line {i}")

  plt.legend()
  plt.show()
  ```



  ![png](examples/examples_files/examples_3_0.png)



  In addition to the default style, the package also provides different styles to be loaded additionally.
  These can be used to
  - enable rendering of texts in LaTeX format by using `ICIWlatex`
  - disable the background when exporting the plot by using `ICIWnobg`

  The latex style automatically imports the LaTex packages `amsmath`, `amssymb`, `siunitx` and `mchem` enabling the use of all latex math commands, SI unit rendering and chemical formulas.

  Note, How I use the style only temporarily with the contextmanager.



  ```python
  import matplotlib.pyplot as plt

  plt.style.use("ICIWstyle")

  x = np.linspace(0, 2 * np.pi, 100)

  with plt.style.context(
      "ICIWlatex", after_reset=False
  ):  # use the latex style only for this plot
      for i in range(7):
          plt.plot(x, np.sin(x + (i * (4 * np.pi / 7))))

      plt.xlabel(r"$t$ / \unit{\second}")  # use latex formulae and a unit
      plt.ylabel(r"$c$ / \unit{\mole\per\metre\cubed}")
      plt.legend(
          [
              r"\ce{A}",  # use chemistry symbols
              r"\ce{B}",
              r"\ce{AB}",
              r"\ce{AB2}",
              r"\ce{A2B}",
              r"\ce{C2+}",
          ]
      )

      plt.show()
  ```



  ![png](examples/examples_files/examples_5_0.png)





  The package provides default size options for the following publishers:
  - ACS
  - Elsevier

  To make conversion between default matplotlib units (inches) and european units (cm) easier, the package provides the following conversion factors:
  - `cm2inch`
  - `mm2inch`


  ```python
  from ICIW_Plots.figures import Elsevier_Sizes, ACS_Sizes
  from ICIW_Plots import cm2inch

  print(
      f"Width for Elsevier default single column wide plots:\n{Elsevier_Sizes.single_column}"
  )
  print(
      f"Width for Elsevier default double column wide plots:\n{Elsevier_Sizes.double_column}"
  )
  print(
      f"width for Elsevier defaultone and a half column wide plots:\n{Elsevier_Sizes.threehalf_column}"
  )

  print(f"Width for ACS default single column wide plots:\n{ACS_Sizes.single_column}")
  print(f"Width for ACS default double column wide plots:\n{ACS_Sizes.double_column}")

  fig = plt.figure(figsize=(Elsevier_Sizes.single_column["in"], 5 * cm2inch))
  ax = fig.add_axes([0, 0, 1, 1])
  plt.show()
  ```

      Width for Elsevier default single column wide plots:
      {'mm': 90, 'in': 3.54, 'cm': 9}
      Width for Elsevier default double column wide plots:
      {'mm': 190, 'in': 7.48, 'cm': 19}
      width for Elsevier defaultone and a half column wide plots:
      {'mm': 140, 'in': 5.51, 'cm': 14}
      Width for ACS default single column wide plots:
      {'mm': 82.55, 'in': 3.25, 'cm': 8.255}
      Width for ACS default double column wide plots:
      {'mm': 177.8, 'in': 7, 'cm': 17.78}




  ![png](examples/examples_files/examples_7_1.png)




  Oftentimes, I like to create square axis with a fixed width in the middle of a figure with fixed width. `matplotlib` makes this hard for the user. `ICIW-Plots` provides functions `make_square_ax`, `make_rect_ax` and `make_square_subplots` that do this for you.


  ```python
  plt.style.use("ICIWstyle")
  from ICIW_Plots.figures import Elsevier_Sizes
  from ICIW_Plots import make_square_ax

  fig = plt.figure(figsize=(Elsevier_Sizes.single_column["in"], 7 * cm2inch))
  ax = make_square_ax(
      fig,
      ax_width=5 * cm2inch,
  )
  ax.plot(x, np.sin(x))
  plt.show()
  ```

      c:\ProgramData\Anaconda3\envs\ML3\Lib\site-packages\ICIW_Plots\layout.py:77: UserWarning: Unscientific behavior. No xlabel provided.
        warnings.warn("Unscientific behavior. No xlabel provided.")
      c:\ProgramData\Anaconda3\envs\ML3\Lib\site-packages\ICIW_Plots\layout.py:82: UserWarning: Unscientific behavior. No ylabel provided.
        warnings.warn("Unscientific behavior. No ylabel provided.")




  ![png](examples/examples_files/examples_9_1.png)



  As you can see, you even get a warning when you misbehave. Both functions take some arguments you can inspect via the mouseover in your IDE. Note, that the `kwargs` argument takes any argument, a normal `plt.add_axes` function would take. Here is just an example of what you can do although it is unreasonable to do so:


  ```python
  from ICIW_Plots.figures import Elsevier_Sizes
  from ICIW_Plots import make_square_ax

  plt.style.use("ICIWstyle")

  fig = plt.figure(figsize=(Elsevier_Sizes.single_column["in"], 7 * cm2inch))
  ax = make_square_ax(
      fig,
      ax_width=5 * cm2inch,
      
      
      xlabel=r"$t$ / s",
      ylabel=r"$U$ / V",
      title="This is a title",
      xscale="log",
  )
  ax.plot(x, np.sin(x))
  plt.show()
  ```



  ![png](examples/examples_files/examples_11_0.png)




  ```python
  import matplotlib.pyplot as plt
  from ICIW_Plots import make_rect_ax

  plt.style.use("ICIWstyle")

  fig = plt.figure()

  ax = make_rect_ax(
      fig,
      ax_width=7.3 * cm2inch,
      ax_height=5 * cm2inch,
      
      
      xlabel=r"$t$ / s",
      ylabel=r"$U$ / V",
      title="This is a title",
      xscale="log",
  )

  ax.plot(x, np.sin(x))

  plt.show()
  ```



  ![png](examples/examples_files/examples_12_0.png)



  The `make_square_subplot` command behaves slightly different whether you want the x- or y- axes to be shared and which labels you provide. The docstring sys there are the following options:

  >**sharex, sharey : bool, optional**
  >
  >&emsp; whether axes on top of or next to eachother share one x or y axes, by default `False`
  >
  >**sharelabel : bool, optional**
  >
  >&emsp;whether to share the labels of the shared axes, by default `False`
  >
  >**xlabel, ylabel : Optional[str | npt.ArrayLike], optional**
  >
  >&emsp;label or labels for the axes. Can be one of the following:
  >* `None` - no label
  >* a single `str` - every subplot will get the same x/y label
  >* a 1D `npt.ArrayLike` - every column/row will get the same x/y label
  >* a 2D `npt.ArrayLike` - every subplot will get its own x/y label
  >
  >&emsp;If `sharex` or `sharey` is `True`, only the last row/column (the shared axis) will get the label.
  >By default None


  ```python
  import matplotlib.pyplot as plt
  from ICIW_Plots import make_square_subplots

  plt.style.use("ICIWstyle")

  fig = plt.figure()
  axs = make_square_subplots(
      fig=fig,
      ax_width=3 * cm2inch,
      ax_layout=(2, 3),
      h_sep=1.5 * cm2inch,
      v_sep=1 * cm2inch,
      sharex=True,  # share the axis
      sharey=True,  # share the axis
      sharelabel=False,
      xlabel="$x$",  # every x axis has the same label
      ylabel=["$y_1$", "$y_2$"],  # every y axis along the rows has the same label
  )
  ```



  ![png](examples/examples_files/examples_14_0.png)




  ```python
  fig = plt.figure()
  axs = make_square_subplots(
      fig=fig,
      ax_width=3 * cm2inch,
      ax_layout=(2, 3),
      h_sep=1.5 * cm2inch,
      v_sep=1 * cm2inch,
      sharex=True,  # share the axis
      sharey=True,  # share the axis
      sharelabel=True,  # ticklabels are not repeated for shared axis
      xlabel="$x$",  # every x axis has the same label
      ylabel=["$y_1$", "$y_2$"],  # every y axis along the rows has the same label
  )
  ```



  ![png](examples/examples_files/examples_15_0.png)




  ```python
  fig = plt.figure()
  axs = make_square_subplots(
      fig=fig,
      ax_width=3 * cm2inch,
      ax_layout=(2, 3),
      h_sep=1.5 * cm2inch,
      v_sep=1 * cm2inch,
      sharex=False,  # because we do not share the axis, every axis is labeled
      sharey=False,  # because we do not share the axis, every axis is labeled
      xlabel="x",  # every x axis has the same label
      ylabel=["$y_1$", "$y_2$"],  # every y axis along the rows has the same label
  )
  ```



  ![png](examples/examples_files/examples_16_0.png)




  ```python
  fig = plt.figure()
  axs = make_square_subplots(
      fig=fig,
      ax_width=3 * cm2inch,
      ax_layout=(2, 3),
      h_sep=1.5 * cm2inch,
      v_sep=1 * cm2inch,
      sharex=True,
      sharey=False,
      xlabel=[
          "$x_1$",
          "$x_2$",
          "$x_3$",
      ],  # every x axis along one column has the same label. Because it is shared, they do not repeat.
      ylabel=[
          ["$y_1$", "$y_2$", "$y_3$"],
          ["$y_4$", "$y_5$", "$y_6$"],
      ],  # every y axis was given its own label. Only recommended for non-shared axes
  )
  ```




  ![png](examples/examples_files/examples_17_1.png)




  ```python
  fig = plt.figure()
  axs = make_square_subplots(
      fig=fig,
      ax_width=3 * cm2inch,
      ax_layout=(2, 3),
      h_sep=1.5 * cm2inch,
      v_sep=1 * cm2inch,
      sharex=False,  # because we do not share the axis, every axis is labeled
      sharey=False,  # because we do not share the axis, every axis is labeled
      xlabel="x",  # every x axis has the same label
      ylabel=["$y_1$", "$y_2$"],  # every y axis along the rows has the same label
  )
  ```



  ![png](examples/examples_files/examples_18_0.png)



  In jupyter notebooks the output appears cut to the "appropriate" size. In a python script, you will see the full figure with all the sizes and positions spaced correctly.



  `ICIW-Plots` defines the university colors.


  ```python
  import matplotlib.pyplot as plt
  import ICIW_Plots.colors as ICIWcolors

  plt.style.use("ICIWstyle")

  fig, ax = plt.subplots()

  ax.plot(x, np.sin(x), color=ICIWcolors.CRIMSON)
  ax.plot(x, np.cos(x), color=ICIWcolors.CERULEAN)
  ax.plot(x, np.log(x + 0.1), color=ICIWcolors.KELLYGREEN)
  ax.plot(x, np.tanh(x), color=ICIWcolors.FLAME)
  ax.plot(x, np.arcsinh(x), color=ICIWcolors.DRAB)

  plt.legend(["crimson", "cerulean", "kellygreen", "flame", "drab"])

  plt.show()
  ```



  ![png](examples/examples_files/examples_20_0.png)




  All university colors are available as colormaps as well.
  Here is just an example for the cerulean colormap:


  ```python
  import matplotlib.pyplot as plt
  import ICIW_Plots.colors as ICIWcolors

  plt.style.use("ICIWstyle")

  N = 100
  x = np.linspace(-3.0, 3.0, N)
  y = np.linspace(-2.0, 2.0, N)

  X, Y = np.meshgrid(x, y)
  Z1 = -(X**2) - Y**2
  Z2 = -((X * 10) ** 2) - (Y * 10) ** 2
  z = Z1 + 50 * Z2

  fig, ax = plt.subplots()

  cs = ax.contourf(X, Y, z, cmap=ICIWcolors.cerulean_cm, levels=10)
  cbar = fig.colorbar(cs)

  plt.show()
  ```



  ![png](examples/examples_files/examples_22_0.png)



  Additionally, `ICIW-Plots` provides a way to define "nice looking" colorschemes based on the theory of [adjacent or analogous colors](https://en.wikipedia.org/wiki/Analogous_colors). You can use any color as a base and generate an appealing color scheme this way.

  This works great for plots where line show an increase in, e.g. temperature.

  You can either create a list of these colors or use them as a cycler via the functions `adjacent_colors` or `adjacent_cycler` respectively. For cyclers see the later section.


  ```python
  import matplotlib.pyplot as plt
  import ICIW_Plots.colors as ICIWcolors

  colors = ICIWcolors.adjacent_colors(
      ICIWcolors.FLAME,  # any valid color as an array of three values [R,G,B], here, one of our own university colors
      n=5,  # the number of adjacent colors you want. Must be odd.
      phi=15,  # the "distance" of two adjacent colors. The smaller, the more similar.
  )
  print(colors)
  ```

      [(0.91015625, 0.02734375, 0.07031249999999899), (0.91015625, 0.20507812500000003, 0.02734375), (0.91015625, 0.42578125, 0.02734375), (0.91015625, 0.646484375, 0.02734375), (0.91015625, 0.8671875, 0.02734375)]




  The package defines some functionality to do your own cyclers. Supported are:
  - color cyclers from colormaps
    - all default matplotlib colormaps by name
    - all custom colormaps from `ICIW-Plots` by reference
  - line style cyclers
    - all default linestyles by abbreviation (`-`,`--`,`.-`,`:`)
    - every custom linestyle by a dash tuple (e.g., `(0,(3,10,1,15))`)
  - marker cyclers
    - all predefined markers by abbreviation (`o`,`s`,`^`,`v`,and so on)
    - every custom marker by a marker reference

  Custom color cyclers take a colormap and sample `num_plots` points from them equidistantly spaced. `start` and `stop` are used to prevent very light or very dark colors from being used. The `cycler` is then added as the axes `prop_cycle`.


  ```python
  import matplotlib.pyplot as plt
  import ICIW_Plots.cyclers as ICIW_cyclers

  fig, ax = plt.subplots()
  x = np.linspace(-2 * np.pi, 2 * np.pi)
  my_green_cycler = ICIW_cyclers.ICIW_colormap_cycler(
      "Greens",
      7,
      start=0.2,
  )
  ax.set_prop_cycle(my_green_cycler)
  for i in range(7):
      ax.plot(x, np.sin(x + (i * (4 * np.pi / 7))))
  plt.show()
  ```



  ![png](examples/examples_files/examples_26_0.png)




  ```python
  import matplotlib.pyplot as plt
  import ICIW_Plots.cyclers as ICIW_cyclers

  fig, ax = plt.subplots()

  my_blue_cycler = ICIW_cyclers.ICIW_colormap_cycler(
      ICIWcolors.cerulean_cm,
      7,
      start=0.1,
  )
  ax.set_prop_cycle(my_blue_cycler)
  for i in range(7):
      ax.plot(x, np.sin(x + (i * (4 * np.pi / 7))))
  plt.show()
  ```



  ![png](examples/examples_files/examples_27_0.png)




  ```python
  import matplotlib.pyplot as plt
  import ICIW_Plots.colors as ICIWcolors

  adjacent_cyc = ICIWcolors.adjacent_cycler(
      np.array([224, 58, 91])
      / 256,  # any valid color as an array of three values [R,G,B], here, an arbitrary color.
      n=5,
      phi=25,
  )

  fig, ax = plt.subplots()
  ax.set_prop_cycle(adjacent_cyc)

  T = np.linspace(400, 500, 100)
  E_As = np.linspace(60000, 70000, 5)

  for E_A in E_As:
      ax.plot(T, 1e7 * np.exp(-E_A / 8.314 / T), label=f"$E_A$= {E_A}")

  ax.set(xlabel="$T$", ylabel="$r$")

  plt.legend()
  plt.show()
  ```



  ![png](examples/examples_files/examples_28_0.png)




  Custom linestyle cyclers take a list of linestyles and a number of plots to cycle through. The `cycler` is then added as the axes `prop_cycle`.


  ```python
  my_linestyle_cycler = ICIW_cyclers.ICIW_linestyle_cycler(3)

  fig, ax = plt.subplots()

  ax.set_prop_cycle(my_linestyle_cycler)
  for j in range(3):
      ax.plot(x, x + j * 5)
  ```



  ![png](examples/examples_files/examples_30_0.png)



  Note, that all lines have the same color, since matplotlib by default cycles through its default cycler containing the colors. By overwriting the default cycler by our linestyle cycler, all lines will have the same color.

  We can combine different cyclers together by either
  - inner product (pairwise combinations)
  - outer product (unique combinations)


  ```python
  fig, axs = plt.subplots(1, 2)

  custom_c_cycler = ICIW_cyclers.ICIW_colormap_cycler("Greens", 3, start=0.5)
  custom_l_cycler = ICIW_cyclers.ICIW_linestyle_cycler(3)

  axs[0].set_title("Inner Product")


  axs[0].set_prop_cycle(custom_c_cycler + custom_l_cycler)
  for i in range(3):
      axs[0].plot(x, np.sin(x + (i * (4 * np.pi / 5))))

  axs[1].set_title("Outer Product")


  axs[1].set_prop_cycle(custom_c_cycler * custom_l_cycler)
  for i in range(3):
      for j in range(3):
          axs[1].plot(x, i * x + j * 5)
  ```



  ![png](examples/examples_files/examples_32_0.png)


pkgId: 488ad506d3e2b5305880f854b64822fa555bfd6f9a04263c5f6e2e3d843c82e5
name: python-IMDBTraktSyncer-help
arch: noarch
version: 2.9.5
epoch: 0
release: 1
summary: Development documents and examples for IMDBTraktSyncer
url: https://github.com/RileyXX/IMDB-Trakt-Syncer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-IMDBTraktSyncer-2.9.5-1.src.rpm
location_href: Packages/python-IMDBTraktSyncer-help-2.9.5-1.noarch.rpm
checksum_type: sha256
description:
  This Python script syncs user watchlist, ratings and reviews for Movies, TV Shows and Episodes both ways between [Trakt](https://trakt.tv/) and [IMDB](https://imdb.com/). Existing items will not be overwritten. Ratings, watchlist and comment/review sync are all optional. The user will be prompted to enter their settings and credentials on first run.

  The script is compatible with operating systems that support Python (v3.6 or later) and Chromedriver (Windows, Linux and Mac). If you're interested in syncing ratings between Trakt, Plex, IMDB, and TMDB, I recommend the following projects: [PlexTraktSync](https://github.com/Taxel/PlexTraktSync), [IMDB-Trakt-Syncer](https://github.com/RileyXX/IMDB-Trakt-Syncer), and [TMDB-Trakt-Syncer](https://github.com/RileyXX/TMDB-Trakt-Syncer). See below for my other [recommended projects](https://github.com/RileyXX/IMDB-Trakt-Syncer?tab=readme-ov-file#other-recommended-projects).


  1. Install [Python](https://www.python.org/downloads/) (v3.6 or later) and [Google Chrome](https://www.google.com/chrome/). During Python installation, tick the box for adding Python to your PATH variable. _If these are already installed, you can skip this step. Please note this script does not affect Chrome in anyway, it is simply required in order for chromedriver to work._
  2. Install the script by executing `python -m pip install IMDBTraktSyncer` in command line.
  3. Login to [Trakt](https://trakt.tv/oauth/applications) and create a new API application named `IMDBTraktSyncer`. In the "Redirect uri" field, enter `urn:ietf:wg:oauth:2.0:oob`, then save the application.
  4. Run the script by executing `IMDBTraktSyncer` in the command line.
  5. Follow the prompts during the first run. You will need to enter your Trakt `client ID` and `client secret` from step 3, as well as your IMDB `username` and `password`. Please note that these details are saved insecurely as `credentials.txt` in the same folder as the script. It is recommended to change your IMDB password to something unique beforehand.
  6. Setup is complete. The script will continue running and syncing your ratings. You can monitor its progress in the command line. See below for [setting up automation](https://github.com/RileyXX/IMDB-Trakt-Syncer?tab=readme-ov-file#for-setting-up-automation-see-the-following-wiki-pages).


  ```
  python -m pip install IMDBTraktSyncer
  ```
  _Run in your operating system's native command line._

  ```
  IMDBTraktSyncer
  ```
  _Run in your operating system's native command line._

  ```
  python -m pip install IMDBTraktSyncer --upgrade
  ```
  _Run in your operating system's native command line._

  ```
  python -m pip uninstall IMDBTraktSyncer
  ```
  _Run in your operating system's native command line._


  ```
  python -m pip install IMDBTraktSyncer==VERSION_NUMBER
  ```
  _Replace `VERSION_NUMBER` with your [desired version](https://github.com/RileyXX/IMDB-Trakt-Syncer/releases) (e.g. 1.1.6) and run in your operating system's native command line._


  1. Install [Python](https://www.python.org/downloads/) (v3.6 or later) and [Google Chrome](https://www.google.com/chrome/). During Python installation, tick the box for adding Python to your PATH variable.  _If these are already installed, you can skip this step. Please note this script does not affect Chrome in anyway, it is simply required in order for chromedriver to work._
  2. Download the latest .zip from the [releases page](https://github.com/RileyXX/IMDB-Trakt-Syncer/releases) and extract it to the desired directory.
  3. Login to [Trakt](https://trakt.tv/oauth/applications) and create a new API application named `IMDBTraktSyncer`. In the "Redirect uri" field, enter `urn:ietf:wg:oauth:2.0:oob`, then save the application.
  4. Run `IMDBTraktSyncer.py` or open the terminal and navigate to the folder where `IMDBTraktSyncer.py` is located. Run `IMDBTraktSyncer.py` in the terminal.
  5. Follow the prompts during the first run. You will need to enter your Trakt `client ID` and `client secret` from step 3, as well as your IMDB `username` and `password`. Please note that these details are saved insecurely as `credentials.txt` in the same folder as the script. It is recommended to change your IMDB password to something unique beforehand.
  6. Setup is complete. The script will continue running and syncing your ratings. You can monitor its progress in the command line. See below for [setting up automation](https://github.com/RileyXX/IMDB-Trakt-Syncer#for-setting-up-automation-see-the-following-wiki-pages).


  - Setup Automation for:
     - [Windows](https://github.com/RileyXX/IMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-Windows)
     - [Linux](https://github.com/RileyXX/IMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-Linux)
     - [macOS](https://github.com/RileyXX/IMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-macOS)
  - Python Script to Update all Packages with Pip (Windows, Linux, Mac, ChromeOS, etc.) [Link #1](https://github.com/RileyXX/IMDB-Trakt-Syncer/wiki/Python-Script-to-Update-all-Packages-with-Pip-\(Windows,-Linux,-Mac,-ChromeOS,-etc\))


  - If any of your details change (passwords, logins, API keys, etc.), simply open `credentials.txt`, modify your details, save it and then run the script again. Alternatively, delete `credentials.txt` to reset the script and it will prompt you to enter your new details on the next run.
  - If IMDB requires a captcha on login, and you see "Not signed in" appear in the script, the captcha is likely the cause. To fix this, navigate to the IMDB website in your browser (preferably Chrome) from the same computer. If you're already logged in, log out and log back in. It may ask you to fill in a captcha. Complete the captcha and finish logging in. After successfully logging in on your browser, run the script again, and it should work. You may need to repeat this step several times if the issue persists. Adding a captcha solver to the script is being considered but not currently implemented. [Issue #2](https://github.com/RileyXX/IMDB-Trakt-Syncer/issues/2)
  - If you see an error about having the incorrect version of Chromedriver, uninstall it by running the following command in the command line: `python -m pip uninstall chromedriver-py`. In your Chrome browser, go to Settings > About Chrome and check the prefix for your version (e.g., 112... or 111). If the prefix matches your Chrome version, navigate to the [chromedriver-py releases page](https://pypi.org/project/chromedriver-py/#history) and find the latest version that matches the prefix for your Chrome version. Copy the version number you need (e.g 113.0.5672.63), then run the following command in the command line: `python -m pip install chromedriver-py==VERSION_NUMBER`. Replace `VERSION_NUMBER` with the version you copied and press enter. This will install the correct version of Chromedriver. Run the script again, and it should work. [Issue #16](https://github.com/RileyXX/IMDB-Trakt-Syncer/issues/16)
  - Due to IMDB's lack of API and rating import ability, this script uses an unconventional method that mimics using a web browser to set ratings on IMDB. Therefore, there are many points of failure that could arise. The script will be updated as best as possible.


  ![Demo](https://i.imgur.com/QXCtGrr.png)


  If you find my scripts helpful, you can become a [sponsor](https://github.com/sponsors/RileyXX) and support my projects! If you need help with a project, open an issue, and I'll do my best to assist you. For other inquiries and custom projects, you can contact me on [Twitter](https://twitter.com/RileyxBell).


  - Cashapp: [$rileyxx](https://cash.app/$rileyxx/)
  - Venmo: [@rileyxx](https://account.venmo.com/u/rileyxx)
  - Bitcoin: `bc1qrjevwqv49z8y77len3azqfghxrjmrjvhy5zqau`


  - [PyPi](https://pypi.org/project/IMDBTraktSyncer/)
  - [Reddit](https://www.reddit.com/r/trakt/comments/17xd8ic/imdb_trakt_watchlistrating_syncer_tool_sync_both/)

  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  | Project Name | Description |
  |--------------|-------------|
  | [PlexTraktSync](https://github.com/Taxel/PlexTraktSync) | A script that syncs user watch history and ratings between Trakt and Plex (without needing a PlexPass or Trakt VIP subscription). |
  | [IMDB-Trakt-Syncer](https://github.com/RileyXX/IMDB-Trakt-Syncer) | A script that syncs user watchlist, ratings, and reviews both ways between Trakt and IMDB. |
  | [TMDB-Trakt-Syncer](https://github.com/RileyXX/TMDB-Trakt-Syncer) | A script that syncs user watchlist and ratings both ways between Trakt and TMDB. |
  | [PlexPreferNonForcedSubs](https://github.com/RileyXX/PlexPreferNonForcedSubs) | A script that sets all movies and shows in your local Plex library to English non-forced subtitles by default. |
  | [Casvt / AudioSubChanger](https://github.com/Casvt/Plex-scripts/blob/main/media_management/audio_sub_changer.py) | A script with advanced options for changing audio & subtitle tracks in Plex. |
  | [Casvt / PlexAutoDelete](https://github.com/Casvt/Plex-scripts/blob/main/media_management/plex_auto_delete.py) | A script for automatically deleting watched content from Plex. |
  | [universal-trakt-scrobbler](https://github.com/trakt-tools/universal-trakt-scrobbler) | An extension that automatically scrobbles TV shows and Movies from several streaming services to Trakt. |
  | [Netflix-to-Trakt-Import](https://github.com/jensb89/Netflix-to-Trakt-Import) | A tool to import your Netflix viewing history into Trakt. |
  | [trakt-tv-backup](https://darekkay.com/blog/trakt-tv-backup/) | A command-line tool for backing up your Trakt.tv data. |
  | [blacktwin / JBOPS](https://github.com/blacktwin/JBOPS) | A collection of scripts and tools for enhancing and automating tasks in Plex. |
  | [Casvt / Plex-scripts](https://github.com/Casvt/Plex-scripts) | A collection of useful scripts for Plex automation and management. |
  | [trakt---letterboxd-import](https://github.com/jensb89/trakt---letterboxd-import) | A tool to import your Letterboxd ratings and watchlist into Trakt. |
  | [TraktRater](https://github.com/damienhaynes/TraktRater/) | A tool to help users transfer user episode, show, and movie user ratings and watchlists from multiple media database sites around the web. |
  | [TvTimeToTrakt](https://github.com/lukearran/TvTimeToTrakt) | A tool to sync your TV Time watch history with Trakt.tv. |
  | [Plex Media Server](https://www.plex.tv/media-server-downloads/#plex-app) | A media server software to organize and stream your personal media collection. |
  | [Radarr](https://github.com/Radarr/Radarr) | A movie collection manager and downloader for various platforms. |
  | [Sonarr](https://github.com/Sonarr/Sonarr) | A TV show collection manager and downloader for various platforms. |
  | [Jackett](https://github.com/Jackett/Jackett) | A proxy server that provides API support for various torrent trackers commonly used with Radarr and Sonarr. |
  | [qBittorrent](https://github.com/qbittorrent/qBittorrent) | A free and open-source BitTorrent client. |
  | [AirVPN](https://airvpn.org/) | A VPN client with port forwarding support. Great VPN for torrents. |
  | [Overseerr](https://github.com/sct/overseerr) | A request management and media discovery tool for your home media server. |
  | [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) | A reverse proxy solution to bypass Cloudflare protection and access websites commonly used with Jackett. |
  | [yt-dlp](https://github.com/yt-dlp/yt-dlp) | A command-line program to download videos from YouTube and other sites. |


pkgId: c908f71721b7e3b87e07aae4aef927665df237f923e88f78b4521547e22b48d5
name: python-IUExtract-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for IUExtract
url: https://tt-cl.github.io/iu-resources/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-IUExtract-1.0.0-1.src.rpm
location_href: Packages/python-IUExtract-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Rule-based Idea Unit segmentation algorithm for the English language.


  First of all, you need to install the dependencies:
  ```
  pip install spacy
  python -m spacy download en_core_web_lg
  ```
  To install the package with the command line tool [install pipx](https://pipx.pypa.io/latest/installation/) and run the following command:
  ```
  pipx install iuextract
  ```

  If you only wish to use the package in your python projects you can install without executable via
  ```
  pip install iuextract
  ```


  Once installed via `pipx`, you can run
  ```
  iuextract -i input_file.txt
  ```
  to segment `file.txt` into Idea Units. The segmented file will be printed on the console as standard output.
  You can specify an output file with the `-o` parameter.
  ```
  iuextract -i input_file.txt -o output_file.txt
  ```
  For more options you can call the help argument.
  ```
  iuextract -h
  ```

rpm_license:
  The Clear BSD License  Copyright (c) 2022 Marcello Gecchele, Tokunaga Laboratory of Computational Linguistics, Tokyo Institute of Technology All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the disclaimer below) provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of 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.  NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 47363b799457f5c40d5f2dafd3a19355761582a773552f0f20e5e0c93d2823f3
name: python-Imgrar-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for Imgrar
url: https://github.com/Otherwa/Imgrar
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Imgrar-1.0.1-1.src.rpm
location_href: Packages/python-Imgrar-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ImgRar is a versatile command-line tool for:
  - **Code to PNG Conversion:** Transforming codes (up to several kilobytes in size) into visually encoded PNG images.
  - **PNG to Code Conversion:** Decoding PNG images back into their original codes.
  - **MP4 Video Preparation:** Preparing PNG files for MP4 video creation (future functionality).


  - **Seamless Conversion:** Effortlessly switch between code and PNG formats.
  - **Customizable Frame Size:** Specify the frame size during code-to-PNG conversions for precise output.
  - **Flexible Directories:** Define input and output directories for streamlined workflows.


  - **Python Version:** Python 3.6 or higher.
  - **Dependencies:**
    - Built-in libraries: `argparse`, `os`.


  1. **Clone the Repository:**
     ```bash
     git clone https://github.com/your-repo/ImgRar.git
     ```
  2. **Navigate to the Directory:**
     ```bash
     cd ImgRar
     ```
  3. **Install Required Dependencies:**
     If additional modules are needed, install them using `pip`.



  Run the tool with these arguments:

  | Argument          | Short Form | Required | Description                                                                                 |
  |-------------------|------------|----------|---------------------------------------------------------------------------------------------|
  | `--Output`        | `-output`  | Yes      | Directory to save the output files.                                                        |
  | `--Input`         | `-input`   | Yes      | Directory containing input files to process.                                               |
  | `--Code2Png`      | `-code2png`| No       | Enable code-to-PNG conversion mode.                                                        |
  | `--Png2Code`      | `-png2code`| No       | Enable PNG-to-code conversion mode.                                                        |
  | `--fsize`         | `-fsize`   | No       | Set the frame size for PNG conversion (default: `320*240`).                                 |


  1. **Code to PNG Conversion:**
     ```bash
     python main.py -input ./input_dir -output ./output_dir -code2png -fsize 640*480
     ```
     Converts code files in `input_dir` to PNG images, saving them to `output_dir` with a frame size of 640x480.

  2. **PNG to Code Conversion:**
     ```bash
     python main.py -input ./input_dir -output ./output_dir -png2code
     ```
     Converts PNG images in `input_dir` back into code files, saving them to `output_dir`.


  ```
  ImgRar/
  |
  â”œâ”€â”€ BaseConversion.py  # Core logic for conversions.
  â”œâ”€â”€ main.py            # Application entry point.
  â”œâ”€â”€ README.md          # Documentation file.
  â”œâ”€â”€ input_dir/         # Example input directory (replace with your path).
  â”œâ”€â”€ output_dir/        # Example output directory (replace with your path).
  ```


  - **Implementation Details:** Ensure the `BaseConversion` class in `BaseConversion.py` includes both `code2png` and `png2code` methods.
  - **Input Files:** Use appropriate input files for smooth processing.


  This project is licensed under the MIT License. Refer to the `LICENSE` file for more details.


  We welcome contributions! To contribute:
  1. Fork the repository.
  2. Create a feature branch.
  3. Submit a pull request.


  For support or questions, email: [your-email@example.com](mailto:your-email@example.com).


pkgId: 2afd93c829917f79b8e6403d837798283cf7f2906b48eb6f069d9acf47720092
name: python-Indago
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Numerical optimization framework
url: https://pypi.org/project/Indago/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Indago-0.5.3-1.src.rpm
location_href: Packages/python-Indago-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  Indago is a Python 3 module for numerical optimization.

  Indago contains several modern methods for real fitness function optimization over a real parameter domain. It was developed at the Department for Fluid Mechanics and Computational Engineering of the University of Rijeka, Faculty of Engineering, by Stefan Ivić, Siniša Družeta, Luka Grbčić, and others.

  Indago is developed for in-house research and teaching purposes and comes with no guarantees whatsoever. However, we use it regularly and it seems to be working fine. Hopefully you will find it useful as well.

  **Important: After every Indago update please check documentation since Indago methods and API can undergo significant changes at any time.**



  You can install Indago via pip:
  ```
  pip install indago
  ```
  If you wish to update your existing Indago installation, just do:
  ```
  pip install indago --upgrade
  ```



  Full documentation is avaliable at [indago.readthedocs.io](https://indago.readthedocs.io).


pkgId: 8030af8b68fefe865bdf58a8d99f127b258da2aba4ec4cc256324e84ccad1947
name: python-InvokeAI-help
arch: noarch
version: 5.4.3
epoch: 0
release: 1
summary: Development documents and examples for InvokeAI
url: https://invoke-ai.github.io/InvokeAI/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-InvokeAI-5.4.3-1.src.rpm
location_href: Packages/python-InvokeAI-help-5.4.3-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  ![project hero](https://github.com/invoke-ai/InvokeAI/assets/31807370/6e3728c7-e90e-4711-905c-3b55844ff5be)





  [![discord badge]][discord link] [![latest release badge]][latest release link] [![github stars badge]][github stars link] [![github forks badge]][github forks link] [![CI checks on main badge]][CI checks on main link] [![latest commit to main badge]][latest commit to main link] [![github open issues badge]][github open issues link] [![github open prs badge]][github open prs link] [![translation status badge]][translation status link]

  </div>

  Invoke is a leading creative engine built to empower professionals and enthusiasts alike. Generate and create stunning visual media using the latest AI-driven technologies. Invoke offers an industry leading web-based UI, and serves as the foundation for multiple commercial products.

  Invoke is available in two editions:

  | **Community Edition**                                                                                                      | **Professional Edition**                                                                            |
  |----------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
  | **For users looking for a locally installed, self-hosted and self-managed service**                                         | **For users or teams looking for a cloud-hosted, fully managed service**                            |
  | - Free to use under a commercially-friendly license                                                                         | - Monthly subscription fee with three different plan levels                                         |
  | - Download and install on compatible hardware                                                                               | - Offers additional benefits, including multi-user support, improved model training, and more                          |
  | - Includes all core studio features: generate, refine, iterate on images, and build workflows                               | - Hosted in the cloud for easy, secure model access and scalability                                               |
  | Quick Start -> [Installation and Updates][installation docs]                                                                     | More Information -> [www.invoke.com/pricing](https://www.invoke.com/pricing)                        |


  ![Highlighted Features - Canvas and Workflows](https://github.com/invoke-ai/InvokeAI/assets/31807370/708f7a82-084f-4860-bfbe-e2588c53548d)


  | **Quick Links**                                                                                                      |
  |----------------------------------------------------------------------------------------------------------------------------|
  |  [Installation and Updates][installation docs] - [Documentation and Tutorials][docs home] - [Bug Reports][github issues] - [Contributing][contributing docs]  |

  </div>



  1. Download and unzip the installer from the bottom of the [latest release][latest release link].
  2. Run the installer script.

     - **Windows**: Double-click on the `install.bat` script.
     - **macOS**: Open a Terminal window, drag the file `install.sh` from Finder into the Terminal, and press enter.
     - **Linux**: Run `install.sh`.

  3. When prompted, enter a location for the install and select your GPU type.
  4. Once the install finishes, find the directory you selected during install. The default location is `C:\Users\Username\invokeai` for Windows or `~/invokeai` for Linux/macOS.
  5. Run the launcher script (`invoke.bat` for Windows, `invoke.sh` for macOS and Linux) the same way you ran the installer script in step 2.
  6. Select option 1 to start the application. Once it starts up, open your browser and go to <http://localhost:9090>.
  7. Open the model manager tab to install a starter model and then you'll be ready to generate.

  More detail, including hardware requirements and manual install instructions, are available in the [installation documentation][installation docs].



  We publish official container images in Github Container Registry: https://github.com/invoke-ai/InvokeAI/pkgs/container/invokeai. Both CUDA and ROCm images are available. Check the above link for relevant tags.

  > [!IMPORTANT]
  > Ensure that Docker is set up to use the GPU. Refer to [NVIDIA][nvidia docker docs] or [AMD][amd docker docs] documentation.



  Run the container, modifying the command as necessary:

  ```bash
  docker run --runtime=nvidia --gpus=all --publish 9090:9090 ghcr.io/invoke-ai/invokeai
  ```

  Then open `http://localhost:9090` and install some models using the Model Manager tab to begin generating.

  For ROCm, add `--device /dev/kfd --device /dev/dri` to the `docker run` command.



  You will likely want to persist your workspace outside of the container. Use the `--volume /home/myuser/invokeai:/invokeai` flag to mount some local directory (using its **absolute** path) to the `/invokeai` path inside the container. Your generated images and models will reside there. You can use this directory with other InvokeAI installations, or switch between runtime directories as needed.



  Build your own image and customize the environment to match your needs using our `docker-compose` stack. See [README.md](./docker/README.md) in the [docker](./docker) directory.



  Please review our [FAQ][faq] for solutions to common installation problems and other issues.

  For more help, please join our [Discord][discord link].



  Full details on features can be found in [our documentation][features docs].



  Invoke runs a locally hosted web server & React UI with an industry-leading user experience.



  The Unified Canvas is a fully integrated canvas implementation with support for all core generation capabilities, in/out-painting, brush tools, and more. This creative tool unlocks the capability for artists to create with AI as a creative collaborator, and can be used to augment AI-generated imagery, sketches, photography, renders, and more.



  Invoke offers a fully featured workflow management solution, enabling users to combine the power of node-based workflows with the easy of a UI. This allows for customizable generation pipelines to be developed and shared by users looking to create specific workflows to support their production use-cases.



  Invoke features an organized gallery system for easily storing, accessing, and remixing your content in the Invoke workspace. Images can be dragged/dropped onto any Image-base UI element in the application, and rich metadata within the Image allows for easy recall of key prompts or settings used in your workflow.



  - Support for both ckpt and diffusers models
  - SD1.5, SD2.0, SDXL, and FLUX support
  - Upscaling Tools
  - Embedding Manager & Support
  - Model Manager & Support
  - Workflow creation & management
  - Node-Based Architecture



  Anyone who wishes to contribute to this project - whether documentation, features, bug fixes, code cleanup, testing, or code reviews - is very much encouraged to do so.

  Get started with contributing by reading our [contribution documentation][contributing docs], joining the [#dev-chat] or the GitHub discussion board.

  We hope you enjoy using Invoke as much as we enjoy creating it, and we hope you will elect to become part of our community.



  Invoke is a combined effort of [passionate and talented people from across the world][contributors]. We thank them for their time, hard work and effort.

  Original portions of the software are Copyright © 2024 by respective contributors.

  [features docs]: https://invoke-ai.github.io/InvokeAI/features/database/
  [faq]: https://invoke-ai.github.io/InvokeAI/faq/
  [contributors]: https://invoke-ai.github.io/InvokeAI/contributing/contributors/
  [invoke.com]: https://www.invoke.com/about
  [github issues]: https://github.com/invoke-ai/InvokeAI/issues
  [docs home]: https://invoke-ai.github.io/InvokeAI
  [installation docs]: https://invoke-ai.github.io/InvokeAI/installation/
  [#dev-chat]: https://discord.com/channels/1020123559063990373/1049495067846524939
  [contributing docs]: https://invoke-ai.github.io/InvokeAI/contributing/
  [CI checks on main badge]: https://flat.badgen.net/github/checks/invoke-ai/InvokeAI/main?label=CI%20status%20on%20main&cache=900&icon=github
  [CI checks on main link]: https://github.com/invoke-ai/InvokeAI/actions?query=branch%3Amain
  [discord badge]: https://flat.badgen.net/discord/members/ZmtBAhwWhy?icon=discord
  [discord link]: https://discord.gg/ZmtBAhwWhy
  [github forks badge]: https://flat.badgen.net/github/forks/invoke-ai/InvokeAI?icon=github
  [github forks link]: https://useful-forks.github.io/?repo=invoke-ai%2FInvokeAI
  [github open issues badge]: https://flat.badgen.net/github/open-issues/invoke-ai/InvokeAI?icon=github
  [github open issues link]: https://github.com/invoke-ai/InvokeAI/issues?q=is%3Aissue+is%3Aopen
  [github open prs badge]: https://flat.badgen.net/github/open-prs/invoke-ai/InvokeAI?icon=github
  [github open prs link]: https://github.com/invoke-ai/InvokeAI/pulls?q=is%3Apr+is%3Aopen
  [github stars badge]: https://flat.badgen.net/github/stars/invoke-ai/InvokeAI?icon=github
  [github stars link]: https://github.com/invoke-ai/InvokeAI/stargazers
  [latest commit to main badge]: https://flat.badgen.net/github/last-commit/invoke-ai/InvokeAI/main?icon=github&color=yellow&label=last%20dev%20commit&cache=900
  [latest commit to main link]: https://github.com/invoke-ai/InvokeAI/commits/main
  [latest release badge]: https://flat.badgen.net/github/release/invoke-ai/InvokeAI/development?icon=github
  [latest release link]: https://github.com/invoke-ai/InvokeAI/releases/latest
  [translation status badge]: https://hosted.weblate.org/widgets/invokeai/-/svg-badge.svg
  [translation status link]: https://hosted.weblate.org/engage/invokeai/
  [nvidia docker docs]: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
  [amd docker docs]: https://rocm.docs.amd.com/projects/install-on-linux/en/latest/how-to/docker.html

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.


pkgId: e87b37da03a37b2b486cc9012b699c840d4b5de3fedb60bf8a1c8b375366a6f8
name: python-IsaREPL-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for IsaREPL
url: https://github.com/xqyww123/Isa-REPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-IsaREPL-0.8.0-1.src.rpm
location_href: Packages/python-IsaREPL-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  Unofficial support for Isabelle's Read-Eval-Print-Loop.
  **Features**
  - Python Client, easy for Machine Learning.
  - Full support for all Isabelle commands
  - Tracing the proof state and the output panel for each step of evaluation.
  	- Plugin: collecting data from Isabelle's internal representations by plugins written in Isabelle/ML ([example](./examples/example_plugin.py)).
  - Socket based remote communication
  - Socket based Concurrency
  - State rollback ([example](./examples/example_rollback.py))
  - Parsing terms & Retrival of lemmas ([example](./examples/example_parse.py))
  - Sledgehammer ([example](./examples/example_sledgehammer.py))
  - Retrivial of contextual information including assumptions, local facts, fixed terms, fixed types, and goals, in either the pretty-printed form or S expression ([example](./examples/example_context.py)).

  We **only** support [Isabelle2023](https://isabelle.in.tum.de/website-Isabelle2023/index.html) and [Isabelle2024](https://isabelle.in.tum.de/website-Isabelle2024/index.html).
  Ensuring `<ISABELLE-BASE-DIRECTORY>/bin` is in your `$PATH` environment
  ```
  git clone https://github.com/xqyww123/Isa-REPL.git
  cd Isa-REPL
  git checkout $(isabelle version) # Error can raise if you are using an unsupported version of Isabelle
  isabelle components -u .
  pip install IsaREPL
  ```

  ```

  ./repl_server.sh 127.0.0.1:6666 HOL ./tmp
  ```
  Run `./repl_server.sh` to see the full explanation of the arguments and options.

  Every interface of our client is will documented (it is highly recommended to read our [source](./IsaREPL/IsaREPL.py)). Some examples are given in [the example folder](./examples).
  ```

  ./examples/example_eval.py 127.0.0.1:6666
  ```
  To evaluate a whole theory file
  ```
  ./examples/eval_file.py 127.0.0.1:6666 $(isabelle getenv -b ISABELLE_HOME)/src/HOL/List.thy
  ```


  All documents are given as docstrings attaching to Python client interfaces, see [the source](./IsaREPL/IsaREPL.py).

  This REPL supports concurrent evaluation of multiple files. However, to ensure proper error tracking and result tracing, it disables Isabelle's concurrency between commands within a single theory file. While Isabelle typically executes `by` commands asynchronously (continuing to the next command before completion), this REPL enforces synchronous evaluation. Each command must complete before the next begins, allowing for accurate capture and reporting of any failures.
  Sledgehammer (via our `auto_sledgehamemr` wrapper, see [example](./examples/example_sledgehammer.py)) is still concurrent.

  It is possible to implement a client in other languages. However, the document for the communication protocol is not provided and I refer you to read our source code, as it should be simple enough.

  Feel free to open any GitHub issue if you have any feature requests.
  I am not a professional python developer, so contribution is highly welcome to enrich the client's features.

rpm_license:
  Isa-REPL COPYRIGHT NOTICE, LICENCE AND DISCLAIMER.  Copyright (c) 2024, Qiyuan Xu <xqyww123@gmail.com>  Isa-REPL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 2.1 of the License, or (at your option) any later version.  Isa-REPL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with Isa-REPL. If not, see <https://www.gnu.org/licenses/>.


pkgId: 57559f24dc20f3eef3e5d3de13b0dda97937209d651e2985392ce59b120bb1c1
name: python-JakaModbusCommunication-help
arch: noarch
version: 4.0.8
epoch: 0
release: 1
summary: Development documents and examples for JakaModbusCommunication
url: https://github.com/cacher300/JakaModbusCom
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-JakaModbusCommunication-4.0.8-1.src.rpm
location_href: Packages/python-JakaModbusCommunication-help-4.0.8-1.noarch.rpm
checksum_type: sha256
description:
  - **Digital Input/Output Handling**:
    - Read and write the states of digital inputs and outputs.
    - Support for specific JAKA input/output types such as `CAB`, `TOOL`, and `MINI`.
  - **Analog Input/Output Handling**:
    - Read and write 16-bit integer, signed integer, and 32-bit floating-point values to analog outputs.
  - **System Data**:
    - Retrieve data such as servo version, serial numbers, joint data (voltages, temperatures, positions, etc.), TCP position and speed, control status, and cabinet data.
  - **Modbus TCP Connection Management**:
    - Easy connection and disconnection from a Modbus TCP server.


pkgId: 079a75c5d1ee9fd3c2082e45128885bbcac74f44edb5bf7d79233ccb2cccce27
name: python-Jedutils-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for Jedutils
url: https://github.com/AYMENJD/jedutils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Jedutils-0.2.6-1.src.rpm
location_href: Packages/python-Jedutils-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  Jedutils is a Python utilities package that provides a collection of useful helper functions.



  You can install Jedutils using `pip`:

  ```bash
  pip install jedutils
  ```

  To install all the dependencies for all utilities, use the following command:
  ```bash
  pip install jedutils[all]
  ```



  Contributions to Jedutils are welcome! If you have an idea for a new utility or an improvement to an existing one, please open an issue or submit a pull request on GitHub.



  Jedutils is licensed under the MIT License. See the `LICENSE` file for details.


pkgId: 91a1a5814e7a413006edfff130c2694ff43861d911b1edc295fec37e9a1494b8
name: python-KEGGaNOG-help
arch: noarch
version: 0.7.0.1
epoch: 0
release: 1
summary: Development documents and examples for KEGGaNOG
url: https://github.com/iliapopov17/KEGGaNOG
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KEGGaNOG-0.7.0.1-1.src.rpm
location_href: Packages/python-KEGGaNOG-help-0.7.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Python3](https://img.shields.io/badge/Language-Python3-steelblue)
  ![Pandas](https://img.shields.io/badge/Dependecy-Pandas-steelblue)
  ![Seaborn](https://img.shields.io/badge/Dependecy-Seaborn-steelblue)
  ![Matplotlib](https://img.shields.io/badge/Dependecy-Matplotlib-steelblue)
  ![Numpy](https://img.shields.io/badge/Dependecy-Numpy-steelblue)
  ![KEGG-Decoder](https://img.shields.io/badge/Dependecy-KEGG_Decoder-steelblue)
  ![License](https://img.shields.io/badge/License-MIT-steelblue)

  ![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)
  ![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0)



  [**`eggNOG-mapper`**](https://github.com/eggnogdb/eggnog-mapper) 🤝 [**`KEGG-Decoder`**](https://github.com/bjtully/BioData/blob/master/KEGGDecoder/README.md)

  - `eggNOG-mapper` is a beautiful tool for fast functional annotation of novel sequences. Yet it does not provide any visualization functions.
  - `KEGG-Decoder` is a perfect tool for visualizing KEGG Pathways. But it only takes `KEGG-Koala` outputs as an input (including blastKOALA, ghostKOALA, KOFAMSCAN).
  - `KEGG-Koala` is a web-tool which can work for more than 24 hours. `eggNOG-mapper` can be installed locally on your PC / server and work faster.
  - This tool `KEGGaNOG` makes `eggNOG-mapper` meet `KEGG-Decoder`! It parses `eggNOG-mapper` output, make it fit for the input to `KEGG-Decoder` and then visualize KEGG Pathways as the heatmap!
  - **Pro-tip:** `eggNOG-mapper` and `KEGGaNOG` could be wrapped into 🐍 `Snakemake` pipeline making metabolic profiling a "one-click" process!



  `KEGG-Decoder` is hardwired into `KEGGaNOG`<br>
  `KEGG-Decoder` uses `python=3.6`<br>
  That's why `KEGGaNOG` uses this version too

  ```bash

  conda create -n kegganog python=3.6


  CONDA_SUBDIR=osx-64 conda create -n kegganog python=3.6

  conda activate kegganog
  pip install kegganog
  ```



  ```
  usage: KEGGaNOG [-h] [-M] -i INPUT -o OUTPUT [-dpi DPI] [-c COLOR] [-n NAME]
                  [-g] [-V]

  KEGGaNOG: Link eggNOG-mapper and KEGG-Decoder for pathway visualization.

  optional arguments:
    -h, --help            show this help message and exit
    -M, --multi           “Multi” mode allows to run KEGGaNOG on multiple
                          eggNOG-mapper annotation files (a text file with file
                          location paths must be passed to the input)
    -i INPUT, --input INPUT
                          Path to eggNOG-mapper annotation file
    -o OUTPUT, --output OUTPUT
                          Output folder to save results
    -dpi DPI, --dpi DPI   DPI for the output image (default: 300)
    -c COLOR, --color COLOR, --colour COLOR
                          Cmap for seaborn heatmap. Recommended options: Greys,
                          Purples, Blues, Greens, Oranges, Reds (default: Blues)
    -n NAME, --name NAME  Sample name for labeling (default: SAMPLE) (not active
                          in `--multi` mode)
    -g, --group           Group the heatmap based on predefined categories
    -V, --version         show program's version number and exit
  ```

  🔗 Please also visit [KEGGaNOG wiki](https://github.com/iliapopov17/KEGGaNOG/wiki) page


  Contributions are welcome! If you have any ideas, bug fixes, or enhancements, feel free to open an issue or submit a pull request.


  For any inquiries or support, feel free to contact me via [email](mailto:iljapopov17@gmail.com)

  Happy functional annotation! 💻🧬


pkgId: 19d359b1d5b2e3c7874da813e2237ef958b67e72efbfc6b416c079572af8ddd9
name: python-KFinanceDataReader-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for KFinanceDataReader
url: https://github.com/jackmappotion/KFinanceDataReader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KFinanceDataReader-1.0.0-1.src.rpm
location_href: Packages/python-KFinanceDataReader-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  한국의 주요 금융 데이터 추출을 위한 library

  - 거시경제 지표 [ECOS](https://ecos.bok.or.kr/api/#/)
  - 시장 지표 [KRX](https://data.krx.co.kr/)
  - 기업 재무제표 지표 [DART](https://dart.fss.or.kr/)



  본 프로젝트는 다양한 source의 금융데이터를 활용하기 편한 형식으로 수집한다.
  1. 데이터 수집 파라미터 형식의 통일
  2. 추출된 데이터 형식의 통일




  - 거시경제 지표 추출을 위해 `ECOS API KEY`가 필요하다.
  - 기업 재무제표 지표 추출을 위해 `DART API KEY`가 필요하다.


pkgId: c80a63024aaa22bf5fc9fbbc72d083f23ac84d76b90ef6652ec15848ffa9be62
name: python-KIB-LAP-debuginfo
arch: aarch64
version: 0.3.22
epoch: 0
release: 1
summary: Debug information for package python-KIB-LAP
url: https://pypi.org/project/KIB-LAP/
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-KIB-LAP-0.3.22-1.src.rpm
location_href: Packages/python-KIB-LAP-debuginfo-0.3.22-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-KIB-LAP.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 3d6139fb8f8052ad0c513a1c88a92806814437bb422c8cd9155fa65934d7ef96
name: python-KIB-LAP-debugsource
arch: aarch64
version: 0.3.22
epoch: 0
release: 1
summary: Debug sources for package python-KIB-LAP
url: https://pypi.org/project/KIB-LAP/
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-KIB-LAP-0.3.22-1.src.rpm
location_href: Packages/python-KIB-LAP-debugsource-0.3.22-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-KIB-LAP.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: d094f2e96d46d4d981dca07f732212a9e545d9b0737f4d0d272998188820f69c
name: python-KKKF-help
arch: noarch
version: 0.4
epoch: 0
release: 1
summary: Development documents and examples for KKKF
url: https://github.com/diegoolguinw/KKKF
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KKKF-0.4-1.src.rpm
location_href: Packages/python-KKKF-help-0.4-1.noarch.rpm
checksum_type: sha256
description:
  KKKF is a Python library that implements kernel Extended Dynamic Mode Decomposition (EDMD) of Koopman operators and provides a non-linear variant of the Kalman Filter. This library is particularly useful for state estimation in dynamical systems with non-linear behavior.



  You can install KKKF using pip:

  ```bash
  pip install KKKF
  ```



  - Kernel-based Extended Dynamic Mode Decomposition (EDMD)
  - Non-linear Kalman Filter implementation
  - Support for general dynamical systems
  - Integration with various kernel functions (e.g., Matérn kernel)
  - Robust state estimation with noise handling



  - NumPy
  - SciPy
  - scikit-learn (for kernel functions)
  - Matplotlib (for visualization)



  Here's a complete example of using KKKF to estimate and visualize states in a SIR (Susceptible-Infected-Recovered) model:

  ```python

  import numpy as np
  import matplotlib.pyplot as plt
  from scipy import stats
  from sklearn.gaussian_process.kernels import Matern
  from KKKF.DynamicalSystems import DynamicalSystem
  from KKKF.kEDMD import KoopmanOperator
  from KKKF.applyKKKF import apply_koopman_kalman_filter


  beta, gamma = 0.12, 0.04


  def f(x):
      return x + np.array([-beta*x[0]*x[1], beta*x[0]*x[1] - gamma*x[1], gamma*x[1]])


  def g(x):
      return np.array([x[1]])


  N = 300
  nx, ny = 3, 1
  k = Matern(length_scale=N**(-1/nx), nu=0.5)


  X_dist = stats.dirichlet(alpha=np.ones(nx))
  dyn_dist = stats.multivariate_normal(mean=np.zeros(nx), cov=1e-5*np.eye(3))
  obs_dist = stats.multivariate_normal(mean=np.zeros(ny), cov=1e-3*np.eye(1))


  dyn = DynamicalSystem(nx, ny, f, g, X_dist, dyn_dist, obs_dist)


  iters = 100
  x0 = np.array([0.9, 0.1, 0.0])
  x = np.zeros((iters, nx))
  y = np.zeros((iters, ny))

  x[0] = x0
  y[0] = g(x[0]) + obs_dist.rvs()

  for i in range(1, iters):
      x[i] = f(x[i-1]) + dyn.dist_dyn.rvs()
      y[i] = g(x[i]) + obs_dist.rvs()




  x0_prior = np.array([0.8, 0.15, 0.05])
  d0 = stats.multivariate_normal(mean=x0_prior, cov=0.1*np.eye(3))


  Koop = KoopmanOperator(k, dyn)


  sol = apply_koopman_kalman_filter(Koop, y, d0, N, noise_samples=100)


  conf = np.zeros((iters, nx))
  for i in range(iters):
      conf[i, :] = np.sqrt(np.diag(sol.Px_plus[i,:,:]))


  err1 = sol.x_plus - 1.96*conf
  err2 = sol.x_plus + 1.96*conf


  labels = ["S (True)", "I (True)", "R (True)"]
  colors = ["blue", "red", "green"]

  plt.plot(sol.x_plus, label=["S (KKF)", "I (KKF)", "R (KKF)"])

  for i in range(nx):
      plt.fill_between(np.arange(iters), err1[:,i], err2[:,i], alpha=0.6)
      plt.scatter(np.arange(iters), x[:,i], label=labels[i], color=colors[i], s=1.4)

  plt.xlabel("Days")
  plt.ylabel("Propotion of population")
  plt.title("KKKF Estimation")
  plt.legend()
  plt.show()
  ```





  ```python
  DynamicalSystem(nx, ny, f, g, X_dist, dyn_dist, obs_dist)
  ```
  Creates a dynamical system with:
  - `nx`: State dimension
  - `ny`: Observation dimension
  - `f`: State transition function
  - `g`: Observation function
  - `X_dist`: State distribution
  - `dyn_dist`: Dynamic noise distribution
  - `obs_dist`: Observation noise distribution



  ```python
  KoopmanOperator(kernel, dynamical_system)
  ```
  Initializes a Koopman operator with:
  - `kernel`: Kernel function (e.g., Matérn kernel)
  - `dynamical_system`: Instance of DynamicalSystem



  ```python
  apply_koopman_kalman_filter(koopman, observations, initial_distribution, N, noise_samples=100)
  ```
  Applies the Koopman-based Kalman filter with:
  - `koopman`: KoopmanOperator instance
  - `observations`: Observation data
  - `initial_distribution`: Initial state distribution
  - `N`: Number of samples
  - `noise_samples`: Number of noise samples for uncertainty estimation

  Returns a solution object containing:
  - `x_plus`: State estimates
  - `Px_plus`: Covariance matrices
  - Additional filter statistics



  The library supports visualization of results with confidence intervals. The example above demonstrates how to:
  - Plot state estimates
  - Add confidence intervals (shaded regions)
  - Compare with real data (if available)
  - Customize plot appearance



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  If you use this library in your research, please cite:

  ```bibtex
  @software{kkkf,
    title = {KKKF: Kernel Koopman Kalman Filter},
    year = {2024},
    author = {Diego Olguín-Wende},
    url = {https://github.com/diegoolguinw/KKKF}
  }
  ```


pkgId: 821f3fe9979627041e5f2842c6724c6b200b3445a5b92c7582cdd67224ddf144
name: python-Kala-Quantum-185-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for Kala-Quantum-185
url: https://github.com/kalasaikamesh944/kala_quantum
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Kala-Quantum-185-0.1.0-1.src.rpm
location_href: Packages/python-Kala-Quantum-185-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Python 3.8+**
  - **NumPy**
  - **TQDM** (for progress tracking)

  To install dependencies, run:
  ```bash
  pip install numpy tqdm
  ```

  ```bash
  git clone https://github.com/Kalasaikamesh944/Kala_Quantum.git
  cd Kala_Quantum


pkgId: c30e92f6a4e0e53da63af33bf825d44490254bd513168f68e76f99b223fafc55
name: python-Kala-Qubits-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for Kala-Qubits
url: https://github.com/Kalasaikamesh944/Qubits
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Kala-Qubits-0.1.0-1.src.rpm
location_href: Packages/python-Kala-Qubits-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The **Qubits** is a Python-based library for simulating quantum circuits. It leverages PyTorch to efficiently represent and manipulate quantum states and gates. This library is designed for developers and researchers who want to prototype and experiment with quantum algorithms without needing access to actual quantum hardware.


  - **Quantum Gates**: Includes common gates like Pauli-X, Pauli-Y, Pauli-Z, Hadamard, CNOT, and parameterized rotation gates (Rx, Ry, Rz).
  - **Quantum and Classical Registers**: Simulate quantum states and classical measurement storage.
  - **Gate Application**: Apply single- and multi-qubit gates on quantum circuits.
  - **Measurement**: Measure qubits and collapse the quantum state.
  - **Lightweight**: Minimal dependencies with a PyTorch backend.



  You can install the library using `pip` after cloning the repository:

  ```bash
  pip install Kala_Qubits
  ```




  ```python
  from Qubits import Gate, QuantumCircuit
  ```


  ```python

  qc = QuantumCircuit(2, 2)


  qc.apply(Gate.hadamard(), [0])  # Apply Hadamard to qubit 0
  qc.apply(Gate.cnot(), [0, 1])  # Apply CNOT with qubit 0 as control and qubit 1 as target


  qc.execute()


  result = qc.measure_all()
  print(f"Measurement outcome: {result}")
  ```


  ```python
  import numpy as np


  custom_matrix = np.array([[1, 0], [0, -1]])
  custom_gate = Gate.custom(custom_matrix)


  qc.apply(custom_gate, [0])
  ```






  - `Gate.pauli_x()`
  - `Gate.pauli_y()`
  - `Gate.pauli_z()`
  - `Gate.hadamard()`
  - `Gate.cnot()`
  - `Gate.rotation_x(theta)`
  - `Gate.rotation_y(theta)`
  - `Gate.rotation_z(theta)`
  - `Gate.custom(matrix)`




  - `apply(gate, qubits)`
  - `measure(qubit, cbit)`
  - `measure_all()`
  - `execute()`


  Used internally to manage quantum states and classical bits.



  1. Fork the repository.
  2. Create a new branch for your feature or bugfix.
  3. Submit a pull request with a detailed explanation of your changes.



  This project is licensed under the MIT License. See the `LICENSE` file for details.


  - Inspired by Qiskit and PyTorch.
  - Designed for educational and research purposes.


pkgId: ba28e673a1778d637de66cf59618dab6e9d25aae789a3497a7fe5c3fe4bab39f
name: python-KegElements-help
arch: noarch
version: 0.12.1
epoch: 0
release: 1
summary: Development documents and examples for KegElements
url: https://github.com/level12/keg-elements
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KegElements-0.12.1-1.src.rpm
location_href: Packages/python-KegElements-help-0.12.1-1.noarch.rpm
checksum_type: sha256
description:
  For a simple example and a checklist of sorts for app setup, see the
  `Getting Started guide <https://keg-elements.readthedocs.io/en/stable/getting-started.html>`_ in the docs.


pkgId: 597ed034ba3ea1fb5fce2b4c7fb0926cbd8d7d8e0a56663faa3b9e9f36ed8c75
name: python-KekikStream-help
arch: noarch
version: 0.5.7
epoch: 0
release: 1
summary: Development documents and examples for KekikStream
url: https://github.com/keyiflerolsun/KekikStream
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KekikStream-0.5.7-1.src.rpm
location_href: Packages/python-KekikStream-help-0.5.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Boyut](https://img.shields.io/github/repo-size/keyiflerolsun/KekikStream?logo=git&logoColor=white&label=Boyut)](#)
  [![Görüntülenme](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https://github.com/keyiflerolsun/KekikStream&title=Görüntülenme)](#)
  <a href="https://KekikAkademi.org/Kahve" target="_blank"><img src="https://img.shields.io/badge/☕️-Kahve Ismarla-ffdd00" title="☕️ Kahve Ismarla" style="padding-left:5px;"></a>

  [![PyPI](https://img.shields.io/pypi/v/KekikStream?logo=pypi&logoColor=white&label=PyPI)](https://pypi.org/project/KekikStream)
  [![PyPI - Yüklenme](https://img.shields.io/pypi/dm/KekikStream?logo=pypi&logoColor=white&label=Yüklenme)](https://pypi.org/project/KekikStream)
  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/KekikStream?logo=pypi&logoColor=white&label=Wheel)](https://pypi.org/project/KekikStream)

  [![Python Version](https://img.shields.io/pypi/pyversions/KekikStream?logo=python&logoColor=white&label=Python)](#)
  [![Lisans](https://img.shields.io/pypi/l/KekikStream?logo=gnu&logoColor=white&label=Lisans)](#)
  [![Durum](https://img.shields.io/pypi/status/KekikStream?logo=windowsterminal&logoColor=white&label=Durum)](#)

  [![PyPI Yükle](https://github.com/keyiflerolsun/KekikStream/actions/workflows/pypiYukle.yml/badge.svg)](https://github.com/keyiflerolsun/KekikStream/actions/workflows/pypiYukle.yml)

  *terminal üzerinden medya içeriği aramanızı ve VLC/MPV gibi popüler medya oynatıcılar aracılığıyla doğrudan izlemenizi sağlayan modüler ve genişletilebilir bir bıdı bıdı*

  [![Video](https://github.com/user-attachments/assets/63d31bb0-0b69-40b4-84aa-66623f2a253f)](https://github.com/user-attachments/assets/63d31bb0-0b69-40b4-84aa-66623f2a253f)

  [![ForTheBadge made-with-python](https://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)
  [![ForTheBadge built-with-love](https://ForTheBadge.com/images/badges/built-with-love.svg)](https://GitHub.com/keyiflerolsun/)



  ```bash

  pip install KekikStream


  pip install -U KekikStream
  ```



  ```bash
  KekikStream
  ```



  **[☕️ Kahve Ismarla](https://KekikAkademi.org/Kahve)**



  - [DeoDorqnt387/aniwatch-tr](https://github.com/DeoDorqnt387/aniwatch-tr)



  * *Copyright (C) 2024 by* [keyiflerolsun](https://github.com/keyiflerolsun) ❤️️
  * [GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007](https://github.com/keyiflerolsun/KekikStream/blob/master/LICENSE) *Koşullarına göre lisanslanmıştır..*



  *Benimle iletişime geçmek isterseniz, **Telegram**'dan mesaj göndermekten çekinmeyin;* [@keyiflerolsun](https://t.me/KekikKahve)



  > **[@KekikAkademi](https://t.me/KekikAkademi)** *için yazılmıştır..*


pkgId: fc4de32a65d5b3136f6d294730de54ec3a9526b2c9d891d70367e7116aae7296
name: python-KennyPavan-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for KennyPavan
url: https://github.com/kennypavan/kennypavan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KennyPavan-1.0.1-1.src.rpm
location_href: Packages/python-KennyPavan-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Below is a simple package which has methods for displaying details about my experience, skills, hobbies, current projects, some inspirational quotes, and resume.


  ```
  pip install kennypavan
  ```


  ```python
  from KennyPavan import KennyPavan


  kp = KennyPavan()


  kp.about()


  kp.skills()


  kp.experience()


  kp.education()


  kp.publications()

  ```

  <br />


  ```python
  from KennyPavan import KennyPavan
  kp = KennyPavan()
  kp.displayAll()
  ```

  <br />
  <br />

  <font size="18px">🤷</font><br />
  <i>There's also a few properties</i>


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


  KmerDecon is a fast, memory-efficient tool for decontaminating sequencing reads using Bloom filters or Cuckoo filters. It generate detailed reports of contaminants in sequencing data.


  - Yujia Feng
  - Xiaoyi Chen
  - Yuxiang Li





  - Python 3.6 or higher
  - pip package manager



  Run the following command inside the directory:
    ```
    pip install .
    ```





  Generate a Bloom filter from contamination source sequences. Generate a Cuckoo filter, use `-s cuckoo`. Use `kbuild --help` for more detail.

  ```
  kbuild -c contamination.fasta -s bloom -o contamination_filter.bf
  ```


  **Optional Arguments:**

  - `kmer-length`: Length of k-mers to generate (e.g., 31). If not provided, the tool determines the optimal k-mer length automatically.
  - `expected-elements`: Expected number of unique k-mers. If not provided, it is estimated using HyperLogLog.
  - `exclude-filter`: A .bf filter or .cms file path. If provided, any k-mers present in the excluded filter will not be encoded into the new build filter.
  - `max-memory`: Maximum memory in GB for the Bloom filter. Adjusts parameters to fit within this limit.
  - `false-positive-rate`: Desired false positive rate (default: 0.01).

  if choose build Cuckoo filter:
  - `capacity-of-cuckoofilter`: The capacity of cuckoo filter



  Filter out contaminated reads from your sequencing data. Use `kdecon --help` for more detail.

  Use bloom filter:
  ```
  kdecon -i reads.fastq -d example_filter/hg38.bf -s bloom -o output
  ```
  Use `-s cuckoo` for Cuckoo filter.

  **Optional Arguments:**

  - `threshold`: Fraction of matching k-mers to consider a read contaminated (default: 0.5).
  - `kmer-length`: Length of k-mers used. If not provided, the k-mer length from the Bloom filter is used.
  - `mode`: Operation mode, either filter (default) or states.
    - filter: Filters reads based on contamination levels.
    - states: Generates a states.csv report with contamination statistics. Columns:
  	- {filter}_avgSimilarity: The average fraction of matching k-mers across all reads in that file for each filter.
  	- {filter}_percentReadsPassing: The percentage of reads passing the threshold for each filter.





  - With default parameters, we achieves FPR = 0.002%, FNR = 0.05% on simulated human reads decontamination task.
  - KmerDecon is memory efficient and uses 10 bits / kmer. (Popular too Kraken2 uses 32 bits / kmer)
  - KmerDecon is fast and takse 5 min to filter 1 million reads of 150bp each (kraken2 takes ~8min, both on single thread)
  - Multi-threads parallel building supported.


  - To read the full performance report, please see: [Here](https://drive.google.com/file/d/1shEp8LZAC5w_qR0p8BzsjBeAsOffvDIH/view?usp=sharing)
  - To recreate the results on the report, please see: [Here](reproducibility.md)




  - `bitarray>=2.1.0`
  - `biopython>=1.78`
  - `mmh3>=2.5.1`
  - `hyperloglog>=0.0.12`

  Install dependencies manually with:

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

   The python module of cuckoofilter is adapted from:

   Author: Huy Do

   Repository: https://github.com/huydhn/cuckoo-filter/blob/master/cuckoo/filter.py

   License: MIT



  Contributions and PRs are welcome!



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



  For questions or suggestions, please open an issue.


pkgId: 9559c4844cf5c32e664c68aa7adba375976bc1f1d329e9ea2643a4d4c9bc13cc
name: python-KofiPyQtHelper-help
arch: noarch
version: 0.1.44
epoch: 0
release: 1
summary: Development documents and examples for KofiPyQtHelper
url: https://pypi.org/project/KofiPyQtHelper/
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-KofiPyQtHelper-0.1.44-1.src.rpm
location_href: Packages/python-KofiPyQtHelper-help-0.1.44-1.noarch.rpm
checksum_type: sha256
description:
  PyQt的快速布局

  项目中配置放置在config文件夹中

  interface放置界面文件

  本项目使用pipreqs 进行依赖管理,若未安装pipreqs使用

  ```shell
  pip install pipreqs
  ```

  1.创建requirement.txt文件

  ```shell
  pipreqs ./ --force
  ```

  2.自动安装所有依赖

  ```shell
  pip install -r requirements.txt
  <!-- 强制安装 -->
  pip install -r requirements.txt -i http://mirrors.aliyun.com/pypi/simple/ --trusted-host mirrors.aliyun.com
  ```


pkgId: 4155689eb248d6d84546f78af81d9cf50e1e33930cacbc6fe372e6520e25eb8c
name: python-LEAFeatures-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for LEAFeatures
url: https://github.com/lrcfmd/LEAF
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LEAFeatures-0.1.2-1.src.rpm
location_href: Packages/python-LEAFeatures-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Local Environment-induced Atomic Features (LEAFs) are derived from comprehensive learning of the local structures of chemical elements in inorganic crystals as described in

  A. Vasylenko et. al. "Learning Atoms from Crystal Structures", https://doi.org/10.48550/arXiv.2408.02292

  LEAFs have been proven useful as
  1. Structurally-informed similarity measure for compositions.
  2. Probability measure of elemental substitutions.
  3. Featurization for elements and compositions.

  We recommend installation via pip

  ```
  pip install LEAFeatures
  ```

  For local installation run

  ```
  python setup.py install
  ```


  For simple usage initiate an object with its compositional formula

  ```python
  > from LEAFeatures.leafs import Leaf
  > x = Leaf("CaTiO3")
  ```

  Calculate the distance to a second object with the `similarity` method,

  ```python
  > x.similarity("SrTiO3")
  9.995487
  ```

  which returns a number from 1 to 10, with ascending similarity.


  the distance is calculated as cosine similarity between 59-dimensional elemental vectors. Hence, many distances > 9 and digits after decimal point are of determining importance. E.g.,
  ```python
  > Leaf("CaTiO3").similarity("SrSiO3")
  9.982714
  > Leaf("CaTiO3").similarity("SrTiO3")
  9.995487
  ```

  Calculate the substitution probability with the `sub_probability` method.

  ```python
  > x.sub_probability("SrSiO3")
  ['Sr2+', 'Ti4+', 'O2-'] ['Ca2+', 'Ti4+', 'O2-'] [0.005256, 0.007006, 0.006997]
  2.57654281392e-07
  ```

  This returns the oxidation states derived assuming a charge balance, pairwise elemental subsitution probabilities (i.e. Sr -> Ca and Si -> Ti) ranging from 0 to 1, and their product.
  Oxidation states of the candidate substitutions can be input explicitly:

  ```python
  > x.sub_probability("Sr2TiO5", oxidations={'Sr':2, 'Ti':3, 'O':-2})
  ```

  Because the probabilites product decreases for multi-element substitutions, comparing multi-element substitutions with the best possible substitutions for the same number of elements is advised.

  ```python
  > x.best_substitutions(top=5)
  Ca2+ [('Ca', 0.007486), ('Sr', 0.005256), ('K', 0.005169), ('Na', 0.005038), ('Eu', 0.004748)]
  Ti4+ [('Ti', 0.007006), ('Sc', 0.005946), ('Zr', 0.005772), ('Mg', 0.005232), ('Mn', 0.005046)]
  O2- [('O', 0.006997), ('F', 0.006419), ('N', 0.005402), ('Cl', 0.005153), ('C', 0.004748)]
  Best probability: 3.6697107125199996e-07
  ```

  This lists best top=10 substitution probabilities and the corresponding elements, by default for all elements in the composition, and the best value for 3-element substitution.
  The best substitutions for the selected elements can be specified.

  ```python
  > z.best_substitutions(['Ca2+','Ti4+'], top=10)
  Ca2+ [('Ca', 0.007486), ('Sr', 0.005256), ('K', 0.005169), ('Na', 0.005038), ('Eu', 0.004748), ('Y', 0.00446), ('Rb', 0.004435), ('Ba', 0.004227), ('Mg', 0.004051), ('La', 0.003906)]
  Ti4+ [('Ti', 0.007006), ('Sc', 0.005946), ('Zr', 0.005772), ('Mg', 0.005232), ('Mn', 0.005046), ('Nb', 0.004739), ('Cr', 0.004675), ('Y', 0.004629), ('V', 0.004548), ('Ta', 0.004236)]
  Best probability: 5.2446916e-05
  ```

  The LEAFs representation for compositions can be accessed.

  ```python
  > z.representation
  > Leaf('CaTiO3').representation
  [6.57610834e-01 2.85473622e-01 4.96881850e-01 7.70918750e-01
   7.97946231e-01 4.61860970e-01 4.49522401e-01 4.86912308e-01
   4.66420565e-01 4.48792432e-01 4.28762788e-01 5.17797120e-01
   5.44486303e-01 4.65229431e-01 2.51304365e-01 3.44853466e-01
   4.01373918e-01 4.96830716e-01 9.00359667e-01 6.10222815e-01
   3.40766216e-01 4.43959061e-01 1.45974281e-01 5.54307962e-01
   2.14342638e-01 2.44581614e-01 2.90158378e-01 2.24863698e-01
   2.68514251e-01 3.07195609e-01 1.62546708e-01 1.77402081e-01
   2.23923315e-01 6.41999013e-01 1.72413736e-01 2.27852236e-01
   2.89814108e-01 6.60000000e+01 3.11000000e+02 1.35943200e+02
   3.22040000e+03 5.40000000e+01 1.40000000e+01 5.34000000e+02
   1.28600000e+01 1.00000000e+01 1.20000000e+01 2.00000000e+00
   0.00000000e+00 2.40000000e+01 0.00000000e+00 6.00000000e+00
   8.00000000e+00 0.00000000e+00 1.40000000e+01 8.17750000e+01
   0.00000000e+00 2.25333333e-05 4.55000000e+02]
  ```

  To re-compute the LEAFs from the set of CIFs files, e.g.,
  if the features are required for the specific subset of inorganic materials,
  provide a list or a directory with CIFs, e.g. './testcifs':

  ```python

  > from LEAFeatures.leafs import CreateLeaf
  > newleaf = CreateLeaf()
  > myleafs = newleaf.generate_from_cifs('./testcifs', mode='dir')
  >
  > # use newly created LEAFs:
  > newx = Leaf("MgO", data=myleafs)
  > newx.representation
  array([2.5875000e-01, 4.0000000e-03, 8.7250000e-02, 3.4150000e-01,
         1.0700000e-01, 1.5250000e-02, 1.0000000e-03, 1.0000000e-03,
         1.0000000e-03, 9.1462500e-01, 5.5662500e-01, 1.3344375e+00,
         1.3321250e+00, 1.0133750e+00, 3.8000000e-02, 7.5250000e-02,
         6.9750000e-02, 3.2500000e-01, 7.8912500e-01, 6.6725000e-01,
         6.2100000e-01, 7.6412500e-01, 1.0000000e-03, 1.0000000e-03,
         2.4500000e-02, 3.9500000e-02, 3.4875000e-02, 1.0000000e-03,
         1.0000000e-03, 1.0000000e-03, 2.8375000e-02, 2.8250000e-02,
         1.8500000e-02, 1.7675000e-01, 6.1937500e-02, 6.1875000e-02,
         8.5625000e-02])


pkgId: 9229f74bca82576fddbbc71a3d263180a411bea48af713caf7e6fd7a62098df3
name: python-LHCbDIRAC-help
arch: noarch
version: 11.0.52
epoch: 0
release: 1
summary: Development documents and examples for LHCbDIRAC
url: https://gitlab.cern.ch/lhcb-dirac/LHCbDIRAC/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LHCbDIRAC-11.0.52-1.src.rpm
location_href: Packages/python-LHCbDIRAC-help-11.0.52-1.noarch.rpm
checksum_type: sha256
description:
  - Official source code repo: https://gitlab.cern.ch/lhcb-dirac/LHCbDIRAC
  - Issue tracker: https://its.cern.ch/jira/browse/LHCBDIRAC/
  - Developers Mailing list: https://groups.cern.ch/group/lhcb-dirac/default.aspx
  - KB articles about GitLab usage: https://cern.service-now.com/service-portal?id=kb_category&kb_category=5b93207b4f2e02404b4abc511310c75b


pkgId: 00223e810ddb1b4cadb24715c6dfe7045ba9d1cf18467e5efbe03a3e1a5587d3
name: python-LSFM-fusion-napari-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for LSFM-fusion-napari
url: https://pypi.org/project/LSFM-fusion-napari/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LSFM-fusion-napari-0.0.1-1.src.rpm
location_href: Packages/python-LSFM-fusion-napari-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
  <!--
  Don't miss the full getting started guide to set up your new package:
  https://github.com/napari/cookiecutter-napari-plugin#getting-started
  and review the napari docs for plugin developers:
  https://napari.org/stable/plugins/index.html
  -->

  You can install `LSFM-fusion-napari` via [pip]:
      pip install LSFM-fusion-napari
  To install latest development version :
      pip install git+https://github.com/peng-lab/LSFM-fusion-napari.git

  Contributions are very welcome. Tests can be run with [tox], please ensure
  the coverage at least stays the same before you submit a pull request.

  Distributed under the terms of the [BSD-3] license,
  "LSFM-fusion-napari" is free and open source software

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
  [file an issue]: https://github.com/peng-lab/LSFM-fusion-napari/issues
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/

rpm_license:
  Copyright (c) 2024, lennart kowitz 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 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: 45f4a357175b9f4cfe6fe224bf057f533778cbfe9358f03ba6df1479c1f6aefd
name: python-LanusStats-help
arch: noarch
version: 1.7.4
epoch: 0
release: 1
summary: Development documents and examples for LanusStats
url: https://github.com/federicorabanos
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LanusStats-1.7.4-1.src.rpm
location_href: Packages/python-LanusStats-help-1.7.4-1.noarch.rpm
checksum_type: sha256
description:
  Para saber que páginas contienen un módulo para scrapear, podes hacer:
  ```bash
  get_available_pages()
  ```
  Para saber que ligas tienen las páginas de la función anterior, podes hacer:
  ```bash
  get_available_leagues(page)
  ```
  Para saber que temporadas tienen las ligas de las páginas de la función anterior, podes hacer:
  ```bash
  get_available_season_for_leagues(page, league)
  ```

  Importo la clase de esta manera:
  ```bash
  import LanusStats as ls
  fbref = ls.Fbref()
  ```
  Todas las funciones deben tener el fbref. delante de ellas
  * Para scrapear información de los equipos se puede usar ```get_teams_season_stats```. Ejemplo:
  ```bash
  get_teams_season_stats('gca', 'Copa de la Liga', season='2024', save_csv=False, stats_vs=False, change_columns_names=False, add_page_name=False)
  ```
  **change_columns_names** te permite ponerle el nombre a columnas de tipo Unnamed: 0
  **add_page_name** le agrega el nombre de la página a las columnas, hay veces que se repiten los nombres entre páginas
  **save_csv** exporta la tabla a un csv
  **stats_vs** te permite scrapear las tablas de estadísticas vs que en Fbref está la posibilidad
  Si esto lo queres hacer todo junto, podes usar ```get_vs_and_teams_season_stats```. Ejemplo:
  ```bash
  get_vs_and_teams_season_stats('gca', 'Copa de la Liga', season='2024', save_excel=False, stats_vs=False, change_columns_names=False, add_page_name=False)
  ```
  Esto te devuelve dos DataFrames, uno para las estadísticas a favor y otro en contra.
  **save_excel** te permite exportarlo a un .xlsx que contiene dos páginas.
  Para terminar, con ```get_all_teams_season_stats``` podes scrapear TODAS las estadísticas que esten en la pagina. Ejemplo:
  ```bash
  get_all_teams_season_stats('Copa de la Liga', '2024', save_csv=False, stats_vs=False, change_columns_names=False, add_page_name=False)
  ```
  * Para scrapear data de los jugadores se pueden usar:
  ```bash
  get_player_season_stats('gca', 'Copa de la Liga', save_csv=False, add_page_name=False)
  ```
  Y si quiero scrapear todas las estadísticas en una
  ```bash
  get_all_player_season_stats("Copa de la Liga", "2024", save_csv=False, add_page_name=False)
  ```
  * Del perfil de un jugar se puede sacar los percentiles y las similutdes (si las tiene)
  ```bash
  get_player_percentiles("https://fbref.com/en/players/bc7dc64d/Bukayo-Saka")
  get_player_similarities("https://fbref.com/en/players/bc7dc64d/Bukayo-Saka")
  ```
  * De un partido en particular se puede sacar los tiros y las estadísticas generales (si las tiene)
  ```bash
  get_match_shots("https://fbref.com/en/matches/77d7e2d6/Arsenal-Luton-Town-April-3-2024-Premier-League")
  get_general_match_team_stats("https://fbref.com/en/matches/77d7e2d6/Arsenal-Luton-Town-April-3-2024-Premier-League")
  ```
  * Si queres scrapear la tabla de posiciones de una liga, podes:
  ```bash
  get_tournament_table("https://fbref.com/en/comps/9/Premier-League-Stats")
  ```

  ```bash
  import LanusStats as ls
  fotmob = ls.FotMob()
  ```
  * Para obtener las distintas tablas que pueden haber en la UI de Fotmob ([ejemplo](https://www.fotmob.com/es/leagues/47/table/premier-league)) pueden usar:
  ```bash
  get_season_tables("Premier League", "2022/2023", "xg")
  ```
  * Para obtener información de estadísticas de una temporada ([ejemplo](https://www.fotmob.com/es/leagues/47/stats/premier-league)):
  ** De los jugadores puedes usar:
  ```bash
  get_players_stats_season("Premier League", "2023/2024", "expected_assists_per_90")
  ```
  ** De los equipos puedes usar:
  ```bash
  get_teams_stats_season("Premier League", "2023/2024", "poss_won_att_3rd_team")
  ```
  * De un partido ([ejemplo](https://www.fotmob.com/es/matches/afc-bournemouth-vs-manchester-united/2yrx85#4193851)) la información que puedes sacar es de:
  ** Mapa de tiros:
  ```bash
  get_match_shotmap(4193851)
  ```
  ** Estadísticas generales de los equipos:
  ```bash
  get_general_match_stats(4193851)
  ```
  Aclaración: El id de parametro es el que se encuentra en la url, ejemplo: https://www.fotmob.com/es/matches/afc-bournemouth-vs-manchester-united/2yrx85#4193851
  * También puedes obtener información de un jugador:
  ** Mapa de tiros ([ejemplo](https://www.fotmob.com/es/players/1203665/alejandro-garnacho)):
  ```bash
  get_player_shotmap("1", "0", 1203665)
  ```
  El 3º parametro es el id que se encuentra en la url, ejemplo: https://www.fotmob.com/es/players/1203665/alejandro-garnacho
  El primer y segundo parametro salen del dropdown de la página de FotMob:
  - El primero es la posición de la temporada en el dropdown, arrancando desde el 0. Es decir, si quiero de la primera temporada que aparece en el dropdown, el valor será 0, si es de la 2º, será 1 y así sucesivamente.
  - El segundo es la posición de la competición dentro de una temporada. La que aparezca primera será 0 y asi.

  ```bash
  import LanusStats as ls
  threesixfivescores = ls.ThreeSixFiveScores()
  ```

  ```bash
  import LanusStats as ls
  sofascore = ls.SofaScore()
  ```
  * De un partido ([ejemplo](https://www.sofascore.com/arsenal-manchester-united/KR#id:11352532)) podes sacar los disparos:
  ```bash
  get_match_shotmap("https://www.sofascore.com/arsenal-manchester-united/KR#id:11352532", save_csv=True)
  ```
  **match_url** se pone la url entera de la página del partido de Sofascore.
  **save_csv** si guardas el dataframe que te devuelve en un csv
  * También de un partido podes sacar las estadísticas de los jugadores:
  ```bash
  get_players_match_stats("https://www.sofascore.com/arsenal-manchester-united/KR#id:11352532")
  ```
  **match_url** se pone la url entera de la página del partido de Sofascore.
  Aclaración, te devuelve una lista de dataframes, el primero (ó [0]) es del local y el segundo ó [1] es del visitante
  * También de un partido podes sacar las posiciones promedio:
  ```bash
  get_players_average_positions("https://www.sofascore.com/arsenal-manchester-united/KR#id:11352532")
  ```
  **match_url** se pone la url entera de la página del partido de Sofascore.
  Aclaración, te devuelve una lista de dataframes, el primero (ó [0]) es del local y el segundo ó [1] es del visitante
  * También podes obtener la información de los lineups:
  ```bash
  get_lineups("https://www.sofascore.com/arsenal-manchester-united/KR#id:11352532")
  ```
  * Por último dentro de un partido podes sacar el mapa de calor de cada uno dentro del partido:
  ```bash
  get_player_heatmap("https://www.sofascore.com/arsenal-manchester-united/KR#id:11352532", "Alejandro Garnacho")
  ```
  Aclaración: el nombre del jugador debe ser tal cual lo muestra SofaScore.
  * Se puede sacar el mapa de calor de un jugador de cada torneo, si es que lo tiene:
  ```bash
  get_player_season_heatmap("Argentina Liga Profesional", "2024", 832213)
  ```
  La liga y la temporada salen de las funciones generales ya vistas y el tercer parámetro es el id del jugador que se puede ver en la página de jugador: https://www.sofascore.com/player/joaquin-pereyra/832213. Es el número al final del link
  * Por último, se pueden scrapear las estadísticas de los jugadores en un [torneo](https://www.sofascore.com/tournament/football/argentina/liga-profesional-de-futbol/155#id:57478):
  ```bash
  scrape_league_stats(league="Argentina Liga Profesional", season="2024", save_csv=False, accumulation="per90", selected_positions= ["Goalkeepers"])
  ```
  **league** Liga habilitada en get_available_leagues("Sofascore")
  **season** Temporada habilitada en get_available_season_for_leagues("Sofascore", league)
  **save_csv** si guardar el dataframe en un csv o no
  **accumulation** como pedir las estadísticas. Valores posibles: total, per90, perMatch
  **selected_positions** que grupo de jugadores traer. Valores posibles: ['Goalkeepers', 'Defenders', 'Midfielders', 'Forwards']

  ```bash
  import LanusStats as ls
  transfermarkt = ls.Transfermarkt()
  ```
  * Información de la valuación de los planteles (general):
  ```bash
  get_league_teams_valuations(league="Primera Division Argentina", season="2024")
  ```
  **league (str)**: Liga que este en get_possible_leagues_for_page("Transfermarkt")
  **season(str)**: Cualquier temporada que este en la interfaz de Transfermarkt (por ejemplo: 2024, 2023/2024)
  * Información de los planteles en particular
  ```bash
  scrape_players_for_teams(team_name="Club Atletico Lanus", team_id="333", season="2024")
  ```
  Ejemplo: https://www.transfermarkt.com.ar/club-atletico-lanus/startseite/verein/333
  **team_name (str)** Nombre respetando la URL (Club Atletico Lanus). No poner guiones medios.
  **team_id (str)** ID que está al final de la URL (333)
  **season(str)**: Cualquier temporada que este en la interfaz de Transfermarkt (por ejemplo: 2024, 2023/2024)
  * Información de jugadores (ejemplo de URL: https://www.transfermarkt.com.ar/marcelino-moreno/profil/spieler/456617). Transferencias, posiciones jugadas, partidos jugadores, valoraciones, etc.:
  ```bash
  get_player_transfer_history(player_id="456617")
  ```
  **player_id (str)** ID del jugador, se saca de la URL.
  ```bash
  get_player_market_value(player_id="456617")
  ```
  **player_id (str)** ID del jugador, se saca de la URL.
  ```bash
  get_player_positions_played(player_name="Marcelino Moreno", player_id="456617")
  ```
  **player_name (str)** Nombre del jugador.
  **player_id (str)** ID del jugador, se saca de la URL.
  ```bash
  get_keepers_penalty_data(player_name="Emiliano Martinez", player_id="111873")
  ```
  **player_name (str)** Nombre del jugador (arquero).
  **player_id (str)** ID del jugador, se saca de la URL.
  ```bash
  get_player_played_data(player_name="Emiliano Martinez", player_id="111873")
  ```
  **player_name (str)** Nombre del jugador.
  **player_id (str)** ID del jugador, se saca de la URL.

  Hay visualizaciones seteadas para hacer desde una función que scrapean usando las funciones de la libreria y visualizan la información de cierta manera para que se puede customizar o usar derecho.
  * Plotear percentiles de los jugadores de Fbref en un grafico de MPLSoccer
  ```bash
  ls.visualizations.fbref_plot_player_percentiles(path="https://fbref.com/en/players/058c938c/Marcelino-Moreno", image=None, chart_stats = ["shots", "passes", "defense"], save_image=True, name_extra = "- Lanus", credit_extra= "")
  ```
  **path** Link del jugador en Fbref
  **image** path de una imagen que quieras usar, se recomienda pasarla por https://crop-circle.imageonline.co/
  **chart_stats** agregar rectangulos y nombres de las estadísticas al gráfico
  **save_image** si guarda el png de la visualización
  **name_extra** agregarle un string al título
  **credit_extra** agregarle un string a los créditos
  Ejemplo: ![Marcelino Moreno fbref percentile plot](https://github.com/federicorabanos/LanusStats/assets/101477588/d2c41dd6-8271-498f-8849-73ee093529b4)
  * Plotear match momentum de FotMob
  ```bash
  ls.visualizations.fotmob_match_momentum_plot(match_id=4193851, save_fig=False)
  ```
  **match_id** es el que se encuentra en la url, ejemplo: https://www.fotmob.com/es/matches/afc-bournemouth-vs-manchester-united/2yrx85#4193851
  **save_fig** si guardo la imagen o no
  * Plotear hexbins de tiros de jugadores de FotMob
  ```bash
  ls.visualizations.fotmob_hexbin_shotmap('La Liga', '2023/2024', 711231)
  ```
  **league** Liga habilitada en get_available_leagues("Fotmob")
  **season** Temporada habilitada.
  **player_id** Id del jugador de FotMob. Ejemplo: https://www.fotmob.com/es/players/711231/gorka-guruzeta el número de la url es el id del jugador.
  * Plotear un mapa de disparos de un partido de 365Scores
  ```bash
  ls.visualizations.threesixfivescores_match_shotmap('https://www.365scores.com/es-mx/football/match/copa-sudamericana-389/lanus-metropolitanos-fc-869-13830-389#id=4072240')
  ```
  Hay que poner la url del partido entera. Va a devolver info si es que tiene un mapa de tiros el partido.
  * Plotear valor de mercado según Transfermarkt a lo largo de la carrera:
  ```bash
  ls.visualizations.transfermarkt_player_market_value(player_id='111873')


pkgId: 4a552ea18c407ce43a46c06733da05636a93bea92303a4b2cc47da475cdc0677
name: python-Leonardo-Ai-SDK-help
arch: noarch
version: 6.3.0
epoch: 0
release: 1
summary: Development documents and examples for Leonardo-Ai-SDK
url: https://github.com/Leonardo-Interactive/leonardo-python-sdk.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Leonardo-Ai-SDK-6.3.0-1.src.rpm
location_href: Packages/python-Leonardo-Ai-SDK-help-6.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://codespaces.new/Leonardo-Interactive/leonardo-python-sdk.git/tree/main"><img src="https://github.com/codespaces/badge.svg" /></a>

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


  Rest Endpoints: Leonardo.Ai API OpenAPI specification.
  <!-- End Summary [summary] -->

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

  <!-- $toc-max-depth=2 -->
  * [Leonardo-Ai-SDK](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#leonardo-ai-sdk)
    * [SDK Installation](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#sdk-installation)
    * [IDE Support](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#ide-support)
    * [SDK Example Usage](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#sdk-example-usage)
    * [Available Resources and Operations](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#available-resources-and-operations)
    * [Retries](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#retries)
    * [Error Handling](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#error-handling)
    * [Custom HTTP Client](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#custom-http-client)
    * [Server Selection](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#server-selection)
    * [Authentication](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#authentication)
    * [Debugging](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/#debugging)

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

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


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



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

  ```bash
  pip install Leonardo-Ai-SDK
  ```



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

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

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




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

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

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




  ```python

  from leonardo_ai_sdk import LeonardoAiSDK

  with LeonardoAiSDK(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as leonardo_ai_sdk:

      res = leonardo_ai_sdk.init_images.delete_init_image_by_id(id="<id>")

      assert res.object is not None

      
      print(res.object)
  ```

  </br>

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

  import asyncio
  from leonardo_ai_sdk import LeonardoAiSDK

  async def main():
      async with LeonardoAiSDK(
          bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
      ) as leonardo_ai_sdk:

          res = await leonardo_ai_sdk.init_images.delete_init_image_by_id_async(id="<id>")

          assert res.object is not None

          
          print(res.object)

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

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


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



  * [create_dataset](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/dataset/README.md#create_dataset) - Create a Dataset
  * [delete_dataset_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/dataset/README.md#delete_dataset_by_id) - Delete a Single Dataset by ID
  * [get_dataset_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/dataset/README.md#get_dataset_by_id) - Get a Single Dataset by ID
  * [upload_dataset_image](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/dataset/README.md#upload_dataset_image) - Upload dataset image
  * [upload_dataset_image_from_gen](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/dataset/README.md#upload_dataset_image_from_gen) - Upload a Single Generated Image to a Dataset



  * [create_element](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/elements/README.md#create_element) - Train a Custom Element
  * [delete_element_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/elements/README.md#delete_element_by_id) - Delete a Single Custom Element by ID
  * [get_element_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/elements/README.md#get_element_by_id) - Get a Single Custom Element by ID
  * [list_elements](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/elements/README.md#list_elements) - List Elements



  * [create_generation](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/image/README.md#create_generation) - Create a Generation of Images
  * [delete_generation_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/image/README.md#delete_generation_by_id) - Delete a Single Generation
  * [get_generation_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/image/README.md#get_generation_by_id) - Get a Single Generation
  * [get_generations_by_user_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/image/README.md#get_generations_by_user_id) - Get generations by user ID



  * [delete_init_image_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/initimages/README.md#delete_init_image_by_id) - Delete init image
  * [get_init_image_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/initimages/README.md#get_init_image_by_id) - Get single init image
  * [upload_canvas_init_image](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/initimages/README.md#upload_canvas_init_image) - Upload Canvas Editor init and mask image
  * [upload_init_image](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/initimages/README.md#upload_init_image) - Upload init image




  * [create_model](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/models/README.md#create_model) - Train a Custom Model
  * [delete_model_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/models/README.md#delete_model_by_id) - Delete a Single Custom Model by ID
  * [get_model_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/models/README.md#get_model_by_id) - Get a Single Custom Model by ID
  * [list_platform_models](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/models/README.md#list_platform_models) - List Platform Models



  * [create_svd_motion_generation](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/motion/README.md#create_svd_motion_generation) - Create SVD Motion Generation



  * [pricing_calculator](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/pricingcalculator/README.md#pricing_calculator) - Calculating API Cost



  * [prompt_improve](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/prompt/README.md#prompt_improve) - Improve a Prompt
  * [prompt_random](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/prompt/README.md#prompt_random) - Generate a Random prompt



  * [create_lcm_generation](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/realtimecanvas/README.md#create_lcm_generation) - Create LCM Generation
  * [perform_alchemy_upscale_lcm](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/realtimecanvas/README.md#perform_alchemy_upscale_lcm) - Perform Alchemy Upscale on a LCM image
  * [perform_inpainting_lcm](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/realtimecanvas/README.md#perform_inpainting_lcm) - Perform inpainting on a LCM image
  * [perform_instant_refine](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/realtimecanvas/README.md#perform_instant_refine) - Perform instant refine on a LCM image



  * [create_texture_generation](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/texture/README.md#create_texture_generation) - Create Texture Generation
  * [delete_texture_generation_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/texture/README.md#delete_texture_generation_by_id) - Delete Texture Generation by ID
  * [get_texture_generation_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/texture/README.md#get_texture_generation_by_id) - Get Texture Generation by ID
  * [get_texture_generations_by_model_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/texture/README.md#get_texture_generations_by_model_id) - Get texture generations by 3D Model ID



  * [delete3_d_model_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/threedmodelassets/README.md#delete3_d_model_by_id) - Delete 3D Model by ID
  * [get3_d_model_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/threedmodelassets/README.md#get3_d_model_by_id) - Get 3D Model by ID
  * [get3_d_models_by_user_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/threedmodelassets/README.md#get3_d_models_by_user_id) - Get 3D models by user ID
  * [upload_model_asset](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/threedmodelassets/README.md#upload_model_asset) - Upload 3D Model



  * [get_user_self](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/user/README.md#get_user_self) - Get user information



  * [create_universal_upscaler_job](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/variation/README.md#create_universal_upscaler_job) - Create using Universal Upscaler
  * [create_variation_no_bg](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/variation/README.md#create_variation_no_bg) - Create no background
  * [create_variation_unzoom](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/variation/README.md#create_variation_unzoom) - Create unzoom
  * [create_variation_upscale](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/variation/README.md#create_variation_upscale) - Create upscale
  * [get_variation_by_id](https://github.com/Leonardo-Interactive/leonardo-python-sdk/blob/master/docs/sdks/variation/README.md#get_variation_by_id) - Get variation by ID

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







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


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

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

  with LeonardoAiSDK(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as leonardo_ai_sdk:

      res = leonardo_ai_sdk.init_images.delete_init_image_by_id(id="<id>",
          RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

      assert res.object is not None

      
      print(res.object)

  ```

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

  with LeonardoAiSDK(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as leonardo_ai_sdk:

      res = leonardo_ai_sdk.init_images.delete_init_image_by_id(id="<id>")

      assert res.object is not None

      
      print(res.object)

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

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


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

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

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

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

  | Error Type      | Status Code | Content Type |
  | --------------- | ----------- | ------------ |
  | errors.SDKError | 4XX, 5XX    | \*/\*        |



  ```python
  from leonardo_ai_sdk import LeonardoAiSDK
  from leonardo_ai_sdk.models import errors

  with LeonardoAiSDK(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as leonardo_ai_sdk:
      res = None
      try:

          res = leonardo_ai_sdk.init_images.delete_init_image_by_id(id="<id>")

          assert res.object is not None

          
          print(res.object)

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



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


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

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

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

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

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

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

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

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

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

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



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




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

  with LeonardoAiSDK(
      server_url="https://cloud.leonardo.ai/api/rest/v1",
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as leonardo_ai_sdk:

      res = leonardo_ai_sdk.init_images.delete_init_image_by_id(id="<id>")

      assert res.object is not None

      
      print(res.object)

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



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




  This SDK supports the following security scheme globally:

  | Name          | Type | Scheme      |
  | ------------- | ---- | ----------- |
  | `bearer_auth` | http | HTTP Bearer |

  To authenticate with the API the `bearer_auth` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from leonardo_ai_sdk import LeonardoAiSDK

  with LeonardoAiSDK(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as leonardo_ai_sdk:

      res = leonardo_ai_sdk.init_images.delete_init_image_by_id(id="<id>")

      assert res.object is not None

      
      print(res.object)

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

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


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

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

  logging.basicConfig(level=logging.DEBUG)
  s = LeonardoAiSDK(debug_logger=logging.getLogger("leonardo_ai_sdk"))
  ```
  <!-- End Debugging [debug] -->

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





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



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Feel free to open a PR or a Github issue as a proof of concept and we'll do our best to include it in a future release !


pkgId: 0a4d61da9d71dba0f6a1b265f29031aee952b0c60de7d4e236a7268997945d31
name: python-LeosToDoList-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for LeosToDoList
url: https://pypi.org/project/LeosToDoList/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LeosToDoList-0.1.5-1.src.rpm
location_href: Packages/python-LeosToDoList-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  Benutzer kann eine einfache Aufgabenliste verwalten und die Aufgaben werden in einer JSON-Datei gespeichert.
  Für jede Aufgabe kann ein Fälligkeitsdatum, eine Beschreibung sowie ein "Abgeschlossen"-Status festgelegt werden.
  Zudem können mehrere Benutzer individuell angelegt werden, sodass jeder Benutzer auf seinen eigenen Json-File zurückgreift.


pkgId: 0d981584481513ec0108b53b4170c686cd838c308f1dcc15398ca9142130d575
name: python-LightSim2Grid-debuginfo
arch: aarch64
version: 0.10.0
epoch: 0
release: 1
summary: Debug information for package python-LightSim2Grid
url: https://github.com/grid2op/lightsim2grid/
rpm_license: MPL 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-LightSim2Grid-0.10.0-1.src.rpm
location_href: Packages/python-LightSim2Grid-debuginfo-0.10.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-LightSim2Grid.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 6905c492096f030c42c9bc234282249f93610a62190f13ca0ebe3bd864c52249
name: python-LightSim2Grid-debugsource
arch: aarch64
version: 0.10.0
epoch: 0
release: 1
summary: Debug sources for package python-LightSim2Grid
url: https://github.com/grid2op/lightsim2grid/
rpm_license: MPL 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-LightSim2Grid-0.10.0-1.src.rpm
location_href: Packages/python-LightSim2Grid-debugsource-0.10.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-LightSim2Grid.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 6299a633fcb6d2eff9b2d2266f7b09fa29586798dd2e73429b51077e8c0a6855
name: python-LightSim2Grid-help
arch: aarch64
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for LightSim2Grid
url: https://github.com/grid2op/lightsim2grid/
rpm_license: MPL 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LightSim2Grid-0.10.0-1.src.rpm
location_href: Packages/python-LightSim2Grid-help-0.10.0-1.aarch64.rpm
checksum_type: sha256
description:
  Provide a fast backend for grid2op using c++ KLU and Eigen librairies. Its primary goal is to serve as a fast
  backend for the grid2op platform, used primarily as a testbed platform for sequential decision making in
  the world of power system.

  See the [Disclaimer](DISCLAIMER.md) to have a more detailed view on what is and what is not this package. For example
  this package should not be used for detailed power system computations or simulations.

  *   [1 Usage](#Usage)
      *   [1.1. As a grid2op backend (preferred method)](#1-as-a-grid2op-backend-preferred-method)
      *   [1.2. replacement of pandapower "newtonpf" method (advanced method)](#2-replacement-of-pandapower-newtonpf-method-advanced-method)
  *   [2 Installation (from pypi official repository, recommended)](#Installation-from-pypi-official-repository-recommended)
  *   [3 Installation (from source, for more advanced user)](#Installation-from-source-for-more-advanced-user)
  *   [4. Benchmarks](#Benchmarks)
  *   [5. Philosophy](#Philosophy)
  *   [6. Miscellaneous](#Miscellaneous)
      * [6.1 Customization of the compilation](#Customization-of-the-compilation)
      * [6.2 Profile the code](#Profile-the-code)
      * [6.3 Local testing](#Local-testing)
      * [6.4 Tests performed automatically](#Tests-performed-automatically)
      * [5.5 Known issues](#Known-issues)



  Once installed (don't forget, if you used the optional virtual env
  above you need to load it with `source venv/bin/activate`) you can
  use it as any python package.


  This functionality requires you to have grid2op installed, with at least version 0.7.0. You can install it with

  ```commandline
  pip install grid2op>=1.6.4
  ```

  Then you can use a LightSimBackend instead of the default PandapowerBackend this way:

  ```python3
  import grid2op
  from lightsim2grid import LightSimBackend
  env_name = "l2rpn_case14_sandbox"  # or any other name.
  env = grid2op.make(env_name, backend=LightSimBackend())


  ```
  And you are good to go.


  It is also possible to use directly the "solver" part of lightsim2grid.

  Suppose you somehow get:
  - `Ybus` the admittance matrix of your powersystem, for example given by pandapower
    (will be converted to a scipy `sparse.csc_matrix` )
  - `V0` the (complex) voltage vector at each bus, for example given by pandapower
  - `Sbus` the (complex) power absorb at each bus, for example as given by pandapower
  - `ref` Ids of the slack buses (added in version 0.5.6 to match recent pandapower changes)
  - `pv` list of PV buses
  - `pq` list of PQ buses
  - `ppci` a ppc internal pandapower test case (or dictionary, is used to retrieve the coefficients associated to each slack bus)
  - `options` list of pandapower "options" (or dictionary with keys `max_iteration` and `tolerance_mva`)

  You can define replace the `newtonpf` function of `pandapower.pandapower.newtonpf` function with the following
  piece of code:
  ```python
  from lightsim2grid.newtonpf import newtonpf
  V, converged, iterations, J = newtonpf(Ybus, V, Sbus, ref, weights, pv, pq, ppci, options)
  ```

  This function uses the KLU algorithm (when available) and a c++ implementation of a Newton solver for speed.



  Since version 0.5.3, lightsim2grid is can be installed like most python packages, with a call to:
  `python -m pip install lightsim2grid`

  It includes faster grid2op backend and the `SuiteSparse` faster `KLU` solver, even on windows. This is definitely the
  easiest method to install lightsim2grid on your system and have it running.

  Note though that these packages have been compiled on a different platform that the one you are using. You might still
  get some benefit (in terms of performances) to install it from your on your machine with the proper compilations flags (
  see section [6.1 Customization of the compilation](#Customization-of-the-compilation) for more information)

  Pypi packages are available for linux (`x86_64` cpu architecture), windows (`x86_64` cpu architecture) and macos (`x86_64` cpu architecture) with python versions:

  - 3.7
  - 3.8
  - 3.9
  - 3.10 (lightsim2grid >= 0.6.1)
  - 3.11 (lightsim2grid >= 0.7.1)
  - 3.12 (lightsim2grid >= 0.7.5)
  - 3.13 (lightsim2grid >= 0.9.2.post2)


  As from version 0.8.2, we also distribute windows `arm64` and macos `arm64` binaries of lightsim2grid that can be installed
  directly with pip too (requires python >= 3.8 for macos and python >= 3.9 for windows). We do not currently produce `arm64` (`aarch64`) linux binaries because it takes too long to build. If you really want them, let us know and we'll see what we can do.


  **NB** on some version of MacOs (thanks Apple !), especially the one using M1 or M2 chip, lightsim2grid is only available
  on pypi starting from version 0.7.3 We attempted to deliver arm64 lightsim2grid version but we could not test them. So if you
  want a reliable working and tested version of lightsim2grid on newest version of macos (with M1 or M2 chips for example) please
  use lightsim2grid >= 0.8.2

  **NB** we do not currently build any 32 bits lightsim2grid libraries.



  See the official documentation at [Install from source](https://lightsim2grid.readthedocs.io/en/latest/install_from_source.html) for more information



  Lightsim2grid is significantly faster than pandapower when used with grid2op for all kind of environment size (sometimes
  more than 30x faster - making 30 steps while pandapower makes one).


  If you prefer to use the dedicated lightsim2grid `SecurityAnalysis` or `TimeSerie` classes you can even expect another 10-20x
  speed ups compared to grid2op with lightsim2grid (sometimes more than 300x faster than grid2op with pandapower).

  For more information (including the exact way to reproduce these results, as well as the computer used), you can consult the dedicated [Benchmarks](https://lightsim2grid.readthedocs.io/en/latest/benchmarks.html) page on the documentation.


  Lightsim2grid aims at providing a somewhat efficient (in terms of computation speed) backend targeting the
  grid2op platform.

  It provides a c++ api, compatible with grid2op that is able to compute flows (and voltages and reactive power) from
  a given grid. This grid can be modified according to grid2op mechanism (see more information in the [official
  grid2Op documentation](https://grid2op.readthedocs.io/en/latest/index.html) ).

  This code do not aim at providing state of the art solver in term of performances nor in terms of realism in the
  modeling of power system elements (*eg* loads, generators, powerlines, transformers, etc.).

  Lightsim2grid codebase is "organized" in 4 different parts:

  1) modify the elements (*eg* disconnecting a powerline or changing the voltage magnitude setpoint of a
     generator, or any other action made possible by grid2op)
  2) generate the `Ybus` (sparse) complex admitance matrix and `Sbus` complex injection vector from the state of the
     powergrid (*eg* physical properties of each elements, which elements are in service, which power is produce at
     each generators and consumed at each loads, what is the grid topology etc.)
  3) solving for the complex voltage `V` (and part of the `Sbus` vector) the equation `V.(Ybus.V)* = Sbus` with the
     "standard" "powerflow constraints"
     (*eg* the voltage magnitude of `V` is set at given components, and on other it's the imaginary part of `Sbus`)
  4) computes the active power, reactive power, flow on powerllines etc. from the `V` and `Sbus` complex vectors computed
     at step 3).

  Step 1, 2 and 4 are done in the [GridModel](https://lightsim2grid.readthedocs.io/en/latest/gridmodel.html#lightsim2grid.gridmodel.GridModel) class.

  Step 3 is performed thanks to a "powerflow solver".


  For now some basic "solver" (*eg* the program that performs points `3.` above) are available, based on the
  Gauss Seidel or the Newton-Raphson methods to perform "powerflows".

  Nothing prevents any other "solver" to be used with lightsim2grid and thus with grid2op. For this, you simply need to
  implement, in c++ a "lightsim2grid solver" which mainly consists in defining a function:
  ```c
  bool compute_pf(const Eigen::SparseMatrix<cplx_type> & Ybus,  // the admittance matrix
                  CplxVect & V,  // store the results of the powerflow and the Vinit !
                  const CplxVect & Sbus,  // the injection vector
                  const Eigen::VectorXi & ref,  // bus id participating to the distributed slack
                  const RealVect & slack_weights,  // slack weights for each bus
                  const Eigen::VectorXi & pv,  // (might be ignored) index of the components of Sbus should be computed
                  const Eigen::VectorXi & pq,  // (might be ignored) index of the components of |V| should be computed
                  int max_iter,  // maximum number of iteration (might be ignored)
                  real_type tol  // solver tolerance
                  );
  ```

  The types used are:

  - `real_type`: double => type representing the real number
  - `cplx_type` :  std::complex<real_type> => type representing the complex number
  - `CplxVect` : Eigen::Matrix<cplx_type, Eigen::Dynamic, 1> => type representing a vector of complex numbers
  - `RealVect` : Eigen::Matrix<real_type, Eigen::Dynamic, 1> => type representing a vector of real numbers
  - `Eigen::VectorXi` => represents a vector of integer
  - `Eigen::SparseMatrix<cplx_type>` => represents a sparse matrix

  See for example [BaseNRSolver](./src/BaseNRSolver.h) for the implementation of a Newton Raphson solver (it requires some "linear solvers", more details about that are given in the section bellow)

  Any contribution in this area is more than welcome.

  **NB** For now the "solver" only uses these above information to perform the powerflow. If a more
  "in depth" solution needs to be implemented, let us know with a github issue. For example, it could be totally fine that a proposed "solver" uses direct information about the elements (powerline, topology etc.) of the grid in order to perform some powerflow.

  **NB** It is not mandatory to "embed" all the code of the solver in lightsim2grid. Thanks to different customization,
  it is perfectly possible to install a given "lightsim solver" only if certain conditions are met. For example, on
  windows based machine, the SuiteSparse library cannot be easily compiled, and the KLUSolver is then not available.

  **NB** It would be totally fine if some "lightsim2grid" solvers are available only if some packages are installed on the
  machine for example.



  In lightsim2grid (c++ part) it is also possible, thanks to the use of "template meta programming" to
  not recode the Newton Raphson algorithm (or the DC powerflow algorithm) and to leverage the
  use of a linear solver.

  A "linear solver" is anything that can implement 3 basic functions:

  - `initialize(const Eigen::SparseMatrix<real_type> & J)` : initialize the solver and prepare it to solve for linear systems `J.x = b` (usually called once per powerflow)
  - `ErrorType solve(const Eigen::SparseMatrix<real_type> & J, RealVect & b, bool has_just_been_inialized)`: effectively solves `J.x = b` (usually called multiple times per powerflow)
  - `ErrorType reset()`: clear the state of the solver (usually performed at the end of a powerflow
    to reset the state to a "blank" / "as if it was just initialized" state)

  Some example are given in the c++ code "KLUSolver.h", "SparLUSolver.h" and "NICSLU.h"

  This usage usually takes approximately around 20 / 30 lines of c++ code (not counting the comments, and boiler code for exception handling for example).



  If you use this package in one of your work, please cite:
  ```
  @misc{lightsim2grid,
      author = {B. Donnot},
      title = {{Lightsim2grid - A c++ backend targeting the Grid2Op platform. }},
      year = {2020},
      publisher = {GitHub},
      journal = {GitHub repository},
      howpublished = {\url{https://GitHub.com/Grid2Op/lightsim2grid}},
  }
  ```





  For that, you need to declare the environment variables `PATH_NICSLU` that points to a valid installation of
  the NICSLU package (see https://github.com/chenxm1986/nicslu).
  For example: `export PATH_NICSLU=/home/user/Documents/nicslu/nicslu202103`


  For that, you need to declare the environment variables `PATH_CKTSO` that points to a valid installation of
  the NICSLU package (see https://github.com/chenxm1986/cktso).
  For example: `export PATH_NICSLU=/home/user/Documents/cktso`


  By default, at least on ubuntu, only the "-O2" compiler flags is used. To use the O3 optimization flag, you need
  to specify the `__O3_OPTIM` environment variable: `set __O3_OPTIM=1` (or `$Env:__O3_OPTIM=1` in powershell) before the compilation (so before
  `python3 setup.py build` or `python -m pip install -e .`)

  This compilation argument will increase the compilation time, but will make the package faster.


  By default, for portability, we do not compile with `-march=native` flags. This lead to some error on some platform.
  If you want to further improve the performances.

  You can `set __COMPILE_MARCHNATIVE=1` to enable it before the compilation (so before
  `python3 setup.py build` or `python -m pip install -e .`)


  This is a work in progress for now. And it is far from perfect, and probably only work on linux.

  See https://github.com/xflash96/pybind11_package_example/blob/main/tutorial.md#perf for more details.

  ```commandline
  cd benchmarks
  perf record ./test_profile.py
  perf report
  ```


  And some official tests, to make sure the solver returns the same results as pandapower
  are performed in "lightsim2grid/tests"
  ```bash
  cd lightsim2grid/tests
  python -m unittest discover
  ```

  This tests ensure that the results given by this simulator are consistent with the one given by pandapower when
  using the Newton-Raphson algorithm, with a single slack bus, without enforcing q limits on the generators etc.

  **NB** to run these tests you need to install grid2op from source otherwise all the test of the LightSim2gridBackend
  will fail. In order to do so you can do:
  ```
  git clone https://github.com/Grid2Op/grid2op.git
  cd Grid2Op
  pip3 install -U -e .
  cd ..
  ```


  Some tests are performed automatically on standard platform each time modifications are made in the lightsim2grid code.

  These tests include, for now, compilation on gcc (version 8, 12 and 13) and clang (version 11, 16 and 17).

  **NB** Intermediate versions of clang and gcc (*eg* gcc 9 or clang 12) are not tested regularly, but lightsim2grid used to work on these.
  We suppose that if it works on *eg* clang 10 and clang 14 then it compiles also on all intermediate versions.

  **NB** Package might work (we never tested it) on earlier version of these compilers.
  The only "real" requirement for lightsim2grid is to have a compiler supporting c++11
  (at least).




  There are discrepency in the handling of storage units, when the are not asked to produce / consume anything (setpoint
  is 0.) between pandapower and lightsim2grid only in the case where the storage unit is alone on its bus.

  Pandapower does not detect it and the episode can continue. On the other side, lightsim2grid detects it and raise an
  error because in that case the grid is not connex anymore (which is the desired behaviour).



  On the clang compiler (default one on MacOS computer) it is sometime require to downgrade the pybind11 version
  to 2.6.2 to install the package.

  You can downgrade pybind11 with: `python -m pip install -U pybind11==2.6.2`


pkgId: eb5e9fd8ae819cb89f8c66f1c6481227ed3764490675fade39aa49e6e459c48d
name: python-LogTranslate-help
arch: noarch
version: 1.5
epoch: 0
release: 1
summary: Development documents and examples for LogTranslate
url: https://github.com/5hmlA/PyTools
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LogTranslate-1.5-1.src.rpm
location_href: Packages/python-LogTranslate-help-1.5-1.noarch.rpm
checksum_type: sha256
description:
  把日志文件拖动到窗口即可解析日志



  安装

  ```commandline
  pip install LogTranslate
  ```

  项目根目录 创建 config.py
  里面定义字段 translator数组

  ```commandline
  translators = [SysLogTranslator(tag_translators=[BluetoothTranslator(), CrashPatternTranslator()])]
  ```

  SysLogTranslator是将文件中每行字符串解析出 tag,time,pid,msg
  SysLogTranslator的参数 tag_translators 是数组 用来解析 各种tag对应的内容
  解析tag的基类有

  - TagPatternTranslator 通过正则匹配tag然后解析
    ```python
    class CrashPatternTranslator(TagPatternTranslator):
         def __init__(self):
             super().__init__({
                 r"AndroidRuntime|FATAL.*|System.err.*": activity_task_translator
             })

         def activity_task_translator(tag, msg): # 这里两个参数
             
             return Log(translated=" ------ %s > %s----- " % (tag, msg), level=Level.e)

    ```

  - TagStrTranslator 通过字符串匹配tag然后解析
     ```python
    class BluetoothTranslator(TagStrTranslator):
         def __init__(self):
             super().__init__({
                 "BluetoothAdapter": bluetooth_adapter,
             })

         def bluetooth_adapter(msg):# 这里一个参数
             
             return Log(translated=" ------ %s > %s----- " % (tag, msg), level=Level.e)

    ```
  - SecStrTagTranslator 解析二级tag
     ```python
     class SecTagDemoTranslator(SecStrTagTranslator):
         def __init__(self):
             super().__init__("DFJ",
                              lambda string: re.search(r"(?P<tag>.*?) *:(?P<msg>.*)", string),
                              [
                                  SysLogTranslator({
                                      "sec_tag": self.new_tag
                                  })
                              ])

         def new_tag(self, tag, msg):# 这里两个参数
             return Log(translated=msg)
    ```





  ```python

  if __name__ == "__main__":
      app = QApplication(sys.argv)
      window = PyQt6Window()
      window.show()
      sys.exit(app.exec())
  ```



  ```commandline

  pyinstaller -n [name] --hidden-import config -F -w [-i tools.ico] ui.py

  ```



  https://pypi.org/project/LogTranslate/0.1/

  读取文件-->每行文件-->
  判断关键tag[每个translate先判断自己的tag满足，然后再正则解析str到通用log，解析后下一个解析的不用解析str-log]

  每个translate 都要配置通用的多个tag用于判断是否需要解析然后正则，解析出通用log格式之后，
  tag的正则可以创建translae对象的时候创建好re.compile("")


pkgId: 8671012567311ac3197f17d31f1b2b1c4d5eb738ee2cab18f069bdc58e5a4595
name: python-LogicChunks-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for LogicChunks
url: https://github.com/yourusername/LogicChunks
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LogicChunks-0.1.0-1.src.rpm
location_href: Packages/python-LogicChunks-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  `LogicChunks` is a Python package offering extended functionalities for working with lists, tuples, dictionaries, and sets. It provides a wide range of predefined conditions to categorize data based on user-defined or built-in conditions, making it easier to handle and organize various data types.



  You can install the package using `pip`:

  ```bash
  pip install LogicChunks



  Features:

  -->Divide lists into multiple groups based on user-defined or predefined conditions.

  Predefined conditions include:

  -> Even numbers
  -> Odd numbers
  -> Prime numbers
  -> Perfect square numbers
  -> Perfect cube numbers
  -> Fibonacci numbers
  -> Palindromes
  -> Ascending digits
  -> And many more...

  User-customizable conditions:
  ->Check if a number is greater than, less than, or equal to a specified number.
  ->Check if a number is divisible by another number or is a multiple of a given number.
  ->Check if a number is a power of another number.
  ->Check if a number is within a specific range.

  Usage:
  ->Divide List into Groups
  ->You can use the divide_list function to divide your data into different groups based on predefined or custom conditions.


  Predefined Conditions:

  The following predefined conditions can be used for grouping data:

  ->is_even(x): Returns True if x is an even number.
  ->is_odd(x): Returns True if x is an odd number.
  ->is_prime(x): Returns True if x is a prime number.
  ->is_perfect_square(x): Returns True if x is a perfect square.
  ->is_perfect_cube(x): Returns True if x is a perfect cube.
  ->is_fibonacci(x): Returns True if x is a Fibonacci number.
  ->is_palindrome(x): Returns True if x is a palindrome (reads the same forward and backward).
  ->is_ascending_digits(x): Returns True if the digits of x are in ascending order.
  ->is_zero(x): Returns True if x is equal to zero.
  ->is_positive(x): Returns True if x is a positive number.
  ->is_negative(x): Returns True if x is a negative number.
  ->Custom Conditions

  You can also create your own conditions using functions that return a True or False value based on a specific condition. Some examples include:

  ->is_greater_than(user_number): Returns a function that checks if a number is greater than a user-defined number.
  ->is_less_than(user_number): Returns a function that checks if a number is less than a user-defined number.
  ->is_divisible_by(user_number): Returns a function that checks if a number is divisible by a user-defined number.
  ->is_multiple_of(user_number): Returns a function that checks if a number is a multiple of a user-defined number.
  ->is_between_range(min_value, max_value): Returns a function that checks if a number is between a given range (inclusive).



  This README will be a good starting point for users of the `LogicChunks` package to install, use, and understand its features.





  from logicchunks.lists import *


  numbers = [1, 2, 3, 4, 5, 6, 10,10, 12, 16, 25, 100, 144, 50, 0,121, 0, -5, -10,2901]




  conditions = {
      "Greater than 10": is_greater_than(10),
      "Divisible by 2": is_divisible_by(2),
      "Multiple of 3": is_multiple_of(3),
      "Power of 2": is_power_of_x(2),
      "Even": is_even,
      "Odd": is_odd,
      "Positive": is_positive,
      "Negative": is_negative,
      "Prime": is_prime,
      "Perfect Square": is_perfect_square,
      "Perfect Cube": is_perfect_cube,
      "Fibonacci": is_fibonacci,
      "Even Length": is_even_length,
      "Odd Length": is_odd_length,
      "Integer": is_integer,
      "Float": is_float,
      "Zero": is_zero,
      "Palindrome": is_palindrome,
      "Ascending Digits": is_ascending_digits,
      "Less than 10": is_less_than(10),
      "Equal to 10": is_equal_to(10),
      "Not Equal to 10": is_not_equal_to(10),
      "Between 5 and 50": is_between_range(5,50),
      "Multiple of 2 or 3": is_multiple_of_any([2,3]),
      "Square Root Integer": is_square_root_integer
  }


  grouped_numbers = divide_list(numbers, conditions)


  for condition_name, group in grouped_numbers.items():
      print(f"\n{condition_name}:")
      print(group)


pkgId: eafe8ed67bc7afc5134f31bae5cd07032432508c337a29be38acc5f95c2c5b19
name: python-LoopProjectFile-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for LoopProjectFile
url: https://pypi.org/project/LoopProjectFile/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LoopProjectFile-0.2.2-1.src.rpm
location_href: Packages/python-LoopProjectFile-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  <!-- TOC seems to break alignment (also note that if TOC is enabled you MUST use level 1 headers) -->
  <!-- [TOC] -->

  <!-- I would prefer to have an image linked to the loop project website but Doxygen markdown cannot do this -->
  <!-- In Doxygen 1.8.16 (released 9/8/2019) it might be possible -->
  ![Loop Project](loop_inv.png "Loop Project")
  [Loop Project Website](https://loop3d.org)


  The Loop platform is an open source 3D probabilistic geological and geophysical modelling platform, initiated by Geoscience Australia and the OneGeology consortium. The project is funded by Australian territory, State and Federal Geological Surveys, the Australian Research Council and the MinEx Collaborative Research Centre.


  A Loop Project File encapsulates all the data and models used or created in a Loop workflow.  This includes the ability to create meta-data which provides provenance of the data and the methodology and history of how models are used and produced.  The Loop Project File is based on netCDF and has APIs for C/C++ and Python (with the intention of creating a Fortran API in the future).
  - [Loop Project File - C/C++](https://github.com/Loop3D/LoopProjectFile-cpp)
  - [Loop Project File - Python](https://github.com/Loop3D/LoopProjectFile)


  There are several benefits to using a single project file.  These include encapsulating the information in a single place, server storage and retrieval enabling batching of model creation over multiple servers, easily shared workflows, and storage efficiency among many more.


  netCDF enables multi-dimensional data structure storage in a highly compressed format as well as data attribution for meta-data all within a single data file.


  The Loop Project File python repository is under the MIT license


pkgId: 30a9d5560a737b1954f72f245ddf44389013af6fece31f2b5fc25dcd01a3d7cb
name: python-LoopStructural-help
arch: noarch
version: 1.6.5
epoch: 0
release: 1
summary: Development documents and examples for LoopStructural
url: https://pypi.org/project/LoopStructural/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LoopStructural-1.6.5-1.src.rpm
location_href: Packages/python-LoopStructural-help-1.6.5-1.noarch.rpm
checksum_type: sha256
description:
  ![3D model of Hamersley created using loopstructural](docs/source/images/image823.png)
  [![PyPI version](https://badge.fury.io/py/LoopStructural.svg)](https://badge.fury.io/py/LoopStructural)
  [![GitHub license](https://img.shields.io/github/license/Naereen/StrapDown.js.svg)](https://github.com/Loop3D/LoopStructural/blob/master/LICENSE)
  [![Documentation loop3d.github.io/LoopStructural/](https://img.shields.io/badge/docs-githubio-brightgreen)](https://loop3d.github.io/LoopStructural)



  LoopStructural is an opensource Python library for 3D geological modelling. The library has been built in the scope of the Loop project ([Loop3d.org](https://loop3d.org/)). LoopStructural can:

  - Model fault networks integrating fault kinematics and overprinting relationships
  - Model folds using structural elements (fold axis, fold axial surface) for multiple fold events
  - Use different implicit interpolation algorithms (Finite Difference, Piecewiese Linear, RBF)
  - Export models to vtk, geoh5, omf, gocad, csv, obj formats
  - Visualise models in an interactive python environment.





  LoopStructural can be used inside a google colab notebook, however interactive visualisation using kitware trame does not work. Only static plots can be displayed.



  `pip install loopstructural`

  Optional dependencies are:

  - loopstructuralvisualisation (wrapper for pyvista to interface with loopstructural objects)
  - pyvista (3D visualisation)
  - geoh5py (export to .geoh5 format)
  - mira-omf (export to .omf format to load in Leapfrog)
  - pyevtk
  - dill (serialize loop models to a pickle file)
  - tqdm (progress bars)
  - loopsolver (experimental solver for admm inequality constraints)

  You can install all of the optional dependencies using:
  `pip install loopstructural[all]`



  `conda install -c conda-forge -c loop3d loopstructural`

  to install the working 3D visualisation environment
  `conda install -c conda-forge -c loop3d loopstructural loopstructuralvisualisation pyvista trame trame-vtk trame-vuetify`



  - A basic geological model

  ```Python
  from LoopStructural import GeologicalModel
  from LoopStructural.datatypes import BoundingBox
  from LoopStructural.visualisation import Loop3DView
  from LoopStructural.datasets import load_claudius

  import numpy as np
  data, bb = load_claudius()




  model = GeologicalModel(bb[0,:],bb[1,:])
  model.data = data


  model.create_and_add_foliation('strati',nelements=1e5)
  model.update()

  locations = np.array(
      [
          np.random.uniform(bb[0, 0], bb[1, 0],5),
          np.random.uniform(bb[0, 1], bb[1, 1],5),
          np.random.uniform(bb[0, 2], bb[1, 2],5),
      ]
  ).T
  val = model.evaluate_feature_value('strati', locations)

  gradient = model.evaluate_feature_gradient('strati',locations)


  model['strati'].scalar_field().plot()


  ```



  The LoopStructural documentation can be found [here](https://loop3d.github.io/LoopStructural)



  Any bugs/feature requests/comments please create a new [issue](https://github.com/Loop3D/LoopStructural/issues).



  _The Loop platform is an open source 3D probabilistic geological and geophysical modelling platform, initiated by Geoscience Australia and the OneGeology consortium. The project is funded by Australian territory, State and Federal Geological Surveys, the Australian Research Council and the MinEx Collaborative Research Centre._


pkgId: 2fc68913487a2ba72c5619c9e28dbf7917dda44e50db9c25f96013fda8859aec
name: python-LuhnExtended-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for LuhnExtended
url: https://pypi.org/project/LuhnExtended/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LuhnExtended-1.0.0-1.src.rpm
location_href: Packages/python-LuhnExtended-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  LuhnExtended is a Python library for advanced operations with the Luhn algorithm. It provides functions to generate, verify, and append Luhn check digits, with support for user-defined checksum values.


  - **Checksum Calculation**: Calculate the Luhn checksum for a given string of digits.
  - **Verification**: Verify whether a string of digits satisfies the Luhn algorithm.
  - **Check Digit Generation**: Generate the correct check digit to append to a string of digits.
  - **Append Check Digit**: Easily append the correct Luhn check digit to a string.



  Install the `LuhnExtended` library using `pip` directly from PyPI:

  ```sh
  pip install LuhnExtended
  ```





  ```python
  from LuhnExtended import checksum, verify, generate, append
  ```




  Compute the Luhn checksum for the provided string of digits. Note that this assumes the check digit is in place.

  **Example**:

  ```python
  checksum_value = checksum("356938035643806")
  print(checksum_value)  # Output: 7
  ```


  Check if the provided string of digits satisfies the Luhn checksum.

  **Parameters**:
  - `string` (str): The string of digits to verify.
  - `checksum_expected` (int, optional): Expected checksum value.

  **Example**:

  ```python

  is_valid = verify("356938035643806", 7)
  print(f"Is ('356938035643806', 7) valid? {is_valid}")  # Expected output: True

  is_invalid = verify("356938035643806", 0)
  print(f"Is ('356938035643806', 0) valid? {is_invalid}")  # Expected output: False

  is_invalid = verify("534618613411236", 7)
  print(f"Is ('534618613411236', 7) valid? {is_invalid}")  # Expected output: False
  ```


  Generate the Luhn check digit to append to the provided string.

  **Parameters**:
  - `string` (str): The string of digits to generate a check digit for.
  - `checksum_desired` (int, optional): Desired checksum value (default is `0`).

  **Example**:

  ```python
  check_digit = generate("35693803564380", 7)
  print(f"Generated check digit for ('35693803564380', 7): {check_digit}")  # Output: 6
  ```


  Append the Luhn check digit to the end of the provided string.

  **Parameters**:
  - `string` (str): The string of digits to append a check digit to.
  - `checksum_desired` (int, optional): Desired checksum value (default is `0`).

  **Example**:

  ```python
  full_string = append("35693803564380", 7)
  print(f"Appended check digit to ('35693803564380', 7): {full_string}")  # Output: '356938035643806'
  ```



  Developed by Luhn Extended.


pkgId: c72c0e512e8ed5e670551b7352ddc911ff1bd8ea86032d4bb46e93660d637a7a
name: python-LunarAI-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for LunarAI
url: https://github.com/Haozhe-py/LunarAI
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-LunarAI-0.0.3-1.src.rpm
location_href: Packages/python-LunarAI-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Welcome to use LunarAI, a convenient AI tool.
  </ br>
  You can use it to create a fully connected neural network. To install it, use cmd "pip3 install LunarAI", or download the files from <a href="https://github.com/Haozhe-py/LunarAI/">GitHub</a>, and then use cmd "python3 setup.py install" to install it.
  < /br>
  If you need an example, see "LunarAI/examples/example_1.py". <b>WARNING: <i>Python 3.12</i> cannot use this program because of a bug in the interpreter.</b>


pkgId: ce5f8fc2b57ca82393e3c92166322870c4da33657e2af280bf6e4fbb2c53c03f
name: python-MIMIC-IV-MEDS-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for MIMIC-IV-MEDS
url: https://github.com/mmcdermott/MIMIC_IV_MEDS
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MIMIC-IV-MEDS-0.0.1-1.src.rpm
location_href: Packages/python-MIMIC-IV-MEDS-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/MIMIC-IV-MEDS)](https://pypi.org/project/MIMIC-IV-MEDS/)
  [![Documentation Status](https://readthedocs.org/projects/meds-transforms/badge/?version=latest)](https://meds-transforms.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/mmcdermott/MIMIC_IV_MEDS/graph/badge.svg?token=E7H6HKZV3O)](https://codecov.io/gh/mmcdermott/MIMIC_IV_MEDS)
  [![tests](https://github.com/mmcdermott/MIMIC_IV_MEDS/actions/workflows/tests.yaml/badge.svg)](https://github.com/mmcdermott/MIMIC_IV_MEDS/actions/workflows/tests.yml)
  [![code-quality](https://github.com/mmcdermott/MIMIC_IV_MEDS/actions/workflows/code-quality-main.yaml/badge.svg)](https://github.com/mmcdermott/MIMIC_IV_MEDS/actions/workflows/code-quality-main.yaml)
  ![python](https://img.shields.io/badge/-Python_3.12-blue?logo=python&logoColor=white)
  [![license](https://img.shields.io/badge/License-MIT-green.svg?labelColor=gray)](https://github.com/mmcdermott/MIMIC_IV_MEDS#license)
  [![PRs](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/mmcdermott/MIMIC_IV_MEDS/pulls)
  [![contributors](https://img.shields.io/github/contributors/mmcdermott/MIMIC_IV_MEDS.svg)](https://github.com/mmcdermott/MIMIC_IV_MEDS/graphs/contributors)

  This pipeline extracts the MIMIC-IV dataset (from physionet) into the MEDS format.



  ```bash
  pip install MIMIC_IV_MEDS
  MEDS_extract-MIMIC_IV raw_input_dir=$RAW_INPUT pre_MEDS_dir=$PRE_MEDS MEDS_cohort_dir=$COHORT
  ```



  You can run `MEDS_extract-MIMIC_IV --help` for more information on the arguments and options. You can also run

  ```bash
  MEDS_extract-MIMIC_IV raw_input_dir=$RAW_INPUT pre_MEDS_dir=$PRE_MEDS MEDS_cohort_dir=$COHORT do_demo=True
  ```

  to run the entire pipeline over the publicly available, fully open MIMIC-IV demo dataset.


pkgId: 2015e3b5e0bc6023647a5a09e0392540adeedaebe82b005c8d824072a41a6421
name: python-MITgcmutils-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for MITgcmutils
url: http://mitgcm.org/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MITgcmutils-0.2.1-1.src.rpm
location_href: Packages/python-MITgcmutils-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Python utilities for the MIT General Circulation Model,
  [MITgcm](http://mitgcm.org).

  This package is developed as a part of MITgcm on
  [github](https://github.com/MITgcm/MITgcm/tree/master/utils/python/MITgcmutils).

  It is documented in the MITgcm
  [manual](http://mitgcm.rtfd.io/en/latest/utilities/utilities.html#mitgcmutils).


pkgId: 8cf1386b2d77ba5e15adaacf6c73795fdaafac822bd24635dfc230f0f0e6454e
name: python-MSIght-help
arch: noarch
version: 1.0.7
epoch: 0
release: 1
summary: Development documents and examples for MSIght
url: https://github.com/laurenfields/MSIght_1.0.0
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MSIght-1.0.7-1.src.rpm
location_href: Packages/python-MSIght-help-1.0.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/msight-100/badge/?version=latest)](https://msight-100.readthedocs.io/en/latest/?badge=latest)
  ![Unit Tests](https://github.com/laurenfields/MSIght_1.0.0/actions/workflows/ci.yml/badge.svg)
  [![PyPI version](https://badge.fury.io/py/msight.svg)](https://pypi.org/project/msight/)

  <div align="center">
  <img src="https://github.com/laurenfields/MSIght/blob/main/utils/MSIght_logo.png">
  </div>



  MSIght is a program produced by the Lingjun Li Lab at the University of Wisconsin-Madison for automated integration of H&E, MSI, and LC-MS/MS datasets


  * [User manual](https://docs.google.com/document/d/e/2PACX-1vRg7HEovZCDG1IdLaVpfKdxXk9n3LBGevGVzZj9DhtYL69CmZ8VAwbSIM4Tm7bsCUkNBI8ixcHTqp6f/pub)
  * [Documentation](https://msight-100.readthedocs.io/en/latest/)



  You can install MSIght directly from [PyPI](https://pypi.org/project/msight/):

  ```
  pip install msight
  ```





  * Initial release


pkgId: 97db91508b1a267df6d98e65b58261f1e336195a9748209b19bfa2076c780924
name: python-MVPanalytics-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for MVPanalytics
url: https://pypi.org/project/MVPanalytics/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MVPanalytics-0.1.4-1.src.rpm
location_href: Packages/python-MVPanalytics-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  MVPanalytics.keitaro:

      keitaro_parser(): функция для парсинга данных из кейтаро на любой вкус и цвет

  MVPanalytics.analysis:

      weightgiver(): Функция для раздачи офферам в партнёрке весов (сплитование)

      off_analyzer(): Функция, позволяющая выявлять витрины по потоку (или офферу), на которых его: target < EPC, 0 < EPC < target, EPC=0

  MVPanalytics.graphics:

      plot_acf_pacf(): Строит графики ACF и PACF для временного ряда.


pkgId: f94611fcba081e3092632d506191e739b1cb4e1827c63791158160b428cd7f0a
name: python-MagicFeedback-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for MagicFeedback
url: https://github.com/MagicFeedback/magicfeedback_python_sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MagicFeedback-0.0.4-1.src.rpm
location_href: Packages/python-MagicFeedback-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  **A Python SDK for interacting with the MagicFeedback API**

  **Installation**

  Bash

  ```
  pip install MagicFeeedback

  ```

  Use code [with caution.](/faq#coding)

  **Usage**

  Python

  ```
  from magicfeedback import MagicFeedbackClient


  client = MagicFeedbackClient('email', 'password')


  feedback_data = {
      "name": "Test Feedback",
      "type": "DOCUMENT",
      
  }
  response = client.create_feedback(feedback_data)


  print(response)

  ```

  **API Reference**

  - **`create_feedback(feedback)`:** Creates a new feedback item.
  - **`get_feedback(feedback_id)`:** Retrieves a specific feedback item.
  - **`update_feedback(feedback_id, feedback)`:** Updates a specific feedback item.
  - **`delete_feedback(feedback_id)`:** Deletes a specific feedback item.

  **Additional Information**

  - **Authentication:** The SDK requires an user / password for authentication. You can obtain from the MagicFeedback platform.
  - **Error Handling:** The SDK handles common API errors and raises appropriate exceptions.
  - **Customizations:** You can customize the SDK to fit your specific needs by extending the `MagicFeedbackClient` class or creating additional helper functions.

  **License**

  This project is licensed under the MIT License.

  **Contact**

  For any questions or support, please contact farias@magicfeedback.io.


pkgId: 5de5fd7a482a7dbd16e774ebcf6b6111599715a2e903b11f015d8b1c3a91c981
name: python-MagnetoResistance-tool-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for MagnetoResistance-tool
url: https://pypi.org/project/MagnetoResistance-tool/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MagnetoResistance-tool-0.0.4-1.src.rpm
location_href: Packages/python-MagnetoResistance-tool-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  Simple tool to generate a calibration correction matrix for resistive sensors in a magnetic field.



  `pip install MagnetoResistance-tool` or `pip install --user MagnetoResistance-tool`.


  ```
  MRcalib [-h] [-o FILE_OUT] [-p] [-B FIELD_ORDER] [-T TEMP_ORDER] [-v] file_in

  Fit magneto-resistance data and create calibration matrix.

  positional arguments:
  file_in               input file defining the measurement data

  options:
  -h, --help            show this help message and exit
  -o FILE_OUT, --out FILE_OUT
  calibration matrix output file
  -p, --plot            plot the data and fits
  -B FIELD_ORDER, --field FIELD_ORDER
  order of polynomial to use for fitting with respect to the magnetic field
  -T TEMP_ORDER, --temperature TEMP_ORDER
  order of polynomial to use for fitting with respect to the measured temperature
  -v, --verbose         print values while calculating
  ```

  The input file `file_in` describes the data files to use.
  It should be a tab delimited file specifying first the path of the data file to use, next the names of the field and temperature columns to use, and finally the parameters for the outlier rejection algorithm.
  Here's an example:

  ```
  SD-3-7_V1-1-5_V2-20-6_BSweep_1,33K.001.dat	Field	Probe_Temp	 0	0	0	0
  SD-3-7_V1-1-5_V2-20-6_BSweep_2,17K.001.dat	Field	Probe_Temp	 0	0	0	0
  SD-3-7_V1-1-5_V2-20-6_BSweep-1,3K.001.dat	Field	Probe_Temp	 0	0	0	0
  SD-3-7_V1-1-5_V2-20-6_BSweep-1,89K.001.dat	Field	Probe_Temp	 50	5	50	0.04
  SD-3-7_V1-1-5_V2-20-6_BSweep-2,6K.001.dat	Field	Probe_Temp	 25	0.8	0	0
  d3_mag_sweep_4p2K.001.dat	B	T-A-K	 0	0	150	0.5
  d3_mag_sweep_10K.001.dat	B	T-A-K	 0	0	20	0.04
  d3_mag_sweep_15K.001.dat	B	T-A-K	 0	0	20	0.06
  d3_mag_sweep_20K.002.dat	B	T-A-K	 0	0	20	0.06
  d3_mag_sweep_25K.001.dat	B	T-A-K	 0	0	30	0.06
  ```

  The outlier rejection algorithm takes a rolling median of the data and rejects any points outside of this rolling median.
  The first two parameters control the outlier rejection in terms of field, the second set of two parameters does the same in terms of temperature.
  In each set the first parameter specifies the size of the window to take the rolling median over, and the second specifies how big the difference has to be for a point to be considered an outlier.
  Setting either of these two parameters to zero disables outlier rejection for this variable.
  To summarize, the syntax of the input file is:
  ```
  <PATH>	<FIELD COLUMN NAME>	<TEMPERATURE COLUMN NAME> <FIELD ROLLING MEDIAN WINDOW> <FIELD REJECTION THRESHOLD> <TEMPERATURE ROLLING MEDIAN WINDOW> <TEMPERATURE REJECTION THERSHOLD>
  ```

  Once the input file is created the calibration matrix creation tool can be called:
  ```
  MRcalib <PATH TO INPUT FILE>
  ```

  All data is sliced up in slices of equal field. For each field the actual temperature is fitted against the measured temperature using the order specified by the `--temperature` or `-T` argument (defaults to 1 if unspecified).
  Next each of these fitting parameters is fitted against field using the order specified by the `--field` or `-B` argument (defaults to 3 if unspecified).
  The optional arguments `--verbose` (`-v`) and `--plot` (`-p`) allow to check and visualize each step.
  Plotting requires matplotlib.

  When plotting is enabled the first set of plots visualizes which points are accepted by the outlier rejection algorithm and which ones are rejected.
  This allows to fine tune the parameters of the algorithm to achieve the desired result.
  The second set of plots visualizes the first round of fitting (actual temperature versus measured temperature) for a maximum of 10 different fields.
  The final plot allows for performing a sanity check.
  The calculated correction is applied to the initial set of input files.
  This should create a series of more or less flat lines since the actual temperature for each input data file is the same.
  If this is not the case than this can indicate that the actual temperature was drifting in one of the input data files.
  Increasing or decreasing the order of the fitting polynomials (`--field`) and `(--temperature`) can help to achieve a better result.
  In general higher is better, but requires more computation and therefore more time and the improvement return tends to diminish the higher the order becomes.

  The generated calibration matrix is written as `calib.txt` into the same directory as the input file was read from.
  This can be overridden using the `--out` or `-o` argument.

  To apply the calculated calibration matrix to your actual data, call the correction function from your python data analysis script as follows:
  ```
  from MRcalib import MRcorrect

  <YOUR CODE GOES HERE>

  MRcorrect(<PATH TO CALIBRATION FILE>, <FIELD DATA>, <TEMPERATURE DATA>)

  <YOUR CODE GOES HERE>
  ```

  This function will return the actual temperature and its uncertainty for a given field and measured temperature. The field and temperature data can be provided as an integer, float, list, numpy array, pandas dataframe or pandas series.



  If you found a problem, please open a new ticket in the issues pane of our GitLab page.
  And if you want to contribute than merge requests are also welcome on our GitLab page.



  The code in this repository is licensed under the GPL-3+ license


pkgId: 7a0c79bc5c857b1c7b5af0a3c67ae9e787c0ab526e29ecfe9f66f2a2d44a1b13
name: python-MainShortcuts2-help
arch: noarch
version: 2.4.5
epoch: 0
release: 1
summary: Development documents and examples for MainShortcuts2
url: https://github.com/MainPlay-TG/MainShortcuts2.py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MainShortcuts2-2.4.5-1.src.rpm
location_href: Packages/python-MainShortcuts2-help-2.4.5-1.noarch.rpm
checksum_type: sha256
description:
  Сокращение и улучшение функций

  Для установки через `pip` используйте
  ```bash
  python3 -m pip install -U MainShortcuts2
  ```

  Импорт модуля
  ```python
  from MainShortcuts2 import ms
  ```
  Встроенная информация о модуле
  ```python
  ms.version -> str # Версия модуля
  ```
  -# README в разработке, это оказалось сложнее, чем писать сам модуль


pkgId: aa579863cfe93cb7c941408e86fcf52356c24b32ca75f198427d6a7e6b9c374c
name: python-ManMade2.BelialDB
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ManMade2.BelialDB/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ManMade2.BelialDB-1.0.0-1.src.rpm
location_href: Packages/python-ManMade2.BelialDB-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install belial-db
  ```

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


pkgId: d46c74107b93e34e3a1ade7dbb7dc5efc09ba43db9759e41d501e559df6390f3
name: python-ManMade2.Commander
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ManMade2.Commander/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ManMade2.Commander-1.0.2-1.src.rpm
location_href: Packages/python-ManMade2.Commander-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install commander
  ```

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


pkgId: f42632e56aac6abe9d534ce0d2aa23f647b12d78655f10aabfb8a84acaec4715
name: python-MdXLogseqTODOSync-help
arch: noarch
version: 0.0.18
epoch: 0
release: 1
summary: Development documents and examples for MdXLogseqTODOSync
url: https://github.com/thiswillbeyourgithub/MdXLogseqTODOSync
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MdXLogseqTODOSync-0.0.18-1.src.rpm
location_href: Packages/python-MdXLogseqTODOSync-help-0.0.18-1.noarch.rpm
checksum_type: sha256
description:
  A Python tool to synchronize TODO items between Markdown and Logseq files. It allows you to maintain TODO lists across different markdown formats while respecting delimiters and filtering based on patterns and bullet point levels.

  I made this so that updating my [logseq](https://github.com/logseq/logseq) graph's TODOs about a given repository would update the README.md of said repository.



  - Synchronize TODO items between different markdown files
  - Configurable delimiters to mark sync boundaries
  - Filter content based on regular expression patterns
  - Control maximum bullet point depth
  - Preserves formatting and indentation
  - Type-safe implementation with beartype


  * From pypi:
      * As a tool: `uvx MdXLogseqTODOSync@latest --help`
      * Via uv: `uv pip install MdXLogseqTODOSync`
      * Via pip: `pip install MdXLogseqTODOSync`
  * From github:
      * Clone this repo then `pip install .`



  The tool is primarily used from the command line:

  ```bash
  MdXLogseqTODOSync --help


  MdXLogseqTODOSync input.md output.md


  MdXLogseqTODOSync --must_match_regex "TODO|DONE" --bulletpoint-max-level 2 input.md output.md


  MdXLogseqTODOSync \
      --input-delim-start "- BEGIN_TODO" \
      --input-delim-end "- END_TODO" \
      --output-delim-start "<!-- BEGIN_TODO -->" \
      --output-delim-end "<!-- END_TODO -->" \
      --must_match_regex "TODO|DONE" \
      --bulletpoint-max-level 2 \
      --sub-pattern '(\s*)- (TODO|DONE|DOING|NOW|LATER) ' '\\1- ' \
      --remove-block-properties \
      --keep-new-lines \
      --recursive \
      input.md output.md
  ```



  - `input_file`: Path or string pointing to the input Markdown/Logseq file
  - `output_file`: Path or string pointing to the output Markdown/Logseq file
  - `input_delim_start`: Regex pattern to match the start of input section. Use "__START__" for beginning of file. Default: `"__START__"`
  - `input_delim_end`: Regex pattern to match the end of input section. Use "__END__" for end of file. Default: `"__END__"`
  - `output_delim_start`: Regex pattern to match the start of output section. Default: `"<!-- BEGIN_TODO -->"`
  - `output_delim_end`: Regex pattern to match the end of output section. Default: `"<!-- END_TODO -->"`
  - `bulletpoint_max_level`: Maximum level of bullet points to process. Use -1 for unlimited. Default: `-1`
  - `must_match_regex`: Regex pattern that lines must match to be included. Default: `r"^\s*- (TODO|DONE|DOING|NOW|LATER|#+) "`
  - `sub_pattern`: Optional tuple of (search pattern, replace pattern) to modify matched lines. Default: `(r"^(\s*)- (TODO|DONE|DOING|NOW|LATER) ", r"\1- ")`
  - `remove_block_properties`: If True, removes Logseq block properties. Default: `True`
  - `keep_new_lines`: If True, preserves newlines from Logseq. Default: `True`
  - `recursive`: If True, processes nested TODO items under a matching parent. Default: `True`



  Input file example:
  ```markdown
  Some content...

  - BEGIN_TODO
  - TODO Review pull request
    - DONE Update tests
    - TODO Add documentation
  - END_TODO

  More content...
  ```

  Output file example:
  ```markdown


  <!-- BEGIN_TODO -->
  - TODO Review pull request
    - DONE Update tests
    - TODO Add documentation
  <!-- END_TODO -->
  ```



  The tool includes robust error checking for:
  - Missing or duplicate delimiters
  - Non-existent input files
  - Empty or invalid content blocks
  - Invalid regex patterns



  Contributions are welcome! Please feel free to submit a Pull Request.



  See LICENSE.md file for details.


pkgId: ce57e19cc1ea595043f346675bf09aef0d5208e2c1c3d377a456bf33d17c18cd
name: python-Mesa-help
arch: noarch
version: 3.1.1
epoch: 0
release: 1
summary: Development documents and examples for Mesa
url: https://pypi.org/project/Mesa/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Mesa-3.1.1-1.src.rpm
location_href: Packages/python-Mesa-help-3.1.1-1.noarch.rpm
checksum_type: sha256
description:
  | | |
  | --- | --- |
  | CI/CD | [![GitHub Actions build status](https://github.com/projectmesa/mesa/workflows/build/badge.svg)](https://github.com/projectmesa/mesa/actions) [![Coverage status](https://codecov.io/gh/projectmesa/mesa/branch/main/graph/badge.svg)](https://codecov.io/gh/projectmesa/mesa) |
  | Package | [![PyPI - Version](https://img.shields.io/pypi/v/mesa.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/Mesa/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/mesa.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold)](https://pypi.org/project/Mesa/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mesa.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/Mesa/) |
  | Meta | [![linting - 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) [![code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch) [![SPEC 0 — Minimum Supported Dependencies](https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038)](https://scientific-python.org/specs/spec-0000/) |
  | Chat | [![chat](https://img.shields.io/matrix/project-mesa:matrix.org?label=chat&logo=Matrix)](https://matrix.to/#/#project-mesa:matrix.org) |

  Mesa allows users to quickly create agent-based models using built-in
  core components (such as spatial grids and agent schedulers) or
  customized implementations; visualize them using a browser-based
  interface; and analyze their results using Python's data analysis
  tools. Its goal is to be the Python-based alternative to NetLogo,
  Repast, or MASON.

  ![A screenshot of the WolfSheep Model in Mesa](https://raw.githubusercontent.com/projectmesa/mesa/main/docs/images/wolf_sheep.png)

  *Above: A Mesa implementation of the WolfSheep model, this
  can be displayed in browser windows or Jupyter.*



  -   Modular components
  -   Browser-based visualization
  -   Built-in tools for analysis
  -   Example model library



  To install our latest stable release (3.0.x), run:

  ``` bash
  pip install -U mesa
  ```

  To install our latest pre-release, run:

  ``` bash
  pip install -U --pre mesa
  ```
  Starting with Mesa 3.0, we don't install all our dependencies anymore by default.
  ```bash

  pip install -U --pre mesa[network,viz]


  pip install -U --pre mesa[rec]


  pip install -U --pre mesa[all]
  ```

  You can also use `pip` to install the latest GitHub version:

  ``` bash
  pip install -U -e git+https://github.com/projectmesa/mesa@main#egg=mesa
  ```

  Or any other (development) branch on this repo or your own fork:

  ``` bash
  pip install -U -e git+https://github.com/YOUR_FORK/mesa@YOUR_BRANCH#egg=mesa
  ```


  For resources or help on using Mesa, check out the following:

  -   [Intro to Mesa Tutorial](http://mesa.readthedocs.org/en/stable/tutorials/intro_tutorial.html) (An introductory model, the Boltzmann
      Wealth Model, for beginners or those new to Mesa.)
  -   [Visualization Tutorial](https://mesa.readthedocs.io/stable/tutorials/visualization_tutorial.html) (An introduction into our Solara visualization)
  -   [Complexity Explorer Tutorial](https://www.complexityexplorer.org/courses/172-agent-based-models-with-python-an-introduction-to-mesa) (An advanced-beginner model,
      SugarScape with Traders, with instructional videos)
  -   [Mesa Examples](https://github.com/projectmesa/mesa-examples) (A repository of seminal ABMs using Mesa and
      examples of employing specific Mesa Features)
  -   [Docs](http://mesa.readthedocs.org/) (Mesa's documentation, API and useful snippets)
      -   [Development version docs](https://mesa.readthedocs.io/latest/) (the latest version docs if you're using a pre-release Mesa version)
  -   [Discussions](https://github.com/projectmesa/mesa/discussions) (GitHub threaded discussions about Mesa)
  -   [Matrix Chat](https://matrix.to/#/#project-mesa:matrix.org) (Chat Forum via Matrix to talk about Mesa)



  You can run Mesa in a Docker container in a few ways.

  If you are a Mesa developer, first [install Docker
  Compose](https://docs.docker.com/compose/install/) and then, in the
  folder containing the Mesa Git repository, you run:

  ``` bash
  $ docker compose up

  $ docker compose up -d
  ```

  This runs the Schelling model, as an example.

  With the docker-compose.yml file in this Git repository, the `docker compose up` command does two important things:

  -   It mounts the mesa root directory (relative to the
      docker-compose.yml file) into /opt/mesa and runs pip install -e on
      that directory so your changes to mesa should be reflected in the
      running container.
  -   It binds the docker container's port 8765 to your host system's
      port 8765 so you can interact with the running model as usual by
      visiting localhost:8765 on your browser

  If you are a model developer that wants to run Mesa on a model, you need
  to:

  -   make sure that your model folder is inside the folder containing the
      docker-compose.yml file
  -   change the `MODEL_DIR` variable in docker-compose.yml to point to
      the path of your model
  -   make sure that the model folder contains an app.py file

  Then, you just need to run `docker compose up -d` to have it
  accessible from `localhost:8765`.



  Want to join the Mesa team or just curious about what is happening with
  Mesa? You can\...

  > -   Join our [Matrix chat room](https://matrix.to/#/#project-mesa:matrix.org) in which questions, issues, and
  >     ideas can be (informally) discussed.
  > -   Come to a monthly dev session (you can find dev session times,
  >     agendas and notes on [Mesa discussions](https://github.com/projectmesa/mesa/discussions)).
  > -   Just check out the code on [GitHub](https://github.com/projectmesa/mesa/).

  If you run into an issue, please file a [ticket](https://github.com/projectmesa/mesa/issues) for us to discuss. If
  possible, follow up with a pull request.

  If you would like to add a feature, please reach out via [ticket](https://github.com/projectmesa/mesa/issues) or
  join a dev session (see [Mesa discussions](https://github.com/projectmesa/mesa/discussions)). A feature is most likely
  to be added if you build it!

  Don't forget to checkout the [Contributors guide](https://github.com/projectmesa/mesa/blob/main/CONTRIBUTING.md).



  To cite Mesa in your publication, you can use the [CITATION.bib](https://github.com/projectmesa/mesa/blob/main/CITATION.bib).


pkgId: 6ffd1d39f42a4a20e47c9fe860526823d5524e52f870f791cf4871d4d847a52c
name: python-MeteorologicalToolkit-help
arch: noarch
version: 0.6
epoch: 0
release: 1
summary: Development documents and examples for MeteorologicalToolkit
url: https://github.com/zhangxutao3/meteorological-toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MeteorologicalToolkit-0.6-1.src.rpm
location_href: Packages/python-MeteorologicalToolkit-help-0.6-1.noarch.rpm
checksum_type: sha256
description:
  This is a Python library for processing meteorological data.



  You can install the package via pip:

  ```bash
  pip install MeteorologicalToolkit


pkgId: aa318b180d7ef451a50efe8f8577cea6869913e3e5894bc443f503a391937ffd
name: python-MetricDB-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for MetricDB
url: https://github.com/Don-Yin/MetricDB
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MetricDB-0.0.10-1.src.rpm
location_href: Packages/python-MetricDB-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  MetricDB is a lightweight SQLite3 based logger with pandas integration.


  ```pip install MetricDB```




  ```python
  from MetricDB import MetricDB


  logger = MetricDB(datafile_dir="my_project.db")


  logger.log({"epoch": 1, "loss": 0.5, "accuracy": 0.85})


  logger.log({"loss": 0.3, "accuracy": 0.9}, name_table="training")
  logger.log({"loss": 0.4, "accuracy": 0.87}, name_table="validation")


  train_loss_avg = logger.get_moving_average(key="loss", name_table="training", window_size=10)
  print(f"Average training loss: {train_loss_avg}")


  logger.on_end()
  ```


  ```python
  from MetricDB import MetricDB

  logger = MetricDB(datafile_dir="analysis.db")


  for epoch in range(10):
      logger.log({
          "epoch": epoch,
          "train_loss": epoch * 0.1,
          "train_acc": 0.85 + epoch * 0.01
      }, name_table="metrics")


  logger.save_as_csv(name_table="metrics", save_dir="training_results.csv")


  df = logger.get_dataframe(name_table="metrics")
  print(df.dtypes)  # Shows column data types

  logger.on_end()
  ```


  ```python
  from MetricDB import MetricDB

  logger = MetricDB(datafile_dir="pandas_example.db")


  logger.log({
      "text_data": "hello",
      "numeric_data": 42.5,
      "integer_data": 100
  })


  df = logger.get_dataframe()
  print("Data Types:")
  print(df.dtypes)


  print("\nDataFrame Summary:")
  print(df.describe())


  logger.save_as_csv(name_table="main", save_dir="output.csv")

  logger.on_end()
  ```


  ```python
  from MetricDB import MetricDB

  logger = MetricDB(datafile_dir="debug.db", verbose=True)


  logger.log({"step": 1, "loss": 0.5})


  logger.print_header()  # Shows all tables and their contents


  logger.show_last_row(name_table="main")

  logger.on_end()
  ```


  ```python
  from MetricDB import MetricDB

  logger = MetricDB(datafile_dir="dev.db")


  logger._write_dummy_data(name_table="test_table")


  logger.print_header()

  logger.on_end()
  ```


pkgId: bef7878741dd8e43c4b2847e9170bbf253b73bf7763d15286cfc21a4196d1ecc
name: python-Ming-help
arch: noarch
version: 0.15.2
epoch: 0
release: 1
summary: Development documents and examples for Ming
url: https://github.com/TurboGears/Ming
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Ming-0.15.2-1.src.rpm
location_href: Packages/python-Ming-help-0.15.2-1.noarch.rpm
checksum_type: sha256
description:
  Database mapping layer for MongoDB on Python. Includes schema enforcement and some facilities for schema migration.


pkgId: 28185faa0d48c568ed810be40cbc23ae67ce08a82696484b6a9c7ebb097d982f
name: python-MissForest-help
arch: noarch
version: 4.0.0
epoch: 0
release: 1
summary: Development documents and examples for MissForest
url: https://github.com/yuenshingyan/MissForest
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MissForest-4.0.0-1.src.rpm
location_href: Packages/python-MissForest-help-4.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13368883.svg)](https://doi.org/10.5281/zenodo.13368883)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/MissForest?link=https%3A%2F%2Fpypi.org%2Fproject%2FMissForest%2F)
  [![MIT Licence](https://badges.frapsoft.com/os/mit/mit.svg?v=103)](https://opensource.org/licenses/mit-license.php)
  [![PyPI version](https://badge.fury.io/py/MissForest.svg)](https://badge.fury.io/py/MissForest)
  [![Open Source Love](https://badges.frapsoft.com/os/v2/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)

  This project is a Python implementation of the MissForest algorithm, a powerful
  tool designed to handle missing values in tabular datasets. The primary goal of
  this project is to provide users with a more accurate method of imputing
  missing data.

  While MissForest may take more time to process datasets compared to simpler
  imputation methods, it typically yields more accurate results.

  Please note that the efficiency of MissForest is a trade-off for its accuracy.
  It is designed for those who prioritize data accuracy over processing speed.
  This makes it an excellent choice for projects where the quality of data is
  paramount.



  Categorical variables in argument `categoricals` will be label encoded for
  estimators to work properly.



  To install MissForest using pip.

  ```console
  pip install MissForest
  ```

  Imputing a dataset:

  ```python
  import pandas as pd
  import numpy as np
  from sklearn.model_selection import train_test_split
  from missforest import MissForest


  df = pd.read_csv("insurance.csv")


  df["sex"] = df["sex"].map({"male": 0, "female": 1})
  df["region"] = df["region"].map({
      "southwest": 0, "southeast": 1, "northwest": 2, "northeast": 3})
  df["smoker"] = df["smoker"].map({"yes": 0, "no": 1})


  for c in df.columns:
      n = int(len(df) * 0.1)
      rand_idx = np.random.choice(df.index, n)
      df.loc[rand_idx, c] = np.nan


  train, test = train_test_split(df, test_size=.3, shuffle=True,
                                 random_state=42)


  mf = MissForest(categorical=["sex", "smoker", "region"])
  mf.fit(x=train)
  train_imputed = mf.transform(x=train)
  test_imputed = mf.transform(x=test)
  ```

  Or using the `fit_transform` method
  ```python
  mf = MissForest(categorical=["sex", "smoker", "region"])
  train_imputed = mf.fit_transform(X=train)
  test_imputed = mf.transform(X=test)
  print(test_imputed)
  ```



  ```python
  from missforest import MissForest
  import pandas as pd
  import numpy as np
  from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier

  df = pd.read_csv("insurance.csv")

  for c in df.columns:
      random_index = np.random.choice(df.index, size=100)
      df.loc[random_index, c] = np.nan

  clf = RandomForestClassifier(n_jobs=-1)
  rgr = RandomForestRegressor(n_jobs=-1)

  mf = MissForest(clf, rgr)
  df_imputed = mf.fit_transform(df)
  ```


  ![image](fig/pseudo_code.png)


  Here are some figures and tables from **Stekhoven and Buhlmann (2012)**
  ![image](fig/figure_1.png)

  Figure 1: Continuous data. Average NRMSE for KNNimpute (grey), MissPALasso (white) and missForest (black) on four different data sets and three different amounts of missing values, i.e., 10%, 20%
  and 30%. Standard errors are in the order of magnitude of 10−4
  . Significance levels for the paired
  Wilcoxon tests in favour of missForest are encoded as “&ast;” <0.05, “&ast;&ast;” <0.01 and “&ast;&ast;&ast;” <0.001. If the
  average error of the compared method is smaller than that of missForest the significance level is encoded
  by a hash (#) instead of an asterisk. In the lowermost data set results for MissPALasso are missing due
  to the methods limited capability with regard to high dimensions.

  ![image](fig/figure_2.png)

  Figure 2: Categorical data. Average PFC for cross-validated KNNimpute (grey), MICE (white) and
  missForest (black) on three different data sets and three different amounts of missing values, i.e., 10%,
  20% and 30%. Standard errors are in the order of magnitude of 10−4
  . Significance levels for the paired
  Wilcoxon tests in favour of missForest are encoded as “&ast;” <0.05, “&ast;&ast;” <0.01 and “*&ast;&ast;&ast;” <0.001.


  ![image](fig/figure_3.png)


  Figure 3: Mixed-type data. Average NRMSE (left bar) and PFC (right bar, shaded) for KNNimpute
  (grey), MICE (white) and missForest (black) on four different data sets and three different amounts
  of missing values, i.e., 10%, 20% and 30%. Standard errors are in the order of magnitude of 10−3
  .
  Significance levels for the paired Wilcoxon tests in favour of missForest are encoded as “&ast;” <0.05, “&ast;&ast;”
  <0.01 and “&ast;&ast;&ast;” <0.001. If the average error of the compared method is smaller than that of missForest
  the significance level is encoded by a hash (#) instead of an asterisk. Note that, due to ill-distribution
  and near dependence in the Child hospital data, the results for MICE have to be treated with caution (see
  Section 4.3).


  ![image](fig/figure_4.png)

  Figure 4: Difference of true imputation error errtrue and OOB imputation error estimate err cOOB for the
  continuous data sets (left) and the categorical data sets (right) and three different amounts of missing
  values, i.e., 0.1, 0.2 and 0.3. In each case the average errtrue (circle) and the average err cOOB (plus) over
  all simulations is given.


  ![image](fig/table_1.png)

  Table 1: Average runtimes [s] for imputing the analyzed data sets. Runtimes are averaged over the
  amount of missing values since this has a negligible effect on computing time.


  ![image](fig/table_2.png)

  Table 2: Average imputation error (NRMSE/PFC in percent) and runtime (in seconds) with different
  numbers of trees (ntree) grown in each forest and variables tried (mtry) at each node of the trees. Here,
  we consider the GFOP data set with artificially introduced 10% of missing values. For each comparison 50 simulation runs were performed using always the same missing value matrix for all numbers of
  trees/randomly selected variables for a single simulation.


pkgId: a9b35cb0c065976274ea0f3fafe3a690479fc46cee350dc29f19d849914d2cc0
name: python-MixtureMetrics-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for MixtureMetrics
url: https://github.com/bakhras/MixtureDescriptors-I
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MixtureMetrics-1.0.3-1.src.rpm
location_href: Packages/python-MixtureMetrics-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  This Python project calculates an additive scheme for mixture descriptors of multi-component materials. The algorithm processes input from two `.csv` files and computes various mixture descriptors.



  The algorithm requires two input files:

  1. Descriptors File: Contains individual descriptors for each component.
  2. Mole Fraction File: Contains mole fraction values for each component in each mixture.
  The main function, mixture_descriptors_to_csv, processes these inputs and generates 12 CSV files, each corresponding to a different mixture descriptor metric.






  Ensure you have Python 3.x installed. You will also need `pip` to install the package.


  You can install the package in two different ways depending on whether you want to install from the local directory or directly from PyPI:

  Option 1: Install from Local Directory
     1. **Download the Package:**
        - Clone the repository or download the ZIP file from GitHub.
        - Extract the contents of the ZIP file.

     2. **Install the Package:**
        - Open a command-line interface (CLI).
        - Navigate to the directory containing the extracted package files.
        - Run the following command to install the package:

        ```bash
        pip install .
        ```
  Option 2: Install from PyPI

  If you prefer to install the package directly from PyPI, you can use the following command.

     ```bash
     pip install MixtureMetrics
     ```



  After installing the package, you can use it in your Python code. Hereâ€™s a basic example of how to use the main function:


  ```python
  from MixtureMetrics import mixture_descriptors_to_csv


  descriptors_file_path = 'path/to/descriptors.csv'
  mole_fraction_file_path = 'path/to/mole_fraction.csv'
  output_directory = 'path/to/output_directory'  # if output path string is empty or None and not provided,it defaults to use the current working directory and if the provided folder is not existed it creates a folder in the given path or in 1.1.5 working directory


  mixture_descriptors_to_csv(descriptors_file_path, mole_fraction_file_path, output_directory)
  ```


  - **descriptors_file_path**: Path to the `.csv` file containing individual descriptors for each component.

  - **mole_fraction_file_path**: Path to the `.csv` file containing mole fraction values for each component in each mixture.

  - **output_directory**: Directory where the 12 output `.csv` files will be saved.



  The code computes and saves 12 different mixture descriptors, each in its own `.csv` file within the specified output directory.



  Contributions are welcome! Please open an issue or submit a pull request if you have suggestions or improvements.


  This project is licensed under the GNU General Public License - see the LICENSE file for details.


pkgId: 9a394a6d84d86f23697ff2e7d9f0c27a2dba20c2cdf66da0946ca6bbb7d29e44
name: python-MonsterUI-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for MonsterUI
url: https://github.com/Isaac-Flath/MonsterUI
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MonsterUI-0.0.8-1.src.rpm
location_href: Packages/python-MonsterUI-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->



  To install this library, uses

  `pip install MonsterUI`



  To get started, check out:

  1.  Start by importing the modules as follows:

  ``` python
  from fasthtml.common import *
  from monsterui.all import *
  ```

  2.  Instantiate the app with the MonsterUI headers

  ``` python
  app = FastHTML(hdrs=Theme.blue.headers())


  app, rt = fast_app(hdrs=Theme.slate.headers())
  ```

  > *The color option can be any of the theme options available out of the
  > box*

  From here, you can explore the API Reference & examples to see how to
  implement the components. You can also check out these demo videos to as
  a quick start guide:

  - MonsterUI [documentation page and Tutorial
    app](https://monsterui.answer.ai/tutorial_app)
  - This
    [video](https://www.loom.com/share/0916e8a95d524c43a4d100ee85157624?sid=9be07e55-c962-4dbd-978c-aa6a0bcee7b3)
    where Isaac iteratively builds a form in 5 minutes with the framework

  More resources and improvements to the documentation will be added here
  soon!



  Using LLMs for development is a best practice way to get started and
  explore. While LLMs cannot code for you, they can be helpful assistants.
  You must check, refactor, test, and vet any code any LLM generates for
  you - but they are helpful productivity tools.

  - [llms.txt](https://raw.githubusercontent.com/AnswerDotAI/monsterui/refs/heads/main/nbs/llms.txt):
    Links to the neccesary reference documents to use the MonsterUI
    library effectively. Contains very little information directly in the
    document.
  - [llms-ctx.txt](https://raw.githubusercontent.com/AnswerDotAI/monsterui/refs/heads/main/nbs/llms-ctx.txt):
    MonsterUI specific context only (does not include FastHTML specific
    context)
  - [llm-ctx-full.txt](https://raw.githubusercontent.com/AnswerDotAI/monsterui/refs/heads/main/nbs/llms-ctx-full.txt):
    All inclusive FastHTML + MonsterUI context


pkgId: b3312576eeecc6f30ff67b1a36da5e3906dd3cbd75142a8e7f6320910e92db1d
name: python-Mopidy-Local-help
arch: noarch
version: 3.3.0
epoch: 0
release: 1
summary: Development documents and examples for Mopidy-Local
url: https://github.com/mopidy/mopidy-local
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Mopidy-Local-3.3.0-1.src.rpm
location_href: Packages/python-Mopidy-Local-help-3.3.0-1.noarch.rpm
checksum_type: sha256
description:
  - `Maintainer wanted`_
  - Installation_
  - Configuration_
  - Usage_
    - `Generating a library`_
    - `Updating the library`_
    - `Clearing the library`_
    - `Library layout`_
  - `Project resources`_
  - Credits_


pkgId: 5ec7dfd2349862e6e0bb65c458c168939bc9626c83995d00f0d0feed12d5f4cc
name: python-MultiBgolearn-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for MultiBgolearn
url: https://github.com/Bin-Cao/MultiBgolearn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MultiBgolearn-0.0.7-1.src.rpm
location_href: Packages/python-MultiBgolearn-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  MultiBgolearn is a Python package designed for multi-objective Bayesian global optimization (MOBO), specifically tailored for materials design. It extends the functionalities of the Bgolearn package, which focuses on single-objective optimization, by enabling the simultaneous optimization of multiple material properties. This makes MultiBgolearn highly suitable for real-world applications where trade-offs between competing objectives are common.

  The repository provides the source code of the MultiBgolearn package along with several multi-objective Bayesian global optimization (MOBO) algorithms.

  For questions or suggestions, feel free to contact: Bin Cao: [bcao686@connect.hkust-gz.edu.cn](mailto:bcao686@connect.hkust-gz.edu.cn), GitHub: [https://github.com/Bin-Cao/MultiBgolearn](https://github.com/Bin-Cao/MultiBgolearn)


pkgId: f656af2d8ebf543d6b7bd526d151cdca826b18856e7299c9465ccd81836ae6d8
name: python-My-question-rag-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for My-question-rag
url: https://pypi.org/project/My-question-rag/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-My-question-rag-0.1-1.src.rpm
location_href: Packages/python-My-question-rag-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python package that implements a Question-Answering Retrieval-Augmented Generation (RAG) pipeline using OpenAI, FAISS, and Sentence Transformers.


  - Retrieve relevant context using FAISS.
  - Generate standalone questions using OpenAI's LLM.
  - Classify intent to block certain queries.


  ```bash
  pip install .


pkgId: ecf8207413a2b0cb6425cadc969c521c40738855e5be5f81f525622b93523941
name: python-MyLLM-help
arch: noarch
version: 4.13.21
epoch: 0
release: 1
summary: Development documents and examples for MyLLM
url: https://pypi.org/project/MyLLM/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MyLLM-4.13.21-1.src.rpm
location_href: Packages/python-MyLLM-help-4.13.21-1.noarch.rpm
checksum_type: sha256
description:
  <table style="border: 1px solid transparent">
    <tr>
      <td>
  <a href="http://talky.readthedocs.io"><img src="https://img.shields.io/badge/Wiki-%23000000.svg?style=for-the-badge&logo=wikipedia&logoColor=white"></a>
  <a href="https://github.com/mraniki/tt/"><img src="https://img.shields.io/badge/github-%23000000.svg?style=for-the-badge&logo=github&logoColor=white"></a><br>
  <a href="https://hub.docker.com/r/mraniki/tt"><img src="https://img.shields.io/docker/pulls/mraniki/tt?style=for-the-badge"></a><br>
         </td>
      <td align="center"><img width="200" alt="Logo" src="/docs/_static/logo-full.png"></td>
    </tr>
    <tr>
      <td>
        <a href="https://pypi.org/project/myllm/"><img src="https://img.shields.io/pypi/v/myllm?style=for-the-badge&logo=PyPI&logoColor=white"></a><br>
        <a href="https://pypi.org/project/myllm/"><img src="https://img.shields.io/pypi/dm/myllm?style=for-the-badge&logo=PyPI&logoColor=white"></a><br>
        <a href="https://github.com/mraniki/myllm/"><img src="https://img.shields.io/github/actions/workflow/status/mraniki/myllm/%F0%9F%91%B7Flow.yml?style=for-the-badge&logo=GitHub&logoColor=white"></a><br>
        <a href="https://talky.readthedocs.io/projects/myllm/"><img src="https://readthedocs.org/projects/myllm/badge/?version=latest&style=for-the-badge"></a><br>
        <a href="https://codebeat.co/projects/github-com-mraniki-myllm-main"><img src="https://codebeat.co/badges/0567b9d9-3cbb-4263-80ec-8ac8043332ea"/></a> <br>
        <a href="https://app.codacy.com/gh/mraniki/MyLLM/dashboard"><img src="https://app.codacy.com/project/badge/Grade/75f2650d58044355957fe667aeed50a1"/></a> <br>
        <a href="https://codecov.io/gh/mraniki/myllm"><img src="https://codecov.io/gh/mraniki/myllm/branch/main/graph/badge.svg?token=WAHUEMAJN6"/></a><br>
      </td>
      <td align="left">
  Interact with LLM in simple way,<br>via  <a href="https://github.com/xtekky/gpt4free">G4F</a>, <a href="https://github.com/openai/openai-python">OPENAI</a>/<a href="https://localai.io/basics/getting_started/">LOCALAI</a><br>
    </td>
    </tr>
  </table>


  <h5>How to use it</h5>
  <pre>
  <code>
      talky = MyLLM()

      chat = await talky.chat("My name is Jack")
      print(chat)
      

      chat = await talky.chat("tell me who is president of the united states?")
      print(chat)
      
      
      

      chat = await talky.chat("what is my name")
      print(chat)
      

      await talky.export_chat_history()
      
  </code>
  </pre>

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


pkgId: f1b2f1bd6fd966e29286de289d81b21d5ec9a91988e26b9c82dc175efb1872df
name: python-NCBI-id-grab-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for NCBI-id-grab
url: https://pypi.org/project/NCBI-id-grab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NCBI-id-grab-0.0.2-1.src.rpm
location_href: Packages/python-NCBI-id-grab-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This is an example Python package.



  ```bash
  pip install NCBI_grab_package
  ```



  ```python
  from NCBI_grab_package import NCBI_id_grab

  find_NCBI_ID_from_Bacterial_list(bacterial_list)

  ```
  """


pkgId: 29235b5d7d1cc2613630815788fe4f69a3df4d313896666bfd694c37f5492708
name: python-NGPIris-help
arch: noarch
version: 5.1.0
epoch: 0
release: 1
summary: Development documents and examples for NGPIris
url: https://pypi.org/project/NGPIris/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NGPIris-5.1.0-1.src.rpm
location_href: Packages/python-NGPIris-help-5.1.0-1.noarch.rpm
checksum_type: sha256
description:
  NGP IRIS, or just Iris, is a tool for interacting with a Hitachi Content Platform (HCP) using S3 in the `boto3` package. NGP Iris is designed with two use cases in mind:
  * A simple, clear, real-time interaction with NGPr file management
  * Improving process flow for performing off-site data analysis by using automated transfer scripts

  Both of these cases can be achieved as either a [Python package](#as-a-python-package) or as a [Command Line Interface (CLI)](#as-a-command-line-tool).




  * Python 3.11.5[^1]
  * NGPr credentials (see ["NGPr credentials"](#ngpr-credentials))

  [^1]: Most versions of Python 3 should work


  Iris can be installed via PyPi by running the following:
  ```bash
  pip install NGPIris
  ```

  If you wish, you can also install Iris with the following steps:
  1. Clone this repository
  2. Open a terminal in your local copy of the repository
  3. Run `pip install .`. This will install Iris along with the required Python packages in your Python environment


  In order to use Iris, a JSON file containing your credentials for the NGPr. The template of the JSON file can be found in [credentials/credentials_template.json](../credentials/credentials_template.json). Depending on your needs, you can either enter only the credentials for the HCP, only for the HCI ***or*** both. Do note that you can't leave some parts of either the HCP or HCI credentials empty:
  ```JSON
  {
    "hcp" : {
        "endpoint" : "some_endpoint",
        "aws_access_key_id" : "",
        "aws_secret_access_key" : ""
    },
    "hci" : {
        "username" : "some_user",
        "password" : "some_password",
        "address" : "some_address",
        "auth_port" : "some_auth_port",
        "api_port" : "some_api_port"
    }
  }
  ```
  This will prompt Iris to complain about incomplete credentials (since the entries `aws_access_key_id` and `aws_secret_access_key` are empty). Of course, the same error would occur if the reverse between the HCP and HCI fields would be true.

  **NOTE:** the `endpoint` field should not contain `https://` or any port number.


  A thorough package documentation can be found in the [technical documentation page]().


  Iris can be used as a Python package or by using the command line. The following sections cover some examples of how Iris might be used as a package and how to use its various commands. However, we highly recommend checking out the [tutorial](/docs/Tutorial.md) containing more example use cases.



  In order to connect to the HCP, we first need to create an `HCPHandler` object and mount it to some bucket:
  ```Python
  from NGPIris.hcp import HCPHandler

  hcp_h = HCPHandler("credentials.json")

  hcp_h.mount_bucket("myBucket")
  ```
  If you are unsure which buckets you are allowed to see, you can use `hcp_h.list_buckets()` in order to list all available buckets to you.

  When you have successfully mounted a bucket, you can then do different operations onto the bucket. Object names on the bucket can be listed by typing `print(hcp_h.list_objects(True))`.


  ```Python

  hcp_h.upload_file("myFile")


  hcp_h.upload_folder("myFiles/")
  ```


  ```Python

  hcp_h.download_file("myFile")
  ```


  In order to connect to the HCI, we first need to create an `HCIHandler` object and request an authorization token:
  ```Python
  from NGPIris.hci import HCIHandler

  hci_h = HCIHandler("credentials.json")

  hci_h.request_token()
  ```
  Note that the token is stored inside of the `HCIHandler` object called `hci_h`. We can now request a list of indexes that are available by typing `print(hci_h.list_index_names())`. We can also look up information about a certain index with `print(hci_h.look_up_index("myIndex"))`. It is recommended to combine the use of the pretty print module `pprint` and the `json` module for this output, as it is mostly unreadable otherwise:
  ```Python
  from NGPIris.hci import HCIHandler
  from pprint import pprint
  import json

  hci_h = HCIHandler("credentials.json")

  hci_h.request_token()

  pprint(
      json.dumps(
          hci_h.look_up_index("myIndex"),
          indent = 4
      )
  )
  ```


  The `utils` module can be contains two functions: one for converting a string to `base64` encoding and one for `MD5` encoding.


  NGP Iris comes with two commands: `iris` and `iris_generate_credentials_file`. The latter command is used solely to generate the `.json` credentials file. Running `iris_generate_credentials_file --help` we get the following:
  ```
  Usage: iris_generate_credentials_file [OPTIONS]

    Generate blank credentials file for the HCI and HCP.

    WARNING: This file will store sensisitve information (such as passwords) in
    plaintext.

  Options:
    --path TEXT  Path for where to put the new credentials file
    --name TEXT  Custom name for the credentials file
    --help       Show this message and exit.
  ```

  The `iris` command is used for communicating with the HCP and HCI. This includes upload and download to and from the HCP/HCI. Running `iris --help` yields the following:
  ```
  Usage: iris [OPTIONS] CREDENTIALS COMMAND [ARGS]...

    NGP Intelligence and Repository Interface Software, IRIS.

    CREDENTIALS refers to the path to the JSON credentials file.

  Options:
    --version  Show the version and exit.
    --help     Show this message and exit.

  Commands:
    delete-folder    Delete a folder from an HCP bucket/namespace.
    delete-object    Delete an object from an HCP bucket/namespace.
    download         Download files from an HCP bucket/namespace.
    list-buckets     List the available buckets/namespaces on the HCP.
    list-objects     List the objects in a certain bucket/namespace on the...
    simple-search    Make simple search using substrings in a...
    test-connection  Test the connection to a bucket/namespace.
    upload           Upload files to an HCP bucket/namespace.
  ```


  ```
  Usage: iris CREDENTIALS delete-folder [OPTIONS] FOLDER BUCKET

    Delete a folder from an HCP bucket/namespace.

    FOLDER is the name of the folder to be deleted.

    BUCKET is the name of the bucket where the folder to be deleted exist.

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


  ```
  Usage: iris CREDENTIALS delete-object [OPTIONS] OBJECT BUCKET

    Delete an object from an HCP bucket/namespace.

    OBJECT is the name of the object to be deleted.

    BUCKET is the name of the bucket where the object to be deleted exist.

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


  ```
  Usage: iris CREDENTIALS download [OPTIONS] OBJECT BUCKET LOCAL_PATH

    Download files from an HCP bucket/namespace.

    OBJECT is the name of the object to be downloaded.

    BUCKET is the name of the upload destination bucket.

    LOCAL_PATH is the path to where the downloaded objects are to be stored
    locally.

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


  ```
  Usage: iris CREDENTIALS list-buckets [OPTIONS]

    List the available buckets/namespaces on the HCP.

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


  ```
  Usage: iris CREDENTIALS list-objects [OPTIONS] BUCKET

    List the objects in a certain bucket/namespace on the HCP.

    BUCKET is the name of the bucket in which to list its objects.

  Options:
    -no, --name-only BOOLEAN  Output only the name of the objects instead of all
                              the associated metadata
    --help                    Show this message and exit.
  ```


  ```
  Usage: iris CREDENTIALS simple-search [OPTIONS] BUCKET SEARCH_STRING

    Make simple search using substrings in a bucket/namespace on the HCP.

    BUCKET is the name of the bucket in which to make the search.

    SEARCH_STRING is any string that is to be used for the search.

  Options:
    -cs, --case_sensitive BOOLEAN  Use case sensitivity?
    --help                         Show this message and exit.
  ```


  ```
  Usage: iris CREDENTIALS test-connection [OPTIONS] BUCKET

    Test the connection to a bucket/namespace.

    BUCKET is the name of the bucket for which a connection test should be made.

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


  ```
  Usage: iris CREDENTIALS upload [OPTIONS] FILE_OR_FOLDER BUCKET

    Upload files to an HCP bucket/namespace.

    FILE-OR-FOLDER is the path to the file or folder of files to be uploaded.

    BUCKET is the name of the upload destination bucket.

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

  Assuming that the repository has been cloned, run the following tests:
  ```shell
  pytype
  ```
  ```shell
  pytest
  ```

  With force flag `-f`:
  ```shell
  cd docs/
  sphinx-apidoc ../NGPIris/ -o . -F -f
  ```

  Without force flag
  ```shell
  cd docs/
  sphinx-apidoc ../NGPIris/ -o . -F
  ```


  ```shell
  cd docs/
  make html
  ```


pkgId: 9af25e5f3ee55a166eeda33e432fdd4f4ca91d51aa4432b859515b0f51b29d2e
name: python-NLPX-help
arch: noarch
version: 1.7.9
epoch: 0
release: 1
summary: Development documents and examples for NLPX
url: https://gitee.com/summry/nlpx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NLPX-1.7.9-1.src.rpm
location_href: Packages/python-NLPX-help-1.7.9-1.noarch.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

          import torch
          from sklearn.model_selection import train_test_split
          from nlpx.text_token import Tokenizer
          from nlpx.model.classifier import TextCNNClassifier
          from nlpx.model.wrapper import ClassModelWrapper
          from nlpx.dataset import TokenDataset, PaddingTokenCollator

          if __name__ == '__main__':
              classes = ['class1', 'class2', 'class3'...]
              texts = [[str],]
              labels = [0, 0, 1, 2, 1...]
              tokenizer = Tokenizer.from_texts(texts, min_freq=5)
              sent = 'I love you'
              tokens = tokenizer.encode(sent, max_length=6)
              
              sent = tokenizer.decode(tokens)
              

              tokens = tokenizer.batch_encode(texts, padding=False)
              X_train, X_test, y_train, y_test = train_test_split(tokens, labels, test_size=0.2)
              train_set = TokenDataset(X_train, y_train)
              val_set = TokenDataset(X_test, y_test)

              model = TextCNNClassifier(embed_dim=128, vocab_size=tokenizer.vocab_size, num_classes=len(classes))
              model_wrapper = ClassModelWrapper(model, classes=classes)
              model_wrapper.train(train_set, val_set, show_progress=True, collate_fn=PaddingTokenCollator(tokenizer.pad))

              result = model_wrapper.evaluate(val_set, collate_fn=PaddingTokenCollator(tokenizer.pad))
              

              test_inputs = torch.tensor(test_tokens, dtype=torch.long)
              result = model_wrapper.predict(test_inputs)
              

              result = model_wrapper.predict_classes(test_inputs)
              

              result = model_wrapper.predict_proba(test_inputs)
              

              result = model_wrapper.predict_classes_proba(test_inputs)


pkgId: ccaac26d696eb89b9edaad420e3029714ab1fb482d1c9f072f5c835ba3e62c94
name: python-NMFProfiler-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for NMFProfiler
url: https://forgemia.inra.fr/omics-integration/nmfprofiler
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NMFProfiler-0.3.0-1.src.rpm
location_href: Packages/python-NMFProfiler-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  NMFProfiler: A multi-omics integration method for samples stratified in groups



  ![NMFProfiler method scheme](images/nmfprofiler.png)



  NMFProfiler can be installed from PiPy:

  ```
  pip install nmfprofiler
  ```

  In addition, various docker images are provided in the [container registry](https://forgemia.inra.fr/omics-integration/nmfprofiler/container_registry).


  Below is a short illustration of the method on a toy dataset.

  ```python
  from nmfprofiler.nmfprofiler import NMFProfiler
  from nmfprofiler.toyexample import ToyExample


  seed = 240820


  model = NMFProfiler(
      omics=[ToyExample().omic1, ToyExample().omic2],
      y=ToyExample().y,
      seed=seed,
      as_sklearn=False,
      backtrack=True)
  res = model.fit()


  print(res)


  ToyExample().y  # 2 groups
  res.heatmap(obj_to_viz="omic", width=15, height=6, path="", omic_number=1)
  res.heatmap(obj_to_viz="omic", width=15, height=6, path="", omic_number=2)
  ```

  ![](images/omic1_Heatmap.png)
  ![](images/omic2_Heatmap.png)

  *Note: NMFProfiler produces* **as many signatures as groups,** *i.e. levels in* $\mathbf{y}$ *vector. Hence in this case we will obtain 2 signatures.*

  ```python

  res.heatmap(obj_to_viz="W", width=10, height=10, path="")
  ```

  ![](images/W_Heatmap.png)

  ```python

  res.heatmap(obj_to_viz="H", width=15, height=6, path="", omic_number=1)
  res.heatmap(obj_to_viz="H", width=15, height=6, path="", omic_number=2)
  ```

  ![](images/H1_Heatmap.png)
  ![](images/H2_Heatmap.png)

  ```python

  res.barplot_error(width=15, height=6, path="")
  ```

  ![](images/BarplotErrors.png)


  For questions or additional feature requests, use [gitlab issues](https://forgemia.inra.fr/groups/omics-integration/-/issues) if possible. Authors can also be contacted by email (check authors' webpages for email information).


  This work was supported by the ANRT (CIFRE no. 2022/0051).


  GPL-3


  Active

  See [Changelog](https://forgemia.inra.fr/omics-integration/nmfprofiler/-/blob/main/CHANGELOG.md)

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


pkgId: aca474ad7d85d95adcafeeeebb40ccf00b7a1c98a52dfda7cad20aa105743524
name: python-NTkpp-help
arch: noarch
version: 0.0.3.4.1
epoch: 0
release: 1
summary: Development documents and examples for NTkpp
url: https://pypi.org/project/NTkpp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NTkpp-0.0.3.4.1-1.src.rpm
location_href: Packages/python-NTkpp-help-0.0.3.4.1-1.noarch.rpm
checksum_type: sha256
description:
  ﻿NTkpp - Библиотека для построения и обучения нейронных сетей

  Описание:

  NTkpp - это простая и интуитивно понятная библиотека для работы с нейронными сетями. Она предоставляет полный набор инструментов для создания, обучения и оптимизации нейронных сетей. Библиотека ориентирована как на новичков, так и на опытных разработчиков, которым требуется гибкость и возможность тонкой настройки.

  Основные возможности:

  Построение нейронных сетей:

  Создание моделей с использованием класса NeuralNetwork и добавление произвольного количества слоев (DenseLayer).

  Функции активации:

  Поддержка популярных функций активации, таких как ReLU, Sigmoid, Softmax, и гиперболический тангенс.

  Функции потерь:

  Реализация MSE (средняя квадратичная ошибка) и кросс-энтропии для задач регрессии и классификации.

  Оптимизация:

  Поддержка популярных алгоритмов оптимизации, включая SGD, RMSProp, AdaGrad, Adam, и AdaDelta.

  Гибкость и кастомизация:

  Инициализация весов: random, xavier, he, normal.

  Настраиваемые параметры скорости обучения, коэффициента затухания и регуляризации.

  Возможность выбора метода обновления весов для каждого слоя.

  Обучение:

  Функция train поддерживает обучение с использованием полного набора данных или мини-батчей. Также возможна интеграция пользовательских оптимизаторов.


pkgId: c434ea3a2e2e81f2ef77581dd72df8f8607df835fb02b3e6004900c047852ca6
name: python-NUCS-help
arch: noarch
version: 4.3.0
epoch: 0
release: 1
summary: Development documents and examples for NUCS
url: https://github.com/yangeorget/nucs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NUCS-4.3.0-1.src.rpm
location_href: Packages/python-NUCS-help-4.3.0-1.noarch.rpm
checksum_type: sha256
description:
  ![NucS logo](https://github.com/yangeorget/nucs/blob/main/assets/nucs.png?raw=true)


  ![pypi version](https://img.shields.io/pypi/v/nucs?color=blue&label=pypi%20version&logo=pypi&logoColor=white)
  ![pypi downloads](https://img.shields.io/pypi/dm/NUCS)

  ![numba version](https://img.shields.io/badge/numba-v0.60-blue)
  ![numpy version](https://img.shields.io/badge/numpy-v2.0-blue)

  ![tests](https://github.com/yangeorget/nucs/actions/workflows/test.yml/badge.svg)
  ![doc](https://img.shields.io/readthedocs/nucs)
  ![license](https://img.shields.io/github/license/yangeorget/nucs)


  NuCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
  Because it is 100% written in Python,
  NuCS is easy to install and allows to model complex problems in a few lines of code.
  The NuCS solver is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).


  ```bash
  pip install nucs
  ```

  Check out [NUCS documentation](https://nucs.readthedocs.io/).



  ```bash
  NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.queens -n 12 --log_level=INFO
  ```
  ```bash
  2024-11-12 17:24:49,061 - INFO - nucs.solvers.solver - Problem has 3 propagators
  2024-11-12 17:24:49,061 - INFO - nucs.solvers.solver - Problem has 12 variables
  2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses variable heuristic 0
  2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses domain heuristic 0
  2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses consistency algorithm 0
  2024-11-12 17:24:49,061 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
  2024-11-12 17:24:49,200 - INFO - nucs.solvers.multiprocessing_solver - MultiprocessingSolver has 1 processors
  {
      'ALG_BC_NB': 262011,
      'ALG_BC_WITH_SHAVING_NB': 0,
      'ALG_SHAVING_NB': 0,
      'ALG_SHAVING_CHANGE_NB': 0,
      'ALG_SHAVING_NO_CHANGE_NB': 0,
      'PROPAGATOR_ENTAILMENT_NB': 0,
      'PROPAGATOR_FILTER_NB': 2269980,
      'PROPAGATOR_FILTER_NO_CHANGE_NB': 990450,
      'PROPAGATOR_INCONSISTENCY_NB': 116806,
      'SOLVER_BACKTRACK_NB': 131005,
      'SOLVER_CHOICE_NB': 131005,
      'SOLVER_CHOICE_DEPTH': 10,
      'SOLVER_SOLUTION_NB': 14200
  }
  ```


  ```bash
  NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -l 3 --symmetry_breaking --log_level=INFO
  ```
  ```bash
  2024-11-12 17:26:39,734 - INFO - nucs.solvers.solver - Problem has 462 propagators
  2024-11-12 17:26:39,734 - INFO - nucs.solvers.solver - Problem has 504 variables
  2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses variable heuristic 0
  2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses domain heuristic 1
  2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses consistency algorithm 0
  2024-11-12 17:26:39,734 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
  {
      'ALG_BC_NB': 1425,
      'ALG_BC_WITH_SHAVING_NB': 0,
      'ALG_SHAVING_NB': 0,
      'ALG_SHAVING_CHANGE_NB': 0,
      'ALG_SHAVING_NO_CHANGE_NB': 0,
      'PROPAGATOR_ENTAILMENT_NB': 4711,
      'PROPAGATOR_FILTER_NB': 104392,
      'PROPAGATOR_FILTER_NO_CHANGE_NB': 73792,
      'PROPAGATOR_INCONSISTENCY_NB': 621,
      'SOLVER_BACKTRACK_NB': 712,
      'SOLVER_CHOICE_NB': 712,
      'SOLVER_CHOICE_DEPTH': 19,
      'SOLVER_SOLUTION_NB': 92
  }
  ```


  ```bash
  NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.golomb -n 10 --symmetry_breaking --log_level=INFO
  ```
  ```bash
  2024-11-12 17:27:45,110 - INFO - nucs.solvers.solver - Problem has 82 propagators
  2024-11-12 17:27:45,110 - INFO - nucs.solvers.solver - Problem has 45 variables
  2024-11-12 17:27:45,110 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses variable heuristic 0
  2024-11-12 17:27:45,110 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses domain heuristic 0
  2024-11-12 17:27:45,110 - INFO - nucs.solvers.backtrack_solver - BacktrackSolver uses consistency algorithm 2
  2024-11-12 17:27:45,110 - INFO - nucs.solvers.backtrack_solver - Choice points stack has a maximal height of 128
  2024-11-12 17:27:45,172 - INFO - nucs.solvers.backtrack_solver - Minimizing variable 8
  2024-11-12 17:27:45,644 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 80
  2024-11-12 17:27:45,677 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 75
  2024-11-12 17:27:45,677 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 73
  2024-11-12 17:27:45,678 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 72
  2024-11-12 17:27:45,679 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 70
  2024-11-12 17:27:45,682 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 68
  2024-11-12 17:27:45,687 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 66
  2024-11-12 17:27:45,693 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 62
  2024-11-12 17:27:45,717 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 60
  2024-11-12 17:27:45,977 - INFO - nucs.solvers.backtrack_solver - Found a (new) solution: 55
  {
      'ALG_BC_NB': 22652,
      'ALG_BC_WITH_SHAVING_NB': 0,
      'ALG_SHAVING_NB': 0,
      'ALG_SHAVING_CHANGE_NB': 0,
      'ALG_SHAVING_NO_CHANGE_NB': 0,
      'PROPAGATOR_ENTAILMENT_NB': 107911,
      'PROPAGATOR_FILTER_NB': 2813035,
      'PROPAGATOR_FILTER_NO_CHANGE_NB': 1745836,
      'PROPAGATOR_INCONSISTENCY_NB': 11289,
      'SOLVER_BACKTRACK_NB': 11288,
      'SOLVER_CHOICE_NB': 11353,
      'SOLVER_CHOICE_DEPTH': 9,
      'SOLVER_SOLUTION_NB': 10
  }
  [ 1  6 10 23 26 34 41 53 55]
  ```


pkgId: 9b8c7faf6f93a92b0b04271d8d96beb44665f842978e0025d530f51cd9e41103
name: python-Named-Entity-Recognition-BERT-Multilingual-Library-LUX-help
arch: noarch
version: 0.1.14
epoch: 0
release: 1
summary: Development documents and examples for Named-Entity-Recognition-BERT-Multilingual-Library-LUX
url: https://github.com/mehrdadalmasi2020/Named_Entity_Recognition_BERT_Multilingual_Library_LUX
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Named-Entity-Recognition-BERT-Multilingual-Library-LUX-0.1.14-1.src.rpm
location_href: Packages/python-Named-Entity-Recognition-BERT-Multilingual-Library-LUX-help-0.1.14-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/named-entity-recognition-bert-multilingual-library-lux)](https://pepy.tech/project/named-entity-recognition-bert-multilingual-library-lux)




  **Named_Entity_Recognition_BERT_Multilingual_Library_LUX** is a powerful and flexible library for Named Entity Recognition (NER) tasks using BERT models. This library supports multilingual NER and is suitable for key information extraction tasks across various domains such as biomedical, environmental, and technological.

  The library simplifies NER tasks by providing an easy-to-use pipeline for loading data, training models, and making predictions. It is designed for developers, researchers, and data scientists looking for a robust NER solution.
  You can find an example of employing the library at [this Kaggle notebook](https://www.kaggle.com/code/mehrdadal/named-entity-recognition-bert-multilingual-library).




  - **Multilingual Support**: Leverage the power of BERT for NER tasks in multiple languages.
  - **Flexible Input Format**: Works with CoNLL format data.
  - **Easy Integration**: Provides a simple `NERPipeline` class for seamless integration into your projects.
  - **Comprehensive Metrics**: Evaluate your models with precision, recall, F1-score, and accuracy.
  - **Pretrained Models**: Supports any BERT-based pretrained models.



  Install the library using `pip`:
  ```bash
  pip install named-entity-recognition-bert-multilingual-library-lux
  ```





  Here is a complete example of how to use the library for training and predicting:

  ```bash

  !git clone https://github.com/spyysalo/bc2gm-corpus.git
  ```

  ```python
  from Named_Entity_Recognition_BERT_Multilingual_Library_LUX import NERPipeline


  pipeline = NERPipeline(pretrained_model="bert-base-multilingual-cased")


  train_dataset, val_dataset, test_dataset = pipeline.prepare_data(
      "./bc2gm-corpus/conll/train.tsv",
      "./bc2gm-corpus/conll/devel.tsv",
      "./bc2gm-corpus/conll/test.tsv"
  )



  pipeline.initialize_model(num_labels=len(pipeline.label_list))


  pipeline.train(train_dataset, val_dataset,output_dir="/kaggle/temp/bio_ner_results/")


  pipeline.load_model(model_dir="/kaggle/temp/bio_ner_results/best_model/")


  test_metrics = pipeline.test(test_dataset)
  print(test_metrics)


  predictions = pipeline.predict("BRCA1 is a gene associated with breast cancer.")
  print("\nPredictions on New Sentence:")
  for token, label in predictions:
      print(f"{token} | {label}")

  ```



  The input data should be in CoNLL format:

  ```mathematica

  Token1    Label1
  Token2    Label2
  Token3    Label3
  Token4    Label4
  ```



  ```mathematica
  BRCA1       B-GENE
  is          O
  a           O
  gene        O
  associated  O
  with        O
  breast      B-DISEASE
  cancer      I-DISEASE
  .           O
  ```





  The main class providing methods for:

  - **Data Preparation**: Converts CoNLL format to a dataset suitable for BERT.
  - **Model Initialization**: Loads a pretrained BERT model for NER.
  - **Training**: Fine-tunes the model on your data.
  - **Prediction**: Predicts labels for new sentences.
  - **Evaluation**: Computes evaluation metrics (precision, recall, F1, etc.).



  The library also includes utility functions for advanced users:

  - **`load_data`**: Load and parse CoNLL format data.
  - **`convert_to_hf_format`**: Convert data to Hugging Face dataset format.
  - **`compute_metrics`**: Evaluate predictions using `seqeval`.



  The library uses the `seqeval` library to compute the following metrics:

  - Precision
  - Recall
  - F1-Score
  - Accuracy



  - `torch`
  - `transformers`
  - `datasets`
  - `evaluate`
  - `numpy`
  - `seqeval`



  We welcome contributions! Please feel free to open issues or submit pull requests.


pkgId: eb76fc603b7e4976ab3bbe8b05712c523645ab86a2f13b61667cc44890e53ec2
name: python-Named-Entity-Recognition-BERT-Multilingual-Library-LUX-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for Named-Entity-Recognition-BERT-Multilingual-Library-LUX
url: https://github.com/mehrdadalmasi2020/Named_Entity_Recognition_BERT_Multilingual_Library_LUX
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Named-Entity-Recognition-BERT-Multilingual-Library-LUX-0.1.6-1.src.rpm
location_href: Packages/python-Named-Entity-Recognition-BERT-Multilingual-Library-LUX-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/named-entity-recognition-bert-multilingual-library-lux)](https://pepy.tech/project/named-entity-recognition-bert-multilingual-library-lux)




  **Named_Entity_Recognition_BERT_Multilingual_Library_LUX** is a powerful and flexible library for Named Entity Recognition (NER) tasks using BERT models. This library supports multilingual NER and is suitable for key information extraction tasks across various domains such as biomedical, environmental, and technological.

  The library simplifies NER tasks by providing an easy-to-use pipeline for loading data, training models, and making predictions. It is designed for developers, researchers, and data scientists looking for a robust NER solution.
  You can find an example of employing the library at [this Kaggle notebook](https://www.kaggle.com/code/mehrdadal/named-entity-recognition-bert-multilingual-library).




  - **Multilingual Support**: Leverage the power of BERT for NER tasks in multiple languages.
  - **Flexible Input Format**: Works with CoNLL format data.
  - **Easy Integration**: Provides a simple `NERPipeline` class for seamless integration into your projects.
  - **Comprehensive Metrics**: Evaluate your models with precision, recall, F1-score, and accuracy.
  - **Pretrained Models**: Supports any BERT-based pretrained models.



  Install the library using `pip`:
  ```bash
  pip install named-entity-recognition-bert-multilingual-library-lux
  ```





  Here is a complete example of how to use the library for training and predicting:

  ```bash

  !git clone https://github.com/spyysalo/bc2gm-corpus.git
  ```

  ```python
  from Named_Entity_Recognition_BERT_Multilingual_Library_LUX import NERPipeline


  pipeline = NERPipeline(pretrained_model="bert-base-multilingual-cased")


  train_dataset, val_dataset, test_dataset = pipeline.prepare_data(
      "./bc2gm-corpus/conll/train.tsv",
      "./bc2gm-corpus/conll/devel.tsv",
      "./bc2gm-corpus/conll/test.tsv"
  )


  pipeline.initialize_model(num_labels=len(pipeline.label_list))


  pipeline.train(train_dataset, val_dataset)


  test_metrics = pipeline.test(test_dataset)
  print(test_metrics)


  predictions = pipeline.predict("BRCA1 is a gene associated with breast cancer.")
  print("\nPredictions on New Sentence:")
  for token, label in predictions:
      print(f"{token} | {label}")

  ```



  The input data should be in CoNLL format:

  ```mathematica

  Token1    Label1
  Token2    Label2
  Token3    Label3
  Token4    Label4
  ```



  ```mathematica
  BRCA1       B-GENE
  is          O
  a           O
  gene        O
  associated  O
  with        O
  breast      B-DISEASE
  cancer      I-DISEASE
  .           O
  ```





  The main class providing methods for:

  - **Data Preparation**: Converts CoNLL format to a dataset suitable for BERT.
  - **Model Initialization**: Loads a pretrained BERT model for NER.
  - **Training**: Fine-tunes the model on your data.
  - **Prediction**: Predicts labels for new sentences.
  - **Evaluation**: Computes evaluation metrics (precision, recall, F1, etc.).



  The library also includes utility functions for advanced users:

  - **`load_data`**: Load and parse CoNLL format data.
  - **`convert_to_hf_format`**: Convert data to Hugging Face dataset format.
  - **`compute_metrics`**: Evaluate predictions using `seqeval`.



  The library uses the `seqeval` library to compute the following metrics:

  - Precision
  - Recall
  - F1-Score
  - Accuracy



  - `torch`
  - `transformers`
  - `datasets`
  - `evaluate`
  - `numpy`
  - `seqeval`



  We welcome contributions! Please feel free to open issues or submit pull requests.


pkgId: 8c97785b712917c5d80b9633046e14b6d0a538abbd918c1689fa6d72e74128d8
name: python-NaxToPy-help
arch: noarch
version: 2.2.1
epoch: 0
release: 1
summary: Development documents and examples for NaxToPy
url: https://www.idaerosolutions.com/Home/NaxToPy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NaxToPy-2.2.1-1.src.rpm
location_href: Packages/python-NaxToPy-help-2.2.1-1.noarch.rpm
checksum_type: sha256
description:
  ⚠️**Warning:** To use NaxToPy, [**NaxTo**](https://apps.microsoft.com/detail/XP9MMH0KDKGRJN?hl=en-US&gl=US) must be installed.
  This version is compatible with **NaxTo 2024.3**. It is compatible with all the steps of this version (2024.3.0, 2024.3.1).
  Check in _Programs and Features_ the NaxTo version that is installed.
  📘**Note:** If a specific NaxTo version is installed, search the [**NaxToPy History**](https://pypi.org/project/NaxToPy/2.2.0/#history) to find which newer version is compatible with it.

  If python is installed and `pip` is added to the PATH:
  `pip install NaxToPy`
  An alternative, if Python is callable from the command line:
  `python -m pip install NaxToPy`
  For **Visual Studio** users:
  - Open "Python Environments" window
  - Change the "general information" label to "Packages(Pypi)"
  - Write the name of the package and press enter:
  - `NaxToPy` + enter
  For **Spyder** users:
  - If pip is installed: `!pip install NaxToPy`
  - If pip is not installed, download and run `get-pip.py` located in  https://bootstrap.pypa.io/get-pip.py . Then, run the
  `!pip ...` command
  - If no method worked, download the sorce ditribution of the package *NaxToPy* from Test PyPi and the source
  distribution of the packages from PyPi *pythonnet*, *clr-loader*, *cffi*, *pycparser*. Copy and paste the five folder in the
  same directory. When ever you want to use the NaxToPy package add the following lines to your script:
        import sys
        sys.path.append("...\directory")
        import NaxToPy as n2p

  If python is callable from the command line:
  `python -m pip install -U NaxToPy`
  For Visual Studio users:
  - Open "Python Environments" window
  - Change the "general information" label to "Packages(Pypi)"
  - Write the following command on the search bar and press enter:
    `-U NaxToPy` + enter

  To see previous version see the pre-release versions in https://test.pypi.org/project/NaxToPy/

  1. Bug Fix: A new dependece is added to support python 3.12
  2. Bug Fix: N2PLog.set_directory now works correctly
  3. New download page for NaxTo and NaxToPy

  1. Bug Fix: PSOLID with material coordinate = -1 is now suppported
  2. Now, it is possible to modify the BDF data from Nastran and rewrite the files.

  1. New property for the class N2PLoadCase: Solver
  2. New fille that allows the user to call the N2P classes. Useful for typing
  3. N2PCoord don't have the property PartID any more, as it is considered that Coordinates systems don't have parts/superelements
  4. Method for the connectivity property of N2PNode have been optimized

  1. Bug Fix: Property IsTransformable of the N2PComponent class is now right.
  2. Bug Fix: When calling the methods .get_nodes(), get_elements(), etc from a Nastran Input File, the user don't have to specify the part.

  1. New method to create N2PLoadCase as envelope load case of the selected load cases.
  2. The name for derivated load cases is now checked to avoid a repeated name

  1. New class N2PReport. This class allow to create tables of data with the components, incremenets, load cases, etc to generate big reports.
  2. Improvement in typing
  3. Small changes in the core of the package related to libraries finding and loading.

  1. Bug correction for N2PReport. Now it sorts correctly by "LC" or "IDS"
  2. N2PLoadCase has a new property: PathFile.

  1. A bug is fixed that prevented requesting results on global axes.
  2. The typing of some functions is improved.

  1. Bug Fix. If the name for a derivated load case is repeated for a second time, the name is changed.
  2. Bug Fix. Now is possible to change the criteria for a new envelope load case.

  1. Bug fix: A bug has been resolved that previously prevented the generation of a .log file while executing the N2PtoEXE module.
  2. Bug fix: An internal error related to finding the libraries has been resolved.
  3. The option to include a splash image in an executable has been added.

  1. Bug fix for the EXE generation.
  2. Updates in the log messages.

  1. Bug Fix: After calling the method get_load_cases(), the new derived cases weren't found. Now they does.
  2. N2PLoadCase has now two properties for the ID: OriginalID, that was in the files readed and ID that is the one that is used in NaxToPy. Usually, they are the same.
  3. New method new_derived_component() in the class N2PResult that allows to create new N2PComponent based on the original components.
  4. New module N2PUpdateFastener. This module updates the stiffness of the CBUSH and CFAST acordint to their properties and shells properties.

  1. Bug Fix: Now is possible to call the module N2PUpdateFastener

  1. The method new_envelope_loadcase() now has the option to choose the envelope group. Which means the user can ask for
  the LoadCases that are critical or the Increment that is critical instead of the value.

  1. Changes made to align the library with updates in lower-level dependencies.
  2. New internal methods to look for the compatibility with low-level dependencies.
  3. The name of the .log is now NaxToPy_Year-Month-Day.log.

  1. The compatibility is extended to all NaxTo steps of the same version.
  2. The property N2PLoadCase.ActiveIncrement is subtitued by N2PLoadCase.ActiveN2PIncrement.
  It uses an object instaed of an int.
  3. Update of the examples of some docstrings.

  1. Reading a Natran Input File: SPC and SCP1 are now supported.
  2. Bug fix. The order in the components in new_report() does not affect now.
  3. Formula check in new_derived_loadcase(), new_enevelope_loadcase() and new_derived_component().
  4. New optional arguments if n2ptoexe() to add extra libaries, packages or files.

  1. Two new methods in N2PModelContent: load_user_coord_sys_from_csv() and set_user_coord_sys().
  Also, there is a new property for N2PElement and N2PNode: UserSystemArray. This update allow the
  user to define a different coordinate system for each element or node. To ask for the results
  in this system, the optional argument `coordsys` must be equal to `-20`.
  2. Bug fix: The checking for component and section in new_report() has been fixed. If a comma
  appeared in the component or section name, the method failed.

  1. Internal change for speeding up the read of NastranInputFiles. Now the Nastran Cards are loaded
  when they are asked and not all at once.
  2. Improvement in error handling and log writing.
  3. The function import_results_from_files() checks if the file exist. If not, it prints an error
  but the execution doesn't crash.

  1. Feat: New module for fastener analysis: N2PGetFasteners.
  2. Feat: New module for fastener analysis: N2PGetLoadFasteners. Calculates forces in joints and bypass forces.
  3. Bug fix: When a NaxToPy executable file is used on a machine where NaxTo is installed, the libraries are selected accordingly.
  4. Feat: Hidden imports are now allowed in n2ptoexe.
  5. Bug fix: Fixed the rotation of the FORCES tensor. Now the QX and QY components (transverse shears) are calculated correctly.
  6. Refactor: The dictionary and list for Cards have been replaced with a lazy dictionary and a lazy list, improving execution efficiency.
  7. Refactor: Reading the mesh from binary files is now executed in parallel by default, as this approach is more memory-safe.

  1. BugFix: The method set_increment() is fixed.
  2. BugFix: Several bugfix (not in the result accuracy) are fixed in modules N2PGetFastener and N2PGetLoadsFastener. Several optimizations are included.
  3. Feat: Now the method get_load_case() admits a list of int and a list of string and return a list of N2PLoadCase.
  4. Refactor: N2P classes use __slots__ for security and optimization.
  5. Refactor: Complete refactor of the module that loads the NaxTo libraries.
  6. BugFix: in parallel mesh load with a small mesh and lot of results.
  7. BugFix: in sequential mesh load in op2.

  **NaxToPy** is a package developed by Idaero Solutions© as a part of the **NaxTo** software.
  NaxToPy only use three dependeces:
  - NumPy: https://numpy.org/
  - PythonNET: https://pythonnet.github.io/
  - Setuptools: https://setuptools.pypa.io/en/latest/index.html


  - **Nastran:** .op2, .h5, .xdb
  - **Optistruct:** .op2, .h3d
  - **Abaqus:** .odb
  - **Ansys:** .rst, .rth(beta)

  - **Nastran** (.bdf)
  - **Optistruct** (.fem)
  - **Abaqus** (.inp)

  Load your model:
  ```python

  import NaxToPy as N2P
  path = "results_fem.op2"
  model = N2P.load_model(path)
  ```

  ```python


  nodes = model.get_nodes()

  nodelist = model.get_nodes([1, 2, 3])

  node1000 = model.get_nodes(1000)

  element = model.get_elements()

  elementlist = model.get_nodes([10, 20, 30])

  connectorslist = model.get_connectors()

  coordslist = model.get_coords()
  ```

  ```python

  N2P.N2PLog.Info.user("INFO-1000: Running results_fem.py")
  ```

  ```python


  loadcaseslist = model.LoadCases

  pressure_lc = model.get_load_case("pressure")

  pressure_lc.ActiveN2PIncrement = pressure_lc.get_increment(10)

  all_results = pressure_lc.Results

  displacement = pressure_lc.get_result("DISPLACEMENT")

  all_components = displacement.Components

  x_coord = displacement.get_component("X")
  ```

  ```python


  x_list = x_coord.get_result_list()[0]
  ```

  ```python



  x_df = x_coord.get_result_ndarray()
  ```

  Using a different script:
  ```python

  import NaxToPy as N2P
  path1 = "results_fem.py"
  path2 = "results_fem_abaqus.py"
  N2P.n2ptoexe(path1, console=True, solver="NASTRAN")
  N2P.n2ptoexe(path2, console=True, solver="ABAQUS", abaqusversion=["2021", "2022"])
  ```

  Private function that generates the proper index for a data frame using the elemnts or nodes ids:
  ```python

  import pandas as pd
  def _index_dataframe(model: "N2PModelContent", component: "N2PComponent", sections, aveSections, cornerData, aveNodes,
                       variation, realPolar, coordsys, v1, v2) -> pd.Index:
      """ Function that returns the proper index for each component asked
      """
      
      parts = len(model.Parts) - (model.Solver == "Abaqus")
      
      on_items = component.get_result_ndarray(sections, aveSections, cornerData, aveNodes,
                                              variation, realPolar, coordsys, v1, v2)[1]
      
      if on_items == "NODES":
          nodes = model.get_nodes()
          ids = [(nodo.PartID, nodo.ID) if parts > 1 else nodo.ID for nodo in nodes]
          indexname = ["Part", "Grid"] if parts > 1 else ["Grid"]
      elif on_items == "ELEMENTS":
          elements = model.get_elements()
          connectors = model.get_connectors()
          ids = [(element.PartID, element.ID) if parts > 1 else element.ID for element in elements] + \
                [(co.PartID, co.ID) if parts > 1 else co.ID for con in connectors for co in (con if isinstance(con, list) else [con])]
          indexname = ["Part", "Element"] if parts > 1 else ["Element"]
      elif on_items == "ELEMENT NODAL":
          ids = model.elementnodal().values()
          indexname = ["Part", "Grid", "Element"]
      else:
          return None
      
      if isinstance(ids[0], tuple):
          index = pd.MultiIndex.from_tuples(ids, names=indexname)
      else:
          index = ids
      return index
  ```
  Function that generates a DataFrame with the results of a component
  ```python

  def dataframe_result(model: "N2PModelContent", component: "N2PComponent",sections=None, aveSections=-1, cornerData=False,
                       aveNodes=-1, variation=100, realPolar=0, coordsys: int = -1000,
                       v1: tuple = (1,0,0), v2: tuple = (0,1,0)) -> pd.DataFrame:
      """Function that returns as a dataframe of pandas the result array of a component
      """
      
      return pd.DataFrame(data={component.Name:
                                component.get_result_ndarray(sections, aveSections, cornerData, aveNodes, variation,
                                                             realPolar, coordsys, v1, v2)[0]},
                          index=_index_dataframe(model, component, sections, aveSections, cornerData, aveNodes, variation,
                                                 realPolar, coordsys, v1, v2),
                          columns=[component.Name])
  ```
  Function that generates a DataFrame for all the components of a result
  ```python

  def dataframe_results(model: "N2PModelContent", result: "N2PResult", sections=None, aveSections=-1, cornerData=False,
                       aveNodes=-1, variation=100, realPolar=0, coordsys: int = -1000,
                       v1: tuple = (1,0,0), v2: tuple = (0,1,0)) -> pd.DataFrame:
      """Function that generates a DataFrame of pandas with all the components of a result. It uses dataframe_result.
      It uses sequential computing.
      """
      return pd.DataFrame(data={component.Name:
                                    component.get_result_ndarray(sections, aveSections, cornerData, aveNodes, variation,
                                                                 realPolar, coordsys, v1, v2)[0]
                                                                 for component in result.Components.values()},
                          index=_index_dataframe(model, next(iter(result.Components.values())), sections, aveSections,
                                                 cornerData, aveNodes, variation, realPolar, coordsys, v1, v2),
                          columns=[component.Name for component in result.Components.values()])
  ```

  For more documentation visit https://idaerosolutions.com/Home/NaxToPy
  Reference Guide at: https://www.idaerosolutions.com/NaxToPyDoc/NaxToPy.html

  Copyright is owned by Idaero Solutions©

rpm_license:
  Copyright (c) 2024 Idaero Solutions  This freeware license agreement (“agreement”) is a legally binding contract between the individual who downloads the software (“you”) and the licensor, that should be read in its entirety. This is an agreement governing your use this software own by Idaero Solutions, further defined herein as “software”, and the licensor of the software is willing to provide you with access to the software only on the condition that you accept all of the terms and conditions contained in this agreement. You are deemed to have read, understood and accepted all such terms and conditions upon executing a download of any free software.  1. License Grant:  Subject to the terms and conditions of this Agreement, Idaero Solutions grants the User a limited, non-exclusive, non-transferable license to use the Software solely for non commercial purposes. This license does not grant any rights to the source code of the Software. It is only free for non-professional and non-commercial purposes. For commercial and professional purposes, you must install the professional NaxTo(c) version.  2. Ownership:  The User acknowledges that the Software, including any and all intellectual property rights associated with it, is the sole property of Idaero Solutions and/or its Suppliers. The User agrees not to claim ownership or proprietary rights over the Software.  3. Distribution:  The User is allowed to distribute the Software to third parties free of charge, ONLY under .exe files that use the software as a dependence of the script, provided that the distribution includes the complete and unmodified Software package as originally provided by Idaero Solutions. The User must not charge any fees or payments for the distribution of the Software.  4. Modifications:  The User agrees not to modify, adapt, reverse engineer, decompile or disassemble, the Software. Any attempt to do so shall be a violation of this Agreement. The User is allowed to develop further code based on the Software. However, the User agrees that the new software shall be subject to the same license terms as this Agreement, including the prohibition on modification, reverse engineering, and proprietization.  5. Proprietization:  The User agrees not to use the Software or any part thereof to develop a competing product or service or engage in any activities that may lead to the proprietization of the Software.  6. Termination:  This Agreement is effective until terminated. Idaero Solutions may terminate this Agreement immediately and without notice if the User fails to comply with any of the terms and conditions herein. Upon termination, the User must cease all use of the Software and destroy all copies in their possession.  7. Warranty and Liability:  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.  8. An extension of NaxTo(c) from Idaero Solutions:  The software is an extension of the NaxTo software developed by Idaero Solutions. Therefore, the terms of use of this software are an extension of the NaxTo license. In the event of any discrepancies, the NaxTo license takes precedence.  9. Governing Law:  This Agreement shall be governed by and construed in accordance with the laws of the jurisdiction in which Idaero Solutions is located.   IDAERO DISCLAIMS ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IDAERO DOES NOT GUARANTEE THAT THE PRODUCTS WILL MEET LICENSEE'S REQUIREMENTS, OPERATE UNINTERRUPTED OR ERROR-FREE, OR BE COMPATIBLE WITH ANY SPECIFIC HARDWARE OR SOFTWARE. THE ENTIRE RISK ASSOCIATED WITH THE USE, PERFORMANCE, OR RESULTS OBTAINED FROM THE PRODUCTS RESTS WITH THE LICENSEE, NOT IDAERO. IDAERO MAKES NO WARRANTIES REGARDING THE ACCURACY, COMPLETENESS, FUNCTIONALITY, SAFETY, PERFORMANCE, OR ANY OTHER ASPECT OF ANY DESIGN, PROTOTYPE, OR FINAL PRODUCT DEVELOPED BY THE LICENSEE USING THE PRODUCTS.  IN NO EVENT SHALL IDAERO OR ITS SUPPLIERS BE LIABLE FOR INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING BUT NOT LIMITED TO LOSS OF PROFITS OR DATA, DEFECTS IN DESIGN OR PRODUCTS CREATED USING THE PRODUCTS, OR ANY INJURY OR DAMAGE RESULTING FROM SUCH DEFECTS, SUFFERED BY THE LICENSEE OR ANY THIRD PARTY, EVEN IF IDAERO OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THE PRODUCTS PROVIDED HEREUNDER ARE INTENDED ONLY TO AID THE LICENSEE IN DEVELOPING THEIR OWN PRODUCTS OR CONDUCTING DATA ANALYSIS AND ARE NOT INTENDED TO SUBSTITUTE FOR SOUND ENGINEERING JUDGMENT, INDEPENDENT TESTING OF PHYSICAL PROTOTYPES, CAREFUL NUMERICAL REVIEW, OR SOUND BUSINESS JUDGMENT.   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.


pkgId: d18e029825810861a7b2cc7103f38abd0487df3ff4ca69d115f91a5dd09c564b
name: python-NearBeach-help
arch: noarch
version: 0.31.52
epoch: 0
release: 1
summary: Development documents and examples for NearBeach
url: https://nearbeach.org
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NearBeach-0.31.52-1.src.rpm
location_href: Packages/python-NearBeach-help-0.31.52-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub](https://img.shields.io/github/license/robotichead/NearBeach.svg)
  ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/robotichead/NearBeach.svg)
  [![CircleCI](https://circleci.com/gh/NearBeach/NearBeach.svg?style=shield)](https://circleci.com/gh/NearBeach/NearBeach)
  [![PyPI version](https://badge.fury.io/py/NearBeach.svg)](https://badge.fury.io/py/NearBeach)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/NearBeach.svg?style=flat-square)
  ![GitHub stars](https://img.shields.io/github/stars/robotichead/NearBeach.svg?style=social)
  ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/robotichead/nearbeach.svg)
  ![GitHub Sponsors](https://img.shields.io/github/sponsors/robotichead?style=plastic)
  ![Website](https://img.shields.io/website/https/nearbeach.org.svg)
  ![Twitter Follow](https://img.shields.io/twitter/follow/robotichead.svg?style=social)
  [![DeepSource](https://deepsource.io/gh/robotichead/NearBeach.svg/?label=active+issues&show_trend=true&token=cWkQ-pVgAD4EX2rsqV2kEZRq)](https://deepsource.io/gh/robotichead/NearBeach/?ref=repository-badge)

  NearBeach is currently in alpha development. If you find any issues, or require any help, please do not hesitate to
  contact on our [discord server](https://discord.gg/64uhRztS6n).



  NearBeach is an open source project management system, built using Django and VueJS. The phillosophy of NearBeach is to be easy to install and use, be open sourced, and to be flexible. NearBeach is currently aimed at small/personal organisation to large enterprises. Each new module brought to NearBeach expands it's capability tenfold and brings it closer to a competing product.



  -   [Discord](https://discord.gg/64uhRztS6n)
  -   [Documentation](https://nearbeach.readthedocs.io)
  -   [NearBeach Homepage](https://nearbeach.org)



  We welcome all contributions to NearBeach. Read our [Contributing Guide](https://github.com/robotichead/NearBeach/blob/main/CONTRIBUTING.md).



  NearBeach is currently going through a massive rewrite - we have stripped out a lot of the features temporarily. We are however writting them back in. Our focus of the rewrite is to improve UI/UX, and the speed of page rendering.



  We would like to thank the following sponsors. Their contributions have made sure I am coving any costs associated with NearBeach, i.e. hosting. To sponsor you can use either;

  -   [Patreon](https://www.patreon.com/NearBeach)
  -   [Github](https://github.com/sponsors/NearBeach)



  NearBeach will not be where it currently is without the help of other open sourced projects. Below are the references to all the different tools that are utilised within NearBeach. NearBeach would like to thank these projects as they have help construct a better and more stable product. Please consider visiting and donating.



  Thank you to [Browser Stack](http://browserstack.com/) for giving us the ability to test NearBeach on all browsers and devices.
  [![Browser Stack](https://raw.githubusercontent.com/robotichead/Store_Github_Pictures/master/browserstack-logo-600x315.png)](http://browserstack.com/)



  Python Modules - [![Known Vulnerabilities](https://snyk.io/test/github/robotichead/NearBeach/badge.svg?targetFile=NearBeach/requirements.txt)](https://snyk.io/test/github/robotichead/NearBeach?targetFile=NearBeach/requirements.txt)

  JavaScript Modules - [![Known Vulnerabilities](https://snyk.io/test/github/robotichead/NearBeach/badge.svg?targetFile=package.json)](https://snyk.io/test/github/robotichead/NearBeach?targetFile=package.json)



  Creator(s): Evan You

  Github: https://github.com/vuejs/vue

  License: The MIT License (MIT)

  Note: VueJS is used to render all front-end UI.



  Creator(s): Tiny Technologies Inc.

  Github: https://github.com/tinymce/tinymce

  License: GNU Lesser General Public License v2.1

  Note: TinyMCE is used for rich text within NearBeach



  Creator(s): Mark Otto, Jacob Thornton

  Github: https://github.com/twbs/bootstrap

  License: MIT

  Note: NearBeach's CSS is currently being migrated to Bootstrap. For easy development.



  Creator(s): Damian Dulisz, Natalia Tepluhina, Dobromir Hristov, Marina Mosti

  Github: https://github.com/vuelidate/vuelidate

  License: MIT

  Note: We use Vuelidate for validating the form fields before submitting.

rpm_license:
  MIT License  Copyright (c) 2017  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: 24d2bca9a741e4df987ac801f58e7ad6c6a00c77341859016c77d44d0ddad82c
name: python-NeoBase-help
arch: noarch
version: 0.34.1
epoch: 0
release: 1
summary: Development documents and examples for NeoBase
url: https://github.com/alexprengere/neobase
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NeoBase-0.34.1-1.src.rpm
location_href: Packages/python-NeoBase-help-0.34.1-1.noarch.rpm
checksum_type: sha256
description:
  Minimalist `GeoBases <https://github.com/opentraveldata/geobases/>`__
  implementation:
  -  no dependencies
  -  compatible with Python 3.9+, CPython and PyPy
  -  one data source:
     `opentraveldata <https://github.com/opentraveldata/opentraveldata>`__
  -  one Python module for easier distribution on clusters (like Hadoop)
  -  faster load time (5x)
  -  tested with pytest and tox
      >>> from neobase import NeoBase
      >>> b = NeoBase()
      >>> b.get('ORY', 'city_code_list')
      ['PAR']
      >>> b.get('ORY', 'city_name_list')
      ['Paris']
      >>> b.get('ORY', 'country_code')
      'FR'
      >>> b.distance('ORY', 'CDG')
      34.87...
      >>> b.get_location('ORY')
      LatLng(lat=48.72..., lng=2.35...)


pkgId: d6ccc20c842456481295c4fa4b24da53c3254cebab792c24a6b2801f00792acb
name: python-NetAlpha-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for NetAlpha
url: https://github.com/ihtesham-jahangir/alpha_hybird_model
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NetAlpha-0.1.4-1.src.rpm
location_href: Packages/python-NetAlpha-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  - [Introduction](#introduction)
  - [Features](#features)
  - [Installation](#installation)
    - [Prerequisites](#prerequisites)
    - [Installation via Pip](#installation-via-pip)
  - [Usage](#usage)
    - [Command-Line Interface](#command-line-interface)
      - [Basic Usage](#basic-usage)
      - [Options](#options)
      - [Help](#help)
    - [Examples](#examples)
    - [Data Preparation](#data-preparation)
  - [Programmatic Usage](#programmatic-usage)
  - [Project Structure](#project-structure)
  - [Documentation](#documentation)
  - [Contributing](#contributing)
    - [Reporting Issues](#reporting-issues)
  - [License](#license)
  - [Contact](#contact)


pkgId: 369c8956db3892d2c6d8e1b61c2d55aa21e32899a3fe09d8b4adaaba7f8850ed
name: python-NetHyTech-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for NetHyTech
url: https://github.com/AnubhavChaturvedi-GitHub/NetHyTech-Package
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NetHyTech-1.1.0-1.src.rpm
location_href: Packages/python-NetHyTech-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Real-Time Web Monitoring**: Track and log any changes in targeted text on live web interfaces, all updated seamlessly into `input_cmd.txt`.
  - **Advanced Weather Insights**: Retrieve accurate, up-to-the-minute weather data for any specified location.
  - **File Management**: Effortlessly read and write files with single-line commands, optimizing data flow.
  - **Instant Calculations**: Handle arithmetic with precision and speed.
  - **Animated Text Display**: Add animated text effects for a dynamic user experience.


pkgId: 298f42d99a622e6b6b0e9da795af55e9aa6cb83d15e25e5f60f92cfa9705b719
name: python-NeuLogPy-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for NeuLogPy
url: https://github.com/sustronics/neulogpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NeuLogPy-1.2.0-1.src.rpm
location_href: Packages/python-NeuLogPy-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python interface for NeuLog sensors, providing easy-to-use functions for data collection and experiment management.



  - Simple interface for NeuLog sensors
  - Real-time data collection
  - Configurable sampling rates
  - Support for multiple sensors
  - Automatic sensor discovery and configuration
  - Built-in error handling and logging



  ```bash
  pip install NeuLogPy
  ```



  ```python
  from NeuLogPy import NeuLog


  neulog = NeuLog(config_file="config/sensors.yaml")


  sensor_name = "Respiration"
  rate = 8        # 8 Hz sampling rate
  samples = 1000  # Number of samples to collect
  respiration_sensor = [(sensor_name, 1)]  # Sensor name and ID


  neulog.start_experiment(sensors=respiration_sensor, rate=rate, samples=samples)


  samples = neulog.experiment.get_samples()
  if samples:
      print(f"Respiration Samples: {samples}")


  neulog.experiment.stop()
  ```



  Create a `sensors.yaml` file in your config directory:

  ```yaml
  sensors:
    Respiration:
      code: "RESP"
      unit: "AU"
      description: "Respiration sensor"
    
  ```



  - Python >= 3.7
  - pydantic >= 2.0.0
  - requests >= 2.25.0
  - pyyaml >= 5.4.0



  - 1.2.0: Fixed package imports, improved documentation
  - 1.1.1: Initial release



  MIT License



  1. Fork the repository
  2. Create your feature branch
  3. Commit your changes
  4. Push to the branch
  5. Create a new Pull Request



  For support, please open an issue on the GitHub repository or contact info@sustronics.com.


pkgId: b2710bde129f20d24dba6df8e3c3be194ac9f28b2a8d6be27ea19a9717a9a2d1
name: python-NeuralProcesses-help
arch: noarch
version: 0.2.7
epoch: 0
release: 1
summary: Development documents and examples for NeuralProcesses
url: https://pypi.org/project/NeuralProcesses/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NeuralProcesses-0.2.7-1.src.rpm
location_href: Packages/python-NeuralProcesses-help-0.2.7-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/wesselb/neuralprocesses/workflows/CI/badge.svg)](https://github.com/wesselb/neuralprocesses/actions?query=workflow%3ACI)
  [![Coverage Status](https://coveralls.io/repos/github/wesselb/neuralprocesses/badge.svg?branch=main)](https://coveralls.io/github/wesselb/neuralprocesses?branch=master)
  [![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://wesselb.github.io/neuralprocesses)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  A framework for composing Neural Processes in Python.



  ```
  pip install neuralprocesses tensorflow tensorflow-probability  # For use with TensorFlow
  pip install neuralprocesses torch                              # For use with PyTorch
  ```

  If something is not working or unclear, please feel free to open an issue.



  See [here](https://wesselb.github.io/neuralprocesses).



  Here you go:

  ```python
  import torch

  import neuralprocesses.torch as nps


  convcnp = nps.construct_convgnp(dim_x=1, dim_y=2, likelihood="het")


  opt = torch.optim.Adam(convcnp.parameters(), 1e-3)


  for _ in range(32):
      
      
      xc = torch.randn(16, 1, 10)  # Context inputs
      yc = torch.randn(16, 2, 10)  # Context outputs
      xt = torch.randn(16, 1, 15)  # Target inputs
      yt = torch.randn(16, 2, 15)  # Target output

      
      loss = -torch.mean(nps.loglik(convcnp, xc, yc, xt, yt, normalise=True))
      opt.zero_grad(set_to_none=True)
      loss.backward()
      opt.step()


  mean, var, noiseless_samples, noisy_samples = nps.predict(
      convcnp,
      torch.randn(16, 1, 10),  # Context inputs
      torch.randn(16, 2, 10),  # Context outputs
      torch.randn(16, 1, 15),  # Target inputs
  )
  ```


pkgId: a159ea5f40196dbf8ff3c6da2361be2f7f4d34866828d4369b678dd7ee6feca1
name: python-NlpToolkit-Classification-help
arch: noarch
version: 1.0.17
epoch: 0
release: 1
summary: Development documents and examples for NlpToolkit-Classification
url: https://github.com/StarlangSoftware/Classification-Py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NlpToolkit-Classification-1.0.17-1.src.rpm
location_href: Packages/python-NlpToolkit-Classification-help-1.0.17-1.noarch.rpm
checksum_type: sha256
description:
  Machine learning is about optimization. In learning via optimization, we define an error function (loss function) on the model and try to optimize it, i.e., try to find the optimal parameters of the model by optimization techniques borrowed from optimization literature.
  Machine learning is about algorithms. In decision/regression trees, we need to write a recursive-learning algorithm to classify the data arriving at each decision node, and we also need to write a recursive code to generate the decision tree structure.
  Machine learning is about statistics. We usually assume Gaussian noise on the data, we assume multivariate normal distribution on class covariance matrices in quadratic discriminant analysis, and we use cross-validation or bootstrapping to generate multiple training sets.
  Machine learning is about models. In decision trees, the data structure is a binary/L-ary tree depending on the type of the features and the decision function used.
  Machine learning is about performance metrics. In classification, we use accuracy if we want to get a crude estimate on the performance of the classifier. If we need more details on pairwise classes, confusion matrix comes in handy. If the dataset has two classes, more metrics follow: precision, recall, true positive rate, false positive rate, F-measure, etc.
  What is machine learning about? Like defining an elephant, we need the combination of all of these topics to define machine learning: we start machine learning by assuming a certain model on the data, use algorithmic and/or optimization and/or statistical techniques to learn the parameters of that model (which is sometimes defined as curve fitting), and use performance metrics to evaluate our model/algorithm/classifier.


  The most commonly used representative of nonparametric algorithms is the nearest neighbor. The assumption of nearest neighbor is simple, the world does not change much, i.e., similar things perform similarly. Therefore, we only need to store the dataset itself and make the decision on the test instance based on the similarity of it to the instances in the dataset. In other words, the class label of an instance is strongly influenced by its nearby instances.

  If the class distributions are assumed to follow Gaussian density, we obtain our first parametric classifier, namely, quadratic discriminant. The number of parameters, i.e., the model complexity is Kd + Kd (d + 1) / 2, the first part is for class means and the second part for class covariance matrices.
  We can assume a single shared covariance matrix for all classes. In this case, simplifying the function reduces to our second classifier, namely, linear discriminant. The model complexity is Kd + d (d + 1) / 2, where the first part is for class means and the second part for shared covariance matrix.
  When we assume all off-diagonals of the shared covariance matrix are zero; we get the naive Bayes classifier. The model complexity is Kd + d, where the first part is for class means and the second part for the diagonal of the shared covariance matrix.
  We further reduce by taking priors equal and a single covariance value s. In this case, we get the nearest mean classifier and the model complexity is only Kd + 1.

  Decision trees have a tree-based structure where each non-leaf node m implements a decision function, f<sub>m</sub>(x), and each leaf node corresponds to a class decision. Second, they are one of most interpretable learning algorithms available. When written as a set of IF-THEN rules, the decision tree can be transformed into a human-readable format, which then can be modified and/or validated by human experts in their corresponding domains.

  Kernel machines, in other words, support vector machines, are maximum margin methods, where the model is written as a weighted sum of support vectors. Kernel machines are discriminative methods, i.e., they are only interested in the instances across the class boundaries in classification, or instances across the regressor in regression. For obtaining the optimal separating hyperplane, kernel machines try to maximize separability, or margin, and write the problem as a quadratic optimization problem, whose solution gives us support vectors.

  Artificial neural networks (ANN) take their inspiration from the brain. The brain consists of billions of neurons and these neurons are interconnected and work in parallel, which makes the brain a powerful computing machine. Each neuron is connected through synapses to thousands of neurons and the firing of a neuron depends on those synapses.
  There are three types of neurons (units) in ANN. Each unit except the input unit takes an input and calculates an output. Input units represent a single input feature x<sub>i</sub> or the bias = +1. Hidden units calculate an intermediate output from its inputs. They first combine their inputs linearly and then use nonlinear activation functions to map that linear combination to a nonlinear space. Output units calculate the output of the ANN.


pkgId: 2c72da3edf7687b2170d1b3b3c5671fd6e497fc95fbd267ca056e6a4726357e7
name: python-Nuitka-winsvc-debuginfo
arch: aarch64
version: 2.5.6
epoch: 0
release: 1
summary: Debug information for package python-Nuitka-winsvc
url: https://github.com/tabris17/Nuitka-winsvc
rpm_license: Apache License, Version 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-Nuitka-winsvc-2.5.6-1.src.rpm
location_href: Packages/python-Nuitka-winsvc-debuginfo-2.5.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Nuitka-winsvc.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 847bae89eb28c250e433be07e49c2f7760cd0d6118315a418d5714bef0b25159
name: python-Nuitka-winsvc-debugsource
arch: aarch64
version: 2.5.6
epoch: 0
release: 1
summary: Debug sources for package python-Nuitka-winsvc
url: https://github.com/tabris17/Nuitka-winsvc
rpm_license: Apache License, Version 2.0
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-Nuitka-winsvc-2.5.6-1.src.rpm
location_href: Packages/python-Nuitka-winsvc-debugsource-2.5.6-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Nuitka-winsvc.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 283d0641289a135b1256b615d3f1b967c3ad102f2b33bfdc819e70012da2adb6
name: python-Nuitka-winsvc-help
arch: aarch64
version: 2.5.6
epoch: 0
release: 1
summary: Development documents and examples for Nuitka-winsvc
url: https://github.com/tabris17/Nuitka-winsvc
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Nuitka-winsvc-2.5.6-1.src.rpm
location_href: Packages/python-Nuitka-winsvc-help-2.5.6-1.aarch64.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/Nuitka-winsvc) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Nuitka-winsvc) ![License](https://img.shields.io/github/license/tabris17/Nuitka-winsvc)

  Nuitka-winsvc is a forked version of Nuitka, it supports compiling EXE as a Windows service.



  You can install Nuitka-winsvc by pip:

  ```shell
  pip install nuitka-winsvc
  ```



  In addition to supporting all the command line arguments of Nuitka, Nuitka-winsvc also provides 7 additional arguments for compiling the Windows services:

  - `--windows-service`
    Enable Windows service mode, works only when compiling for Windows and **onefile** mode enabled.
  - `--windows-service-name`
    Name of the Windows service. If not provided, the target program name will be used as the service name.
  - `--windows-service-display-name`
    Display name of the Windows service. If not provided, the product name will be attempted to use.
  - `--windows-service-description`
    Description of the Windows service. If not provided, the file description will be attempted to use.
  - `--windows-service-cmdline`
    Additional command line arguments that will be passed to the service, such as `--config config.json --output output.log` .
  - `--windows-service-install`
    Windows service installation command-line argument. Default value is `install` .
  - `--windows-service-uninstall`
    Windows service uninstallation command-line argument. Default value is `uninstall` .

  Use the following command to build a Windows service:

  ```shell
  python -m nuitka --onefile --output-dir=build --windows-service --windows-service-name=myservice --windows-service-display-name="My Service" --windows-service-description="This is the description of my service" --windows-service-cmdline="-c config.yml -o output.log" --windows-service-install=install --windows-service-uninstall=uninstall main.py
  ```

  When the python program is compiled successfully, you can use the following command to install the service:

  ```shell
  .\main.exe install
  ```

  Also you can use the following command to uninstall the service:

  ```shell
  .\main.exe uninstall
  ```

  Note: Administrator privileges is required when installing and uninstalling the Windows services. You should run the above commands as administrator.

  The compiled EXE executable file can be run both as a Windows service and as a regular Windows program. However, it is important to note that the Windows service installation and uninstallation command-line arguments which specified by `--windows-service-install` and `--windows-service-uninstall` of Nuitka-winsvc compilation arguments will override the original behavior of the program. Therefore, the compiled Python program should avoid using the same command line arguments.


pkgId: e87837cd6573366045bbe763374cac6e79fe08681f38e37fc089d3faafc34d8e
name: python-NyxCrypta-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for NyxCrypta
url: https://github.com/Division-of-Cyber-Anarchy/NyxCrypta
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-NyxCrypta-1.2.1-1.src.rpm
location_href: Packages/python-NyxCrypta-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  *Simplicity is the ultimate sophistication. - Leonardo da Vinci*
  [Malic1tus]: <https://github.com/malic1tus>
  [Calypt0sis]: <https://github.com/calypt0sis>
  [NyxCrypta]: <https://github.com/nyxcrypta>
  [Viral0x]: <https://github.com/viral0x>


pkgId: f3f30d5156c4826c759b1a1f47594b35dfc2c77eeebe446422b3227cbddf6f7a
name: python-OASYS1-ESRF-Extensions-help
arch: noarch
version: 0.0.89
epoch: 0
release: 1
summary: Development documents and examples for OASYS1-ESRF-Extensions
url: https://github.com/oasys-esrf-kit/OASYS1-ESRF-Extensions
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OASYS1-ESRF-Extensions-0.0.89-1.src.rpm
location_href: Packages/python-OASYS1-ESRF-Extensions-help-0.0.89-1.noarch.rpm
checksum_type: sha256
description:
  OASYS extensions for the ESRF

  This repository contains extensions to Oasys developed at ESRF.



  To install the add-on as user:

  + In the Oasys window, open "Options->Add-ons..."
  + click the button "Add more" and enter "OASYS1-ESRF-Extensions". You will see a new entry "ESRFExtensions" in the add-on list. Check it and click "OK"
  + Restart Oasys.

  ![addon menu](https://github.com/oasys-esrf-kit/OASYS1-ESRF-Extensions/blob/master/images/image2.png "addon menu")

  Once it is installed, it should populate the widget bar on the side.

  ![side menu](https://github.com/oasys-esrf-kit/OASYS1-ESRF-Extensions/blob/master/images/image1.png "side menu")



  To install it as developper, download it from github:
  ```
  git clone  https://github.com/oasys-esrf-kit/OASYS1-ESRF-Extensions
  cd OASYS1-ESRF-Extensions
  ```

  Then link the source code to your Oasys python (note that you must use the python that Oasys uses):
  ```
  python -m pip install -e . --no-deps --no-binary :all:
  ```

  When restarting Oasys, you will see the ESRF addons there.



  First create a new version using your developper installation. Do not forget to increment the version number in setup.py

  + Then run:

  ```
  python setup.py sdist
  ```

  + Followed by:

  ```
  python -m twine upload dist/OASYS1-ESRF-Extensions-X.X.X.tar.gz
  ```

  You need an account in pypi.org and be authorized in https://pypi.org/project/OASYS1-ESRF-Extensions/


pkgId: 1c7c5f43608573c972ab3e4561ca50976b8210d272e02827b1d9ae27cb90481f
name: python-OASYS1-shadow4-help
arch: noarch
version: 0.0.63
epoch: 0
release: 1
summary: Development documents and examples for OASYS1-shadow4
url: https://github.com/oasys-kit/OASYS1-SHADOW4
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OASYS1-shadow4-0.0.63-1.src.rpm
location_href: Packages/python-OASYS1-shadow4-help-0.0.63-1.noarch.rpm
checksum_type: sha256
description:
  This is the official user interface for SHADOW4 (https://github.com/oasys-kit/shadow4). It is presented as an OASYS add-on.



  To install the add-on as user:

  + In the Oasys window, open "Options->Add-ons..."
  + Check the options "Shadow4" and "Shadow4 Avdanced". Click "OK"
  + Restart Oasys.



  A collection of workspaces are being created containing parallel branches of simulations with shadow3 and shadow4. They are in the repository https://github.com/oasys-kit/shadow4workspaces

  Please report issues in https://github.com/oasys-kit/shadow4/issues


pkgId: 815dc139b02ac53a05dce938130bb27568f04aa8a9d5b1785c8aa29c6c66bb32
name: python-ObjectNat-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for ObjectNat
url: https://pypi.org/project/ObjectNat/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ObjectNat-0.2.6-1.src.rpm
location_href: Packages/python-ObjectNat-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI version](https://img.shields.io/pypi/v/objectnat.svg)](https://pypi.org/project/objectnat/)

  - [РИДМИ (Russian)](README_ru.md)
  <p align="center">
  <img src="https://github.com/user-attachments/assets/d3878cce-8eba-4f96-8458-9a798d436120" alt="logo" width="400">
  </p>





  - [IduEdu](https://github.com/DDonnyy/IduEdu) : `IduEdu` provides graph functions
  - [population-restorator](https://github.com/kanootoko/population-restorator) : `restorator` provides city resettlement



  1. **[City graph from OSM (IduEdu)](./examples/get_any_graph.ipynb)** - Functions to assemble a road, pedestrian,
     and public transport graph from OpenStreetMap (OSM) and creating Intermodal graph.

     <img src="https://github.com/user-attachments/assets/8dc98da9-8462-415e-8cc8-bdfca788e206" alt="IntermodalGraph" height="250">

  2. **[Adjacency matrix](./examples/calculate_adjacency_matrix.ipynb)** - Calculate adjacency matrix based on the provided
     graph and edge weight type (time or distance). The intermodal graph can be obtained using the previous example.

  3. **[Isochrones,transport accessibility](./examples/isochrone_generator.ipynb)** - Function for generating isochrones to
     analyze transportation accessibility from specified starting coordinates. Isochrones can be constructed based on
     pedestrian, automobile, or public transport graphs, or a combination thereof.

     <img src="https://github.com/user-attachments/assets/37f308a5-db56-497d-b080-4edef3584fe5" alt="isochrones" height="250">

  4. **[Population restoration](./examples/restore_population.ipynb)** - Function for resettling population into the provided
     layer of residential buildings. This function distributes people among dwellings based on the total city population
     and the living area of each house.
  5. **[Service provision](./examples/calculate_provision.ipynb)** - Function for calculating the provision of residential
     buildings and population with services.

     <img src="https://github.com/user-attachments/assets/5f2b3c55-9a02-4d70-80f4-503b77023eda" alt="ProvisionSchools" height="250">

  6. **[Visibility analysis](./examples/visibility_analysis.ipynb)** - Function to get a quick estimate of visibility from a
     given point(s) to buildings within a given distance. Also, there is a visibility catchment area calculator for a
     large
     urban area. This function is designed to work with at least 1000 points spaced 10-20 meters apart for optimal
     results. Points can be generated using a road graph and random point distribution along edges.

     <img src="https://github.com/user-attachments/assets/2927ac86-01e8-4b0e-9ea8-72ad81c13cf5" alt="visibility-from-point" height="250">

     <img src="https://github.com/user-attachments/assets/b5b0d4b3-a02f-4ade-8772-475703cd6435" alt="visibility-catchment-area" height="250">

  7. **[Point clusterization](./examples/point_clusterization.ipynb)** - Function to generate cluster polygons for given
     points based on a specified minimum distance and minimum points per cluster. Optionally, calculate the relative ratio
     between types of services within the clusters.

     <img src="https://github.com/user-attachments/assets/2a9ad722-87d2-4954-9612-5ac3765aa824" alt="service-clusterization" height="250">

  8. **[Living buildings from OSM](./examples/download_buildings_from_osm.ipynb)** - This function downloads building geometries from OpenStreetMap (OSM) for a specified territory and assigns attributes to each building. Specifically, it determines whether a building is residential (`is_living` attribute) and estimates the approximate number of inhabitants (`approximate_pop` attribute).

     <img src="https://github.com/user-attachments/assets/d60dcd85-1a2e-4342-aae4-561aeda18858" alt="Living buildings" height="250">



  **ObjectNat** can be installed with ``pip``:

  ```
  pip install ObjectNat
  ```


  ```python
  from objectnat import config

  config.set_timeout(10)  # Timeout for overpass queries
  config.change_logger_lvl('INFO')  # To mute all debug msgs
  config.set_enable_tqdm(False)  # To mute all tqdm's progress bars
  config.set_overpass_url('http://your.overpass-api.de/interpreter/URL')
  ```


  - [NCCR](https://actcognitive.org/) - National
    Center for Cognitive Research
  - [IDU](https://idu.itmo.ru/) - Institute of
    Design and Urban Studies
  - [Natalya Chichkova](https://t.me/nancy_nat) - project manager
  - [Danila Oleynikov (Donny)](https://t.me/ddonny_dd) - lead software engineer


pkgId: 671fd131f3c1ef75e66b26c97fefa45b714b92daa992654ca295a285c6ab53ef
name: python-Oneliner-Py-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for Oneliner-Py
url: https://github.com/yunline/Oneliner-Py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Oneliner-Py-1.2.0-1.src.rpm
location_href: Packages/python-Oneliner-Py-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![oneliner-py](https://github.com/yunline/Oneliner-Py/assets/31395137/97ba030b-5d44-4810-9aad-7fed718f18fb)

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Oneliner-Py)](https://pypi.org/project/Oneliner-Py/)
  [![PyPI - License](https://img.shields.io/pypi/l/Oneliner-Py)](https://github.com/yunline/Oneliner-Py/blob/main/LICENSE)
  ![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/yunline/e86b754a309a222ab53215c9d5ff5594/raw/Oneliner-Py_coverage.json)
  [![Tests](https://github.com/yunline/Oneliner-Py/actions/workflows/run_test.yml/badge.svg)](https://github.com/yunline/Oneliner-Py/actions/workflows/run_test.yml)

  [![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)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)

  Convert python scripts into **oneliner** expression.


  ```
  python3 -m oneliner [input file] -o [output file]
  ```

  Or use `python3 -m oneliner -h` for help.


  InputFile:
  ```python
  import random
  y,h=0,2
  msg='hello_world'
  while y<h*2:
      for x in range(len(msg)+2):
          print(random.choice('/\\'),end='')
      y+=1
      if y==h:
          print('\n %s '%msg)
      else:
          print('')
  ```
  OutputFile:
  ```py
  [(importlib := __import__('importlib')), (itertools := __import__('itertools')), (random := importlib.import_module('random')), (__ol_assign_qqaleuwbod := (0, 2)), (y := __ol_assign_qqaleuwbod[0]), (h := __ol_assign_qqaleuwbod[1]), (msg := 'hello_world'), [[[print(random.choice('/\\'), end='') for x in range(len(msg) + 2)], y.__iadd__(1) if hasattr(y, '__iadd__') else (y := (y + 1)), print('\n %s ' % msg) if y == h else print('')] for _ in itertools.takewhile(lambda _: y < h * 2, itertools.count())]]
  ```


  ```shell
  pip install Oneliner-Py
  ```
  Or
  ```shell
  git clone https://github.com/yunline/Oneliner-Py.git
  cd ./Oneliner-Py
  python3 -m pip install .
  ```


  This converter requires **python 3.10+**
  The converted scripts should be able to run on **python 3.8+**


  Following statements are not able to be converted as oneliner.

  - `from-import *` (from-import with star)
  - `yield` and `yield from`
  - `try-except-finally` statements
  - `raise` statement
  - `with` statement
  - `assert` statement
  - `del` statement
  - `async-xxx` statements
  - `match-case` statement (new in Python 3.10)
  - `type` statement (new in 3.12)


pkgId: ef5615c74bf0db15c75565680d2e96c9c1bb94e3e41fbfd2a19fba036e8af8e0
name: python-OnspringApiSdk-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for OnspringApiSdk
url: https://github.com/StevanFreeborn/onspring-api-sdk-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OnspringApiSdk-2.0.2-1.src.rpm
location_href: Packages/python-OnspringApiSdk-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  The python SDK for **version 2** of the Onspring API is meant to simplify development in Python for Onspring customers who want to build integrations with their Onspring instance.

  **Note:**
  This is an unofficial SDK for the Onspring API. It was not built in consultation with Onspring Technologies LLC or a member of their development team.

  This SDK was developed independently using their existing C# SDK, their swagger page, and api documentation as the starting point with the intention of making development of integrations done in Python with an Onspring instance quicker and more convenient.





  Requires use of Python 3.10.0 or later.



  All methods for the `OnspringClient` make use of the [Requests](https://docs.python-requests.org/en/latest/) library to interact with the endpoints of version 2 of the Onspring API.



  Install the SDK using pip:

  `pip install OnspringApiSdk`



  In order to successfully interact with the Onspring Api you will need an API key. API keys are obtained by an Onspring user with permissions to at least **Read** API Keys for your instance via the following steps:

  1. Login to the Onspring instance.
  2. Navigate to **Administration** > **Security** > **API Keys**
  3. On the list page, add a new API Key - this will require **Create** permissions - or click an existing API key to view its details.
  4. Click on the **Developer Information** tab.
  5. Copy the **X-ApiKey Header** value from this tab.





  The most common way to use the SDK is to create an `OnspringClient` instance and call its methods. Its constructor requires two parameters:

  - `baseUrl` - currently this should always be: `https://api.onspring.com`
  - `apiKey` - the value obtained by following the steps in the **API Key** section

  It is best practice to read these values in from a configuration file for both flexibility and security purposes.

  Example `config.ini` file:

  ```ini
  [prod]
  key = 000000ffffff000000ffffff/00000000-ffff-0000-ffff-000000000000
  url = https://api.onspring.com
  ```

  Example constructing `OnspringClient`:

  ```python
  from OnspringApiSdk.OnspringClient import OnspringClient
  from configparser import ConfigParser

  cfg = ConfigParser()
  cfg.read('config.ini')

  key = cfg['prod']['key']
  url = cfg['prod']['url']

  client = OnspringClient(url, key)
  ```



  Each `OnspringClient` method - aside from `CanConnect` - returns an `ApiResponse` object which will have the following properties:

  - `statusCode` - The http status code of the response.
  - `data` - If the request was successful will contain the response data deserialized to custom python objects.
  - `message` - A message that may provide more detail about the requests success or failure.
  - `raw` - Exposes the raw response object of the request if you'd like to handle it directly.

  The goal with this `ApiResponse` object is to provide the flexibility to do with the response what you'd like as well as already having the raw JSON response deserialized to python objects.

  If you do want to handle and/or manipulate the response object yourself you will want to use the value of the `ApiResponse`'s `raw` property which will be a [`Response`](https://docs.python-requests.org/en/latest/user/advanced/#request-and-response-objects) object from the [Requests](https://docs.python-requests.org/en/latest/) library.



  You may wish to refer to the full [Onspring API documentation](https://software.onspring.com/hubfs/Training/Admin%20Guide%20-%20v2%20API.pdf) when determining which values to pass as parameters to some of the `OnspringClient` methods. There is also a [swagger page](https://api.onspring.com/swagger/index.html) that you can use for making exploratory requests.



  The examples that follow assume you have created an `OnspringClient` as described in the **Start Coding** section.





  ```python
  canConnect = client.CanConnect()

  if canConnect:
      print('Connected successfully')
  else:
      print('Attempt to connect failed')
  ```





  Returns a paged collection of apps and/or surveys that can be paged through. By default the page size is 50 and page number is 1.

  ```python
  response = client.GetApps()

  print(f'Status Code: {response.statusCode}')
  print(f'Page Size: {response.data.pageSize}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Total Pages: {response.data.totalPages}')
  print(f'Total Records: {response.data.totalRecords}')

  for app in response.data.apps:
      print(f'Id: {app.id}')
      print(f'Name: {app.name}')
      print(f'href: {app.href}')
  ```

  You can set your own page size and page number (max is 1,000) as well.

  ```python
  from OnspringApiSdk.Models import PagingRequest

  pagingRequest = PagingRequest(1, 100)
  response = client.GetApps(pagingRequest)

  print(f'Status Code: {response.statusCode}')
  print(f'Page Size: {response.data.pageSize}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Total Pages: {response.data.totalPages}')
  print(f'Total Records: {response.data.totalRecords}')

  for app in response.data.apps:
      print(f'Id: {app.id}')
      print(f'Name: {app.name}')
      print(f'href: {app.href}')
  ```



  Returns an Onspring app or survey according to provided id.

  ```python
  response = client.GetAppById(appId=195)

  print(f'Status Code: {response.statusCode}')
  print(f'id: {response.data.app.id}')
  print(f'Name: {response.data.app.name}')
  print(f'href: {response.data.app.href}')
  ```



  Returns a collection of Onspring apps and/or surveys according to provided ids.

  ```python
  response = client.GetAppsByIds(appIds=[195, 240])

  print(f'Status Code: {response.statusCode}')
  print(f'Count: {response.data.count}')

  for app in response.data.apps:
      print(f'Id: {app.id}')
      print(f'Name: {app.name}')
      print(f'href: {app.href}')
  ```





  Example `PrintField` method referenced in following examples.

  ```python
  def PrintField(field: Field):

      print('Field:')
      print(f' Id: {field.id}')
      print(f' App Id: {field.appId}')
      print(f' Name: {field.name}')
      print(f' Type: {field.type}')
      print(f' Status: {field.status}')
      print(f' IsRequired: {field.isRequired}')
      print(f' IsUnique: {field.isUnique}')

      if field.type == 'Formula':

          print(f' Output Type: {field.outputType}')

          if field.outputType == 'ListValue':

              print(f' Multiplicity: {field.multiplicity}')
              print(' Values:')

              for value in field.values:

                  print(f'  {value.AsString()}')

      if field.type == 'List':

          print(f' Multiplicity: {field.multiplicity}')
          print(' Values:')

          for value in field.values:

              print(f'  {value.AsString()}')
  ```



  Returns an Onspring field according to provided id.

  ```python
  response = client.GetFieldById(fieldId=9686)

  print(f'Status Code: {response.statusCode}')
  PrintField(response.data.field)
  ```



  Returns a collection of Onspring fields according to provided ids.

  ```python
  response = client.GetFieldsByIds(fieldIds=[9686, 9687])

  print(f'Status Code: {response.statusCode}')
  print(f'Count: {response.data.count}')

  for field in response.data.fields:
      PrintField(field)
  ```



  Returns a paged collection of fields that can be paged through. By default the page size is 50 and page number is 1.

  ```python
  response = client.GetFieldsByAppId(appId=195)

      print(f'Status Code: {response.statusCode}')
      print(f'Page Size: {response.data.pageSize}')
      print(f'Page Number: {response.data.pageNumber}')
      print(f'Total Pages: {response.data.totalPages}')
      print(f'Total Records: {response.data.totalRecords}')

      for field in response.data.fields:
          PrintField(field)
  ```

  You can set your own page size and page number (max is 1,000) as well.

  ```python
  from OnspringApiSdk.Models import PagingRequest

  pagingRequest = PagingRequest(1, 100)

  response = client.GetFieldsByAppId(appId=195, pagingRequest)

      print(f'Status Code: {response.statusCode}')
      print(f'Page Size: {response.data.pageSize}')
      print(f'Page Number: {response.data.pageNumber}')
      print(f'Total Pages: {response.data.totalPages}')
      print(f'Total Records: {response.data.totalRecords}')

      for field in response.data.fields:
          PrintField(field)
  ```





  Returns the Onspring file's metadata.

  ```python
  response = client.GetFileInfoById(recordId=1, fieldId=6990, fileId=274)

  print(f'Status Code: {response.statusCode}')
  print(f'Name: {response.data.fileInfo.name}')
  print(f'Type: {response.data.fileInfo.type}')
  print(f'Owner: {response.data.fileInfo.owner}')
  print(f'Content Type: {response.data.fileInfo.contentType}')
  print(f'Created Date: {response.data.fileInfo.createdDate}')
  print(f'Modified Date: {response.data.fileInfo.modifiedDate}')
  print(f'File Href: {response.data.fileInfo.fileHref}')
  ```



  Returns the file itself.

  ```python
  response = client.GetFileById(recordId=1, fieldId=6990, fileId=274)

  print(f'Status Code: {response.statusCode}')
  print(f'Name: {response.data.file.name}')
  print(f'Content Type: {response.data.file.contentType}')
  print(f'Content Length: {response.data.file.contentLength}')

  filePath = f'C:\\Users\\sfree\\Documents\\Temp\\{response.data.file.name}'

  with open(filePath, "wb") as file:

      file.write(response.data.file.content)

  print(f'File Location: {filePath}')
  ```



  ```python
  from OnspringApiSdk.Models import SaveFileRequest
  import os
  import mimetypes

  filePath = 'C:\\Users\\sfree\\Documents\\Temp\\Test Attachment.txt'
  fileName = os.path.basename(filePath)
  contentType = mimetypes.guess_type(filePath)

  request = SaveFileRequest(
      recordId=60,
      fieldId=6989,
      fileName,
      filePath,
      contentType,
      notes='Initial revision',
      modifiedDate=datetime.now())

  response = client.SaveFile(request)

  print(f'Status Code: {response.statusCode}')
  print(f'File Id: {response.data.id}')
  ```



  ```python
  response = client.DeleteFileById(recordId=60, fieldId=6989, fileId=231)

  print(f'Status Code: {response.statusCode}')
  print(f'Message: {response.message}')
  ```





  To add a list value don't provide an id value.

  ```python
  from OnspringApiSdk.Models import ListItemRequest

  request = ListItemRequest(
          listId=906,
          name='Not Started',
          id='',
          numericValue=0,
          color='#ffffff')

  response = client.AddOrUpdateListItem(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Id: {response.data.id}')
  ```

  To update a list value provide an id value.

  ```python
  from OnspringApiSdk.Models import ListItemRequest

  request = ListItemRequest(
          listId=906,
          name='Pending',
          id='4118d53a-9121-4345-8682-07f23d606daa',
          numericValue=0,
          color='#ffffff')

  response = client.AddOrUpdateListItem(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Id: {response.data.id}')
  ```



  ```python
  response = client.DeleteListItem(listId=906, itemId='36f94d8c-2b9d-465e-9ad1-ede04109efc9')

  print(f'Status Code: {response.statusCode}')
  print(f'Message: {response.message}')
  ```





  Returns a paged colletion of records that can be paged through. By default the page size is 50 and page number is 1.

  ```python
  request = GetRecordsByAppRequest(appId=195)

  response = client.GetRecordsByAppId(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Page Size: {response.data.pageSize}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Total Pages: {response.data.totalPages}')
  print(f'Total Records: {response.data.totalRecords}')

  for record in response.data.records:
      print(f'AppId: {record.appId}')
      print(f'RecordId: {record.recordId}')

      for field in record.fields:
          print(f'Type: {field.type}')
          print(f'FieldId: {field.fieldId}')
          print(f'Value: {field.GetResultValueString()}')
  ```

  You can set your own page size and page number (max is 1,000) as well. In addition to specifying what field values to return and in what format (Raw vs. Formatted) to return them.

  ```python
  from OnspringApiSdk.Models import PagingRequest, GetRecordsByAppRequest
  from OnspringApiSdk.Enums import DataFormat

  pagingRequest = PagingRequest(1,10)

  request = GetRecordsByAppRequest(
      appId=195,
      fieldIds=[9686],
      dataFormat=DataFormat.Formatted.name,
      pagingRequest)

  response = client.GetRecordsByAppId(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Page Size: {response.data.pageSize}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Total Pages: {response.data.totalPages}')
  print(f'Total Records: {response.data.totalRecords}')

  for record in response.data.records:
      print(f'AppId: {record.appId}')
      print(f'RecordId: {record.recordId}')

      for field in record.fields:
          print(f'Type: {field.type}')
          print(f'FieldId: {field.fieldId}')
          print(f'Value: {field.GetResultValueString()}')
  ```



  Returns an onspring record based on the provided app and record ids.

  ```python
  from OnspringApiSdk.Models import GetRecordByIdRequest

  request = GetRecordByIdRequest(appId=195, recordId=60)

  response = client.GetRecordById(request)

  print(f'Status Code: {response.statusCode}')
  print(f'AppId: {response.data.appId}')
  print(f'RecordId: {response.data.recordId}')

  for field in response.data.fields:
      print(f'Type: {field.type}')
      print(f'FieldId: {field.fieldId}')
      print(f'Value: {field.GetResultValueString()}')
  ```

  You can also specify what field values to return and in what format (Raw vs. Formatted) to return them.

  ```python
  from OnspringApiSdk.Models import GetRecordByIdRequest
  from OnspringApiSdk.Enums import DataFormat

  request = GetRecordByIdRequest(
      appId=195,
      recordId=60,
      fieldIds=[9686],
      dataFormat=DataFormat.Formatted.name)

  response = client.GetRecordById(request)

  print(f'Status Code: {response.statusCode}')
  print(f'AppId: {response.data.appId}')
  print(f'RecordId: {response.data.recordId}')

  for field in response.data.fields:
      print(f'Type: {field.type}')
      print(f'FieldId: {field.fieldId}')
      print(f'Value: {field.GetResultValueString()}')
  ```



  ```python
  response = client.DeleteRecordById(appId=195, recordId=60)

  print(f'Status Code: {response.statusCode}')
  print(f'Message: {response.message}')
  ```



  Returns a collection of Onspring records based on the provided appId and recordIds.

  ```python
  from OnspringApiSdk.Models import GetBatchRecordsRequest

  request = GetBatchRecordsRequest(appId=195, recordIds=[1, 2, 3])

  response = client.GetRecordsByIds(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Count: {response.data.count}')

  for record in response.data.records:
      print(f'AppId: {record.appId}')
      print(f'RecordId: {record.recordId}')

      for field in record.fields:
          print(f'Type: {field.type}')
          print(f'FieldId: {field.fieldId}')
          print(f'Value: {field.GetResultValueString()}')
  ```

  You can also specify what field values to return and in what format (Raw vs. Formatted) to return them.

  ```python
  from OnspringApiSdk.Models import GetBatchRecordsRequest
  from OnspringApiSdk.Enums import DataFormat

  request = GetBatchRecordsRequest(
      appId=195,
      recordIds=[1, 2, 3],
      fieldIds=[9686],
      dataFormat=DataFormat.Formatted.name)

  response = client.GetRecordsByIds(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Count: {response.data.count}')

  for record in response.data.records:
      print(f'AppId: {record.appId}')
      print(f'RecordId: {record.recordId}')

      for field in record.fields:
          print(f'Type: {field.type}')
          print(f'FieldId: {field.fieldId}')
          print(f'Value: {field.GetResultValueString()}')
  ```



  Returns a paged colletion of records based on a criteria that can be paged through. By default the page size is 50 and page number is 1.

  ```python
  from OnspringApiSdk.Models import QueryRecordsRequest

  fieldId = 6983
  operator = 'eq'
  value = '\'Test Task 5\''

  request = QueryRecordsRequest(appId=195, filter=f'{fieldId} {operator} {value}')

  response = client.QueryRecords(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Page Size: {response.data.pageSize}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Total Pages: {response.data.totalPages}')
  print(f'Total Records: {response.data.totalRecords}')

  for record in response.data.records:
      print(f'AppId: {record.appId}')
      print(f'RecordId: {record.recordId}')

      for field in record.fields:
          print(f'Type: {field.type}')
          print(f'FieldId: {field.fieldId}')
          print(f'Value: {field.GetResultValueString()}')
  ```

  You can set your own page size and page number (max is 1,000) as well. In addition to specifying what field values to return and in what format (Raw vs. Formatted) to return them.

  ```python
  from OnspringApiSdk.Models import PagingRequest, QueryRecordsRequest
  from OnspringApiSdk.Enums import DataFormat

  pagingRequest = PagingRequest(1, 10)
  fieldId = 6983
  operator = 'eq'
  value = '\'Test Task 5\''

  request = QueryRecordsRequest(
      appId=195,
      filter=f'{fieldId} {operator} {value}',
      fieldIds=[9686],
      dataFormat=DataFormat.Formatted.name,
      pagingRequest)

  response = client.QueryRecords(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Page Size: {response.data.pageSize}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Total Pages: {response.data.totalPages}')
  print(f'Total Records: {response.data.totalRecords}')

  for record in response.data.records:
      print(f'AppId: {record.appId}')
      print(f'RecordId: {record.recordId}')

      for field in record.fields:
          print(f'Type: {field.type}')
          print(f'FieldId: {field.fieldId}')
          print(f'Value: {field.GetResultValueString()}')
  ```

  For further details on constructing the `filter` parameter please refer to the [documentation](https://software.onspring.com/hubfs/Training/Admin%20Guide%20-%20v2%20API.pdf) for v2 of the Onspring API.



  You can add a record by not providing a record id value. If successful will return the id of the added record.

  ```python
  from OnspringApiSdk.Models import StringFieldValue, GuidFieldValue, DateFieldValue, IntegerListValue, Record

  fields = []

  status = uuid.UUID('4118d53a-9121-4345-8682-07f23d606daa')
  dueDate = datetime.utcnow()

  fields.append(StringFieldValue(6983, 'Test Task via API'))
  fields.append(StringFieldValue(6984, 'This is a task.'))
  fields.append(GuidFieldValue(6986, status))
  fields.append(DateFieldValue(6985, dueDate))
  fields.append(IntegerListValue(6987, [4]))

  record = Record(
      appId=195,
      fields)

  response = client.AddOrUpdateRecord(record)

  print(f'Status Code: {response.statusCode}')
  print(f'Id: {response.data.id}')
  for warning in response.data.warnings:
      print(f'Warning: {warning}')
  ```

  You can update a record by providing its id. If successful will return the id of record updated.

  ```python
  from OnspringApiSdk.Models import StringFieldValue, GuidFieldValue, DateFieldValue, IntegerListValue, Record

  fields = []

  status = uuid.UUID('1c1c5f7e-cd03-4b70-9790-0f83b24b5863')
  dueDate = datetime.utcnow()

  fields.append(StringFieldValue(6983, 'Test Task via API'))
  fields.append(StringFieldValue(6984, 'This is a task.'))
  fields.append(GuidFieldValue(6986, status))
  fields.append(DateFieldValue(6985, dueDate))
  fields.append(IntegerListValue(6987, [4]))

  record = Record(
      appId=195,
      fields,
      recordId=103)

  response = client.AddOrUpdateRecord(record)

  print(f'Status Code: {response.statusCode}')
  print(f'Id: {response.data.id}')
  for warning in response.data.warnings:
      print(f'Warning: {warning}')
  ```



  ```python
  from OnspringApiSdk.Models import DeleteBatchRecordsRequest

  request = DeleteBatchRecordsRequest(appId=195, recordIds=[1, 2, 3])

  response = client.DeleteRecordsByIds(request)

  print(f'Status Code: {response.statusCode}')
  print(f'Message: {response.message}')
  ```





  Returns the report for the provided id.

  ```python
  from OnspringApiSdk.Models import GetReportByIdRequest

  request = GetReportByIdRequest(reportId=53)

  response = client.GetReportById(request)

  print(f'Status Code: {response.statusCode}')
  print('Columns:')
  print(f'{", ".join(response.data.columns)}')
  print('Rows:')
  for row in response.data.rows:
      print(f'Record Id {row.recordId}: {", ".join([str(cell) for cell in row.cells])}')
  ```

  You can also specify the format of the data in the report as well as whether you are requesting the report's data or its chart data.

  ```python
  from OnspringApiSdk.Models import GetReportByIdRequest
  from OnspringApiSdk.Enums import DataFormat, ReportDataType

  request = GetReportByIdRequest(
      reportId=53,
      apiDataFormat=DataFormat.Formatted.name,
      dataFormat=ReportDataType.ChartData.name)

  response = client.GetReportById(request)

  print(f'Status Code: {response.statusCode}')
  print('Columns:')
  print(f'{", ".join(response.data.columns)}')
  print('Rows:')
  for row in response.data.rows:
      print(f'Record Id {row.recordId}: {", ".join([str(cell) for cell in row.cells])}')
  ```



  Returns a paged collection of reports that can be paged through. By default the page size is 50 and page number is 1.

  ```python
  response = client.GetReportsByAppId(appId=195)

  print(f'Status Code: {response.statusCode}')
  print(f'App Id: {appId}')
  print('Reports:')

  for report in response.data.reports:
      print(f' Id: {report.id}')
      print(f' Name: {report.name}')
      print(f' Description: {report.description}')
  ```

  You can set your own page size and page number (max is 1,000) as well.

  ```python
  from OnspringApiSdk.Models import PagingRequest

  pagingRequest = PagingRequest(1,10)

  response = client.GetReportsByAppId(appId=195, pagingRequest)

  print(f'Status Code: {response.statusCode}')
  print(f'Page Number: {response.data.pageNumber}')
  print(f'Page Number: {response.data.pageSize}')
  print(f'Page Number: {response.data.totalPages}')
  print(f'Page Number: {response.data.totalRecords}')
  print(f'App Id: {appId}')
  print('Reports:')

  for report in response.data.reports:
      print(f' Id: {report.id}')
      print(f' Name: {report.name}')
      print(f' Description: {report.description}')
  ```


pkgId: 591d38ed17268f3e3406dd979277333cc2e69e552199bec3fb0528dbce761c8e
name: python-OntoAligner-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for OntoAligner
url: https://ontoaligner.readthedocs.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OntoAligner-1.2.2-1.src.rpm
location_href: Packages/python-OntoAligner-help-1.2.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="https://raw.githubusercontent.com/sciknoworg/OntoAligner/main/images/logo-with-background.png" alt="OntoAligner Logo"/>
  </div>

  <h3 align="center">OntoAligner: A Comprehensive Modular and Robust Python Toolkit for Ontology Alignment</h3>

  <div align="center">

  [![PyPI version](https://badge.fury.io/py/OntoAligner.svg)](https://badge.fury.io/py/OntoAligner)
  [![PyPI Downloads](https://static.pepy.tech/badge/ontoaligner)](https://pepy.tech/projects/ontoaligner)
  ![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![Documentation Status](https://readthedocs.org/projects/ontoaligner/badge/?version=main)](https://ontoaligner.readthedocs.io/)
  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/sciknoworg/OntoAligner/graphs/commit-activity)

  </div>

  **OntoAligner** is a Python library designed to simplify ontology alignment and matching for researchers, practitioners, and developers. With a modular architecture and robust features, OntoAligner provides powerful tools to bridge ontologies effectively.




  You can install **OntoAligner** from PyPI using `pip`:

  ```bash
  pip install ontoaligner
  ```

  Alternatively, to get the latest version directly from the source, use the following commands:

  ```bash
  git clone git@github.com:sciknoworg/OntoAligner.git
  pip install ./ontoaligner
  ```



  Comprehensive documentation for OntoAligner, including detailed guides and examples, is available at **[ontoaligner.readthedocs.io](https://ontoaligner.readthedocs.io/)**.

  **Tutorials**

  | Example                        | Tutorial                                                                                                        |                                            Script                                             |
  |:-------------------------------|:----------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------:|
  | Lightweight                    | [📚 Fuzzy Matching](https://ontoaligner.readthedocs.io/tutorials/lightweight.html)                              |   [📝 Code](https://github.com/sciknoworg/OntoAligner/blob/main/examples/fuzzy_matching.py)   |
  | Retrieval                      | [📚 Retrieval Aligner](https://ontoaligner.readthedocs.io/tutorials/retriever.html)                             | [📝 Code](https://github.com/sciknoworg/OntoAligner/blob/main/examples/retriever_matching.py) |
  | Large Language Models          | [📚 Large Language Models Aligner](https://ontoaligner.readthedocs.io/tutorials/llm.html)                       |    [📝 Code](https://github.com/sciknoworg/OntoAligner/blob/main/examples/llm_matching.py)    |
  | Retrieval Augmented Generation | [📚 Retrieval Augmented Generation](https://ontoaligner.readthedocs.io/tutorials/rag.html)                      |       [📝 Code](https://github.com/sciknoworg/OntoAligner/blob/main/examples/rag_matching.py)|
  | FewShot                        | [📚 FewShot RAG](https://ontoaligner.readthedocs.io/tutorials/rag.html#fewshot-rag)                             |       [📝 Code](https://github.com/sciknoworg/OntoAligner/blob/main/examples/rag_matching.py)
  | In-Context Vectors Learning    | [📚 In-Context Vectors RAG](https://ontoaligner.readthedocs.io/tutorials/rag.html#in-context-vectors-rag)                  |       [📝 Code](https://github.com/sciknoworg/OntoAligner/blob/main/examples/icv_rag_matching.py)



  Below is an example of using Retrieval-Augmented Generation (RAG) step-by-step approach for ontology matching:

  ```python
  from ontoaligner.ontology import MaterialInformationMatOntoOMDataset
  from ontoaligner.utils import metrics, xmlify
  from ontoaligner.ontology_matchers import MistralLLMBERTRetrieverRAG
  from ontoaligner.encoder import ConceptParentRAGEncoder
  from ontoaligner.postprocess import rag_hybrid_postprocessor


  task = MaterialInformationMatOntoOMDataset()
  print("Test Task:", task)


  dataset = task.collect(
      source_ontology_path="assets/MI-MatOnto/mi_ontology.xml",
      target_ontology_path="assets/MI-MatOnto/matonto_ontology.xml",
      reference_matching_path="assets/MI-MatOnto/matchings.xml"
  )


  encoder_model = ConceptParentRAGEncoder()
  encoded_ontology = encoder_model(source=dataset['source'], target=dataset['target'])


  retriever_config = {"device": 'cuda', "top_k": 5,}
  llm_config = {"device": "cuda", "max_length": 300, "max_new_tokens": 10, "batch_size": 15}


  model = MistralLLMBERTRetrieverRAG(retriever_config=retriever_config, llm_config=llm_config)
  predicts = model.generate(input_data=encoded_ontology)


  hybrid_matchings, hybrid_configs = rag_hybrid_postprocessor(predicts=predicts,
                                                              ir_score_threshold=0.1,
                                                              llm_confidence_th=0.8)

  evaluation = metrics.evaluation_report(predicts=hybrid_matchings, references=dataset['reference'])
  print("Hybrid Matching Evaluation Report:", evaluation)


  xml_str = xmlify.xml_alignment_generator(matchings=hybrid_matchings)
  open("matchings.xml", "w", encoding="utf-8").write(xml_str)
  ```

  Ontology alignment pipeline using RAG method:

  ```python
  import ontoaligner

  pipeline = ontoaligner.OntoAlignerPipeline(
      task_class=ontoaligner.ontology.MouseHumanOMDataset,
      source_ontology_path="assets/MI-MatOnto/mi_ontology.xml",
      target_ontology_path="assets/MI-MatOnto/matonto_ontology.xml",
      reference_matching_path="assets/MI-MatOnto/matchings.xml",
  )

  matchings, evaluation = pipeline(
      method="rag",
      encoder_model=ontoaligner.encoder.ConceptRAGEncoder(),
      model_class=ontoaligner.ontology_matchers.MistralLLMBERTRetrieverRAG,
      postprocessor=ontoaligner.postprocess.rag_hybrid_postprocessor,
      llm_path='mistralai/Mistral-7B-v0.3',
      retriever_path='all-MiniLM-L6-v2',
      llm_threshold=0.5,
      ir_threshold=0.7,
      top_k=5,
      max_length=512,
      max_new_tokens=10,
      device='cuda',
      batch_size=32,
      return_matching=True,
      evaluate=True
  )

  print("Matching Evaluation Report:", evaluation)
  ```


  We welcome contributions to enhance OntoAligner and make it even better! Please review our contribution guidelines in [CONTRIBUTING.md](CONTRIBUTING.md) before getting started. Your support is greatly appreciated.

  [//]: # (## 📧 Contact)

  If you encounter any issues or have questions, please submit them in the [GitHub issues tracker](https://github.com/sciknoworg/OntoAligner/issues).




  If you use OntoAligner in your work or research, please cite the following:

  ```bibtex
  @software{babaei_giglou_ontoaligner_2024,
    author       = {Hamed Babaei Giglou and Jennifer D'Souza and Oliver Karras and S{"o}ren Auer},
    title        = {OntoAligner: A Comprehensive Modular and Robust Python Toolkit for Ontology Alignment},
    version      = {1.0.0},
    year         = {2024},
    url          = {https://github.com/sciknoworg/OntoAligner},
  }
  ```

  <p>
    This software is licensed under the
    <a href="https://www.apache.org/licenses/LICENSE-2.0" target="_blank">Apache 2.0</a>.
  </p>
  <a href="https://www.apache.org/licenses/LICENSE-2.0" target="_blank">
    <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="Apache 2.0 License">
  </a>


pkgId: 3d481b0caaf7bcd22c2c39409611e378d5daa4b30a1ff30c0383f570b979f856
name: python-OpenDrive-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for OpenDrive
url: https://github.com/OpenDriveDevelopment/OpenDrive
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OpenDrive-1.0.0-1.src.rpm
location_href: Packages/python-OpenDrive-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  **OpenDrive Framework** is an open-source project designed to accelerate the development of autonomous driving systems.

  It provides a modular structure and the necessary tools to create a complete development environment for autonomous vehicles. OpenDrive Framework allows developers to work on detection, perception, and decision-making components, facilitating the creation of custom autonomous systems.



  The goal of **OpenDrive Framework** is to simplify the development of autonomous driving systems by providing well-defined, ready-to-use components while maintaining the flexibility to customize or replace modules as needed. This project is designed to be accessible to developers who wish to experiment and contribute new features, bug fixes, and improvements.



  The framework is divided into three main modules, each designed to fulfill specific functions within an autonomous system:

  - **Sensor Module**: Captures and processes real-time data from cameras and other sensors. Currently, it supports data acquisition through cameras.
  - **Perception Module**: Uses pre-trained AI models to analyze data captured by the sensors, performing tasks such as object detection, lane recognition, and traffic sign detection.
  - **Decision-Making Module**: Based on the results provided by the perception module, this module defines the actions or warnings that the vehicle should take.



  **OpenDrive Framework** is guided by the following principles, aimed at maintaining a modular, flexible, and developer-friendly system:

  - **Modularity**: Each module has well-defined functions and APIs, allowing them to work together seamlessly. Developers can contribute to or modify modules without affecting the rest of the system.
  - **Interchangeable Architecture**: Although OpenDrive Framework provides the necessary components to build a complete autonomous system, its modular architecture allows developers to replace components with their own implementations.
  - **Developer-focused**: The framework is designed to be functional and useful for building powerful tools. The documentation and user experience are aimed at developers, making integration and extension easier.



  OpenDrive Framework is an open project, welcoming contributions from the community. Whether you want to add new features, improve performance, or fix bugs, all contributions are welcome. To get started, check out the [Contribution Guide](CONTRIBUTING.md) and follow the established development standards.



  To install the framework, follow these steps:
  1. Clone the repository: `git clone https://github.com/your_username/opendrive-framework.git`
  2. Navigate to the project root
  3. Install the dependencies: `pip install -r requirements.txt`



  To install the framework via PyPI follow the next steps:
  1. Open a new terminal
  2. Type `pip install OpenDrive`
  3. Check more info here: https://pypi.org/project/OpenDrive/




  The usage guide for this framework is available at the following link:
  [OpenDrive Documentation](https://opendrivedevelopment.github.io/OpenDrive-Documentation/)


