# packages

pkgId: f74825eafb2a405e8b107bd3a1530ffffeca48e89a89c5f692fc5c34962bc4df
name: python-amplpy
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Python API for AMPL
url: http://ampl.com/
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amplpy-0.14.0-1.src.rpm
checksum_type: sha256
description:
  ```python

  $ python -m pip install amplpy --upgrade


  $ python -m amplpy.modules install highs cbc gurobi


  $ python -m amplpy.modules activate <license-uuid>


  $ python
  >>> from amplpy import AMPL
  >>> ampl = AMPL() # instantiate AMPL object
  ```

  ```python

  from amplpy import AMPL
  import pandas as pd
  ampl = AMPL()
  ampl.eval(r"""
      set A ordered;
      param S{A, A};
      param lb default 0;
      param ub default 1;
      var w{A} >= lb <= ub;
      minimize portfolio_variance:
          sum {i in A, j in A} w[i] * S[i, j] * w[j];
      s.t. portfolio_weights:
          sum {i in A} w[i] = 1;
  """)
  tickers, cov_matrix = # ... pre-process data in Python
  ampl.set["A"] = tickers
  ampl.param["S"] = pd.DataFrame(cov_matrix, index=tickers, columns=tickers)
  ampl.solve(solver="gurobi", gurobi_options="outlev=1")
  assert ampl.solve_result == "solved"
  sigma = ampl.get_value("sqrt(sum {i in A, j in A} w[i] * S[i, j] * w[j])")
  print(f"Volatility: {sigma*100:.1f}%")

  ```

  [[Documentation](https://amplpy.readthedocs.io/)] [[AMPL Modules for Python](https://dev.ampl.com/ampl/python/modules.html)] [[Available on Google Colab](https://colab.ampl.com/)] [[AMPL Community Edition](http://ampl.com/ce)]

  `amplpy` is an interface that allows developers to access the features of [AMPL](https://ampl.com) from within Python. For a quick introduction to AMPL see [Quick Introduction to AMPL](https://dev.ampl.com/ampl/introduction.html).

  In the same way that AMPL’s syntax matches naturally the mathematical description of the model, the input and output data matches naturally Python lists, sets, dictionaries, `pandas` and `numpy` objects.

  All model generation and solver interaction is handled directly by AMPL, which leads to great stability and speed; the library just acts as an intermediary, and the added overhead (in terms of memory and CPU usage) depends mostly on how much data is sent and read back from AMPL, the size of the expanded model as such is irrelevant.

  With `amplpy` you can model and solve large scale optimization problems in Python with the performance of heavily optimized C code without losing model readability. The same model can be deployed on applications built on different languages by just switching the API used.



  - http://amplpy.ampl.com



  * GitHub Repository: https://github.com/ampl/amplpy
  * PyPI Repository: https://pypi.python.org/pypi/amplpy


pkgId: 529a2141c19fcc9a3346586b2a9211d8b2ecf2d4529122b3f396f5e57df83ab4
name: python-ampltools
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: AMPL Python Tools
url: http://ampl.com/
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ampltools-0.7.5-1.src.rpm
checksum_type: sha256
description:
  This package includes tools to use with [AMPL](https://ampl.com) and [amplpy](https://amplpy.readthedocs.io).



  * GitHub Repository: https://github.com/ampl/amplpy/
  * PyPI Repository: https://pypi.python.org/pypi/ampltools


pkgId: 1464c4fe4a885504fa3aa9430b26da0989894d44c95dce4c9247ad03e8299e2c
name: python-amps-py
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Package for Interfacing with AMPS from Agile Data Inc.
url: https://mftlabs.github.io/amps-py
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amps-py-0.1.8-1.src.rpm
checksum_type: sha256
description:
  This package serves as an interface to the [Agile Message Processing System (AMPS)]() by providing Action, Endpoint, and Service classes that can be used in AMPS Actions, Gateways, and Custom Services, respectively.

  The package documentation is available [here](https://mft-labs.github.io/amps-py)


pkgId: bfd8d96b5b1496574601752701e833603ecf202c4c8034e8f3adc4a689a47f76
name: python-ampy
arch: src
version: 0.1.3.5
epoch: 0
release: 1
summary: Python-based Processing Tool for Active Matter Experiments
url: https://pypi.org/project/ampy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ampy-0.1.3.5-1.src.rpm
checksum_type: sha256
description:
  [pypi-version-image]: https://badge.fury.io/py/ampy.svg?=
  [pypi-version-url]: https://badge.fury.io/py/ampy

  [docs-image]: https://readthedocs.org/projects/ampy/badge/?version=latest
  [docs-url]: https://ampy.readthedocs.io/en/latest

  [linting-image]: https://github.com/swarmtronics/AMPy/actions/workflows/pylint.yml/badge.svg
  [linting-url]: https://github.com/swarmtronics/AMPy/actions/workflows/pylint.yml

  [coverage-image]: https://coveralls.io/repos/github/swarmtronics/AMPy/badge.svg?service=github&kill_cache=1
  [coverage-url]: https://coveralls.io/github/swarmtronics/AMPy

  [pypi-license-image]: https://img.shields.io/pypi/l/ampy

  ![Pipeline_image](materials/logo_header_bl_font.png#gh-light-mode-only)
  ![Pipeline_image](materials/logo_header_wh_font.png#gh-dark-mode-only)


  [![Python](https://img.shields.io/badge/python-3.8%20--%203.11-blue)](https://www.python.org)
  [![PyPI version][pypi-version-image]][pypi-version-url]
  [![Docs Status][docs-image]][docs-url]
  [![Coverage Status][coverage-image]][coverage-url]
  [![Linting Status][linting-image]][linting-url]
  ![PyPI - License][pypi-license-image]

  **[Website](https://swarmtronics.com)** | **[Documentation](https://ampy.readthedocs.io/en/latest/)** | **[Paper](https://arxiv.org/abs/2305.13510)** | **[Video Tutorial](https://www.youtube.com/watch?v=dQw4w9WgXcQ)** (TBD) | **[Colab Notebook](https://colab.research.google.com/drive/1hiCGXoDtOEO3LOm6RG12111Kiwofh069?usp=sharing)**

  **AMPy** is a *baseline* library built upon [OpenCV](https://opencv.org/) and [NumPy](https://numpy.org/) to easily process experimental video data for active matter and disordered systems. Our library turns the processing of experiment recordings into a cakewalk, considerably accelerating extraction of system dynamics.



  The library is comprised of 4 components: `processing.py`, `statistic2d.py`, `statistic3d.py`, `animation.py`, and `utils.py`.

  - `processing.py` handles the initial processing of experimental video recordings and tracks the ArUco markers placed on the robots' upper surfaces.

  - `statistics2d.py` extracts various two-dimensional statistical measures from obtained kinematics (such as Cartesian displacement or order parameters).

  - `statistics3d.py` evaluates position, orientation, and velocity correlation maps for the entire platform.

  - `animation.py` generates .gif/.mp4 with different visual augmentations of an input video.

  - `utils.py` provides methods for reading/saving video data.

  If you want a brief introduction into library capabilities, we prepared [a Colab tutorial](https://colab.research.google.com/drive/1hiCGXoDtOEO3LOm6RG12111Kiwofh069?usp=sharing) for that occasion.



  AMPy is available at [the Python Package Index](https://pypi.org/project/ampy/):

  ```
  $ pip install ampy
  ```



  For users' convenience, we provide [the .ipynb notebook](https://github.com/swarmtronics/AMPy/tree/master/marker_generator) allowing to generate ArUco- and AprilTag-based markers for tracking of their own robots.



  If you have some questions about the code, you are welcome to open an issue, we will respond to that as soon as possible. Contributions towards extension of AMPy functionality are more than welcome!



  Established code released as open-source software under the GPLv3 license.



  ```
  @misc{
        dmitriev2023swarmobot,
        title={Swarmodroid 1.0: A Modular Bristle-Bot Platform for Robotic Active Matter},
        author={Alexey A. Dmitriev and Alina D. Rozenblit and Vadim A. Porvatov and
                Mikhail K. Buzakov and Anastasia A. Molodtsova and Daria V. Sennikova and
                Vyacheslav A. Smirnov and Oleg I. Burmistrov and Ekaterina M. Puhtina and
                Nikita A. Olekhno},
        year={2023},
        eprint={2305.13510},
        archivePrefix={arXiv},
        primaryClass={cond-mat.soft}
  }
  ```


pkgId: fca9697ad1b3a784df193b6cae80bb54dacca0473cf9e23dfb80959416662257
name: python-ampycloud
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Determining the sky coverage fraction and base height of cloud layers usingceilometer data
url: https://meteoswiss.github.io/ampycloud
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ampycloud-2.1.1-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/435391098.svg)](https://zenodo.org/doi/10.5281/zenodo.8399683)
  [![github](https://img.shields.io/github/release/MeteoSwiss/ampycloud.svg)](https://github.com/MeteoSwiss/ampycloud/releases)
  [![last-commit](https://img.shields.io/github/last-commit/MeteoSwiss/ampycloud.svg?colorB=e6c000)](https://github.com/MeteoSwiss/ampycloud)
  [![issues](https://img.shields.io/github/issues/MeteoSwiss/ampycloud.svg?colorB=b4001e)](https://github.com/MeteoSwiss/ampycloud/issues)
  [![pypi](https://img.shields.io/pypi/v/ampycloud.svg?colorB=<brightgreen>)](https://pypi.python.org/pypi/ampycloud/)
  [![.github/workflows/CI_pytest_weekly.yml](https://github.com/MeteoSwiss/ampycloud/actions/workflows/CI_pytest_weekly.yml/badge.svg)](https://github.com/MeteoSwiss/ampycloud/actions/workflows/CI_pytest_weekly.yml)



  ampycloud refers to both this Python package and the algorithm at its core, designed to
  characterize cloud layers (i.e. height and sky coverage fraction) using ceilometer measurements
   (i.e. automatic cloud base *hits* measurements), and derive the corresponding METAR-like message.

  For the full documentation, installation instructions, etc ..., go to: https://meteoswiss.github.io/ampycloud



  ampycloud is released under the terms of **the 3-Clause BSD license**. The copyright (2021-2024) belongs to MeteoSwiss.



  Please see the [contributing guidelines](CONTRIBUTING.md) for details.


pkgId: 9445c8f6d4771fa2cdb5e8f5fca04b46839e0522c2d1a0f2fdf928e4a3fd97d6
name: python-amqencode
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Encoding utility for Anime Music Quiz
url: https://github.com/ayyu/amq-encoding
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amqencode-0.2.3-1.src.rpm
checksum_type: sha256
description:
  This Python 3 package simplifies 2-pass VP9/Opus encoding for AMQ using `ffmpeg`.
  It's basically a wrapper with presets for [ffmpeg-python](https://github.com/kkroening/ffmpeg-python),
  with some hacky stuff to get 2-pass encodes working.

  You can use it to encode every resolution of a video with a single command.

  You can override a lot of the presets.
  Passing `norm=True` automatically adjusts volume levels for you.

  I'll write up documentation later.



  First, install Python 3 if you haven't already. Then,

  ```bash
  pip install amqencode
  ```

  or maybe this on Windows

  ```cmd
  py -3 -m pip install amqencode
  ```

  Also make sure that `ffmpeg` is on your PATH.



  `import amqencode` in your python scripts.

  See `sample_encode.py` for an example of a script that encodes a video into
  mp3 and webms, then muxes those outputs with clean audio.



  If you just want to encode a file without writing a standalone script,
  you can call the package directly from a terminal.

  *nix

  ```bash
  python3 -m amqencode
  ```

  Windows

  ```cmd
  py -3 -m amqencode
  ```

  However, this is incapable of muxing clean audio into an encode.


pkgId: 86311c4289ee88687f34d033ec13d13a647c342566a038c781be481ad401a4bb
name: python-amqp-client-python
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Python AMQP Client Library
url: https://github.com/nutes-uepb/amqp-client-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amqp-client-python-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![License][license-image]][license-url]
  <a href="https://pypi.org/project/amqp-client-python" target="_blank">
      <img src="https://img.shields.io/pypi/v/amqp-client-python?color=%2334D058&label=pypi%20package" alt="Package version">
  </a><a href="https://pypi.org/project/amqp-client-python" target="_blank">
      <img src="https://img.shields.io/pypi/pyversions/amqp-client-python.svg?color=%2334D058" alt="Supported Python versions">
  </a>
  [![Downloads](https://static.pepy.tech/personalized-badge/amqp-client-python?period=month&units=international_system&left_color=black&right_color=orange&left_text=PyPI%20downloads%20per%20month)](https://pepy.tech/project/amqp-client-python)


pkgId: 15b9f23334519a6874598e2a268f00bf73e78481cf20bd5f9f025cef6bdacf96
name: python-amqpipe
arch: src
version: 1.2
epoch: 0
release: 1
summary: Twisted based pipeline framework for AMQP
url: https://github.com/Fatal1ty/amqpipe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amqpipe-1.2-1.src.rpm
checksum_type: sha256
description:
  Twisted based pipeline framework for AMQP. It allow you to create fast
  asynchronous services which follow ideology:
  -  get message from queue
  -  doing something with message
  -  publish some result


pkgId: 63df23526ef3d38112c73bd8c903069ad2e078820fde12ba64e18382b0860e3c
name: python-amqpstorm-flask
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: amqpstorm library for Flask
url: https://github.com/inuits/amqpstorm-flask
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amqpstorm-flask-0.4.7-1.src.rpm
checksum_type: sha256
description:
  - Connection validation and reconnection for AMQP.
  - Sending messages to a specified exchange with retries.
  - Consuming messages from a queue with retries.
  - Customizable parameters for exchanges and queues.
  - Message headers and properties support.
  - Multi-threading support for consumers.



  - Python 3.x
  - Flask
  - amqpstorm
  - retry



  To install the required dependencies, run:

  ```bash
  pip install amqpstorm-flask
  ```





  First, create a Flask app and initialize the `RabbitMQ`.

  ```python
  from flask import Flask
  app = Flask(__name__)
  app.config["MQ_URL"] = "<Your_MQ_URL>"
  app.config["MQ_EXCHANGE"] = "<Your_MQ_Exchange_Name>"

  amqp_service = RabbitMQ()
  amqp_service.init_app(app)
  ```



  To send a message to a specified exchange:

  ```python
  amqp_service.send(
      body={"key": "value"},
      routing_key="route.key",
      exchange_type="direct",
      retries=5,
  )
  ```



  To consume messages from a specified queue:

  ```python
  @amqp_service.queue(
      queue_name="test_queue",
      routing_key="route.key",
  )
  def process_message(message):
      print(message.body)
  ```

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 2, June 1991  Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it.  (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.)  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 this service 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 make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.  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.  We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.  Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software.  If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.  Finally, any free program is threatened constantly by software patents.  We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary.  To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.  The precise terms and conditions for copying, distribution and modification follow.  GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License.  The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  Each licensee is addressed as "you".  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.  1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.  b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.  c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.  (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.  In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:  a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  c) Accompany it with the information you received as to the offer to distribute corresponding source code.  (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)  The source code for a work means the preferred form of the work for making modifications to it.  For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable.  However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.  4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.  6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.  7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all.  For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  9. The Free Software Foundation may publish revised and/or new versions of the 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 a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.  10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE 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.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.  This program 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 General Public License for more details.  You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.  Also add information on how to contact you by electronic and paper mail.  If the program is interactive, make it output a short notice like this when it starts in an interactive mode:  Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.  <signature of Ty Coon>, 1 April 1989 Ty Coon, President of Vice  This General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.


pkgId: 59e01ff8f241552ef7c3f33dbe02b7ac37d05baa5756270c8a471aaa329ea0d7
name: python-amr-logic-converter
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: Convert Abstract Meaning Representation (AMR) into first-order logic
url: https://github.com/chanind/amr-logic-converter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amr-logic-converter-0.11.3-1.src.rpm
checksum_type: sha256
description:
  [![ci](https://img.shields.io/github/actions/workflow/status/chanind/amr-logic-converter/ci.yaml?branch=main)](https://github.com/chanind/amr-logic-converter)
  [![Codecov](https://img.shields.io/codecov/c/github/chanind/amr-logic-converter/main)](https://codecov.io/gh/chanind/amr-logic-converter)
  [![PyPI](https://img.shields.io/pypi/v/amr-logic-converter?color=blue)](https://pypi.org/project/amr-logic-converter/)

  Convert Abstract Meaning Representation (AMR) to first-order logic statements.

  This library is based on the ideas in the paper ["Expressive Power of Abstract Meaning Representations", J. Bos, Computational Linguistics 42(3), 2016](http://www.mitpressjournals.org/doi/pdf/10.1162/COLI_a_00257). Thank you to [@jobos](https://github.com/jobos) for the paper!



  ```
  pip install amr-logic-converter
  ```



  This library parses an AMR tree into first-order logic statements. An example of this is shown below:

  ```python
  from amr_logic_converter import AmrLogicConverter

  converter = AmrLogicConverter()

  AMR = """
  (x / boy
      :ARG0-of (e / giggle-01
          :polarity -))
  """

  logic = converter.convert(AMR)
  print(logic)

  ```



  The output from the `convert` method can be displayed as a string, but it can also be manipulated in Python. For instance, in the example above, we could also write:

  ```python
  converter = AmrLogicConverter()

  AMR = """
  (x / boy
      :ARG0-of (e / giggle-01
          :polarity -))
  """

  expr = converter.convert(AMR)
  type(expr) # <class 'amr_logic_converter.types.And'>
  expr.args[0] # Atom(predicate=Predicate(symbol='boy', alignment=None), terms=(Constant(value='x', type='instance', alignment=None),))
  ```



  This library will parse alignment markers from AMR using the [penman library](https://penman.readthedocs.io/en/latest/), and will include [Alignment](https://penman.readthedocs.io/en/latest/api/penman.surface.html#penman.surface.Alignment) objects from penman in `Predicate` and `Const` objects when available. For example, we can access alignment markers like below:

  ```python
  converter = AmrLogicConverter()

  AMR = """
  (x / boy~1
      :ARG0-of (e / giggle-01~3
          :polarity -))
  """

  expr = converter.convert(AMR)
  expr.args[0].alignment # Alignment((1,))
  expr.args[1].body.args[1].alignment # Alignment((3,))
  ```



  In ["Expressive Power of Abstract Meaning Representations"](http://www.mitpressjournals.org/doi/pdf/10.1162/COLI_a_00257), all instances are wrapped by an existence quantifier. By default `AmrLogicConverter` does not include these as it's likely not useful, but if you'd like to include them as in the paper you can pass the option `existentially_quantify_instances=True` when constructing the `AmrLogicConverter` as below:

  ```python
  converter = AmrLogicConverter(existentially_quantify_instances=True)

  AMR = """
  (x / boy
      :ARG0-of (e / giggle-01
          :polarity -))
  """

  logic = converter.convert(AMR)
  print(logic)

  ```



  When an instance is coreferenced in multiple places in the AMR, it's necessary to hoisting the existential quantification of that variable high enough that it can still wrap all instances of that variable. By default, the existential quantifier will be hoisted to the level of the lowest common ancestor of all nodes in the AMR tree where an instance is coreferenced. However, in ["Expressive Power of Abstract Meaning Representations"](http://www.mitpressjournals.org/doi/pdf/10.1162/COLI_a_00257), these coreferences are instead hoisted to the maximal possible scope, wrapping the entire formula. If you want this behavior, you can specify the option `maximally_hoist_coreferences=True` when creating the `AmrLogicConverter` instance. This is illustrated below:

  ```python
  AMR = """
  (b / bad-07
      :polarity -
      :ARG1 (e / dry-01
          :ARG0 (x / person
              :named "Mr Krupp")
          :ARG1 x))
  """


  converter = AmrLogicConverter(
      existentially_quantify_instances=True,
  )
  logic = converter.convert(AMR)
  print(logic)



  converter = AmrLogicConverter(
      existentially_quantify_instances=True,
      maximally_hoist_coreferences=True,
  )
  logic = converter.convert(AMR)
  print(logic)

  ```



  If you want to use variables for each AMR instance instead of constants, you can pass the option `use_variables_for_instances=True` when creating the AmrLogicConverter instance. When `existentially_quantify_instances` is set, variable will always be used for instances regardless of this setting.



  - By default variables names are capitalized, but you can change this by setting `capitalize_variables=False`.
  - By default, relations like `:ARG0-of(X, Y)` have their arguments flipped in logic and turned into `:ARG0(Y, X)`. If you don't want this normalization to occur, you can disable this by setting `invert_relations=False`.



  Contributions are welcome! Please leave an issue in the Github repo if you find any bugs, and open a pull request with and fixes or improvements that you'd like to contribute. Ideally please include new test cases to verify any changes or bugfixes if appropriate.

  This project uses [poetry](https://python-poetry.org/) for dependency management and packaging, [black](https://black.readthedocs.io/en/stable/) for code formatting, [flake8](https://flake8.pycqa.org/en/latest/) for linting, and [mypy](https://mypy.readthedocs.io/en/stable/) for type checking.



  This project is licenced under a MIT license.


  If you use this software in your work, please cite the following:

  ```bibtex
  @article{chanin2023neuro,
    title={Neuro-symbolic Commonsense Social Reasoning},
    author={Chanin, David and Hunter, Anthony},
    journal={arXiv preprint arXiv:2303.08264},
    year={2023}
  }
  ```


pkgId: ec9642652e9e56622d8bff6eccfc6eba97fabca09ce051fcd7f96ad2874d8337
name: python-amshan
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Decode P1 and MBUS (Meter Bus) DLMS data. Special support for norwegian and swedish meters.
url: https://github.com/toreamun/amshan
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amshan-2.1.1-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release](https://img.shields.io/github/release/toreamun/amshan?style=for-the-badge)](https://github.com/toreamun/amshan/releases)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/toreamun/amshan.svg?logo=lgtm&logoWidth=18&style=for-the-badge)](https://lgtm.com/projects/g/toreamun/amshan/context:python)
  [![License](https://img.shields.io/github/license/toreamun/amshan?style=for-the-badge)](LICENSE)

  ![Project Maintenance](https://img.shields.io/badge/maintainer-Tore%20Amundsen%20%40toreamun-blue.svg?style=for-the-badge)
  [![buy me a coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20me%20a%20coffee-orange.svg?style=for-the-badge)](https://www.buymeacoffee.com/toreamun)



  Package to help decode smart power meter data stream of IEC 62056-21 Mode D P1 or DLMS/Cosem HDLC frames used by MBUS (Meter Bus). The package can both help reading frames of meter data and/or decoding them.

  The package has special support for DLMS formats used by Aidon, Kaifa and Kamstrup smart meteres (HAN) in Norway (See https://www.nek.no/info-ams-han-utviklere/) and Sweden. The Swedish P1 format format is also supported.



  SmartMeterMessagePayloadProtocol can be used to read smart meter P1 date readout (ascii) or MBUS HDLC (binary) frames asynchronous. The content of each mdssage (no headers and control characters) is passed as bytes to a Queue. Headers are checked and checksum validated, and only content from non empty frames with expected length (only DLMS) and checksum is passed to the queue.

  SmartMeterMessageProtocol can be used to read smart meter P1 data readout (ascii) or MBUS HDLC frames asynchronous. The complete message is sent to a Queue as an instance of as subclass of MeterReaderBase. Frames are not validated. This class is a more low level alternative to SmartMeterMessagePayloadProtocol. This type has to be used to get the meter type from P1 readouts as this is part of the message "header".

  Both SmartMeterMessagePayloadProtocol and SmartMeterMessageProtocol is a [Python asyncio protocol](https://docs.python.org/3/library/asyncio-protocol.html#protocols). Protocols support different types of transports like network and serial.

  It is recommended to use provided ConnectionManager and connection factories to read the data stream.



  Pass a factory for the selected protocol (SmartMeterMessagePayloadProtocol or SmartMeterMessageProtocol) to a utility function of your selected transport (e.g., EventLoop.create_connection() for TCP/IP or serial_asyncio.create_serial_connection() for serial).

  Serial example:

  ```python
  transport, protocol = await serial_asyncio.create_serial_connection(loop, lambda: SmartMeterMessagePayloadProtocol(queue, [ModeDReader]), url = "/dev/tty01")
  ```

  Serial example:

  ```python
  transport, protocol = await serial_asyncio.create_serial_connection(loop, lambda: SmartMeterMessagePayloadProtocol(queue, [ModeDReader]), url = "/dev/tty01")
  ```



  Multiple factories are provided to create a protocol as an alternative to using selected transports create function as above. Use [serial_connection_factory](serial_connection_factory.py) for serial and [tcp_connection_factory](tcp_connection_factory) for TCP/IP.

  | Factory module            | SmartMeterMessageProtocol                  | SmartMeterMessagePayloadProtocol        |
  | ------------------------- | ------------------------------------------ | --------------------------------------- |
  | serial_connection_factory | create_serial_message_payload_connection() | create_serial_message_connection()      |
  | tcp_connection_factory    | create_tcp_message_connection()            | create_tcp_message_payload_connection() |

  Example of creating a SmartMeterMessagePayloadProtocol serial connection on device /dev/ttyUSB0:

  ```python
  queue = Queue()
  loop = asyncio.get_event_loop()
  transport, protocol = await create_serial_frame_content_connection(queue, loop, None, url="/dev/ttyUSB0", baudrate=2400, parity=N)
  ```

  Example of creating a SmartMeterMessageProtocol protocol TCP/IP connection to host 192.168.1.1 on port 1234:

  ```python
  queue = Queue()
  loop = asyncio.get_event_loop()
  transport, protocol = await create_tcp_frame_connection(queue, loop, None, "192.168.1.1", 1234)
  ```

  See [reader_async.py](reader_async.py) for a complete example.



  ConnectionManager maintain connection and reconnect if connection is lost. A back-off retry strategy is used when reconnecting, and a simple circuit breaker is used for lost connection.

  ```python
  queue = Queue()
  loop = asyncio.get_event_loop()
  connection_manager = ConnectionManager(lambda: create_serial_message_connection(queue, loop, None, url="/dev/ttyUSB0", baudrate=2400, parity=N))
  await connection_manager.connect_loop()
  ```

  See [reader_async.py](amshan/reader_async.py) for a complete example.



  dlde.ModeDReader can be used to read readout by readout from bytes. Call read() to read readouts as more bytes become available. The function takes bytes as an argument and returns a list of DataReadout (the list can be empty). The function can receive incomplete readout in the buffer input and add incomplete data to an internal buffer. The buffer is schrinked when complete readout are found and returned. You should check if returned readouts are valid with readout.is_valid before using them.



  hdlc.HdlcFrameReader can be used to read frame by frame from bytes. Call read() to read frames as more bytes become available. The function takes bytes as an argument and returns a list of HdlcFrame (the list can be empty). The function can receive incomplete frames in the buffer input and add incomplete data to an internal buffer. The buffer is schrinked when complete frames are found and returned. You should check if returned frames are valid with frame.is_valid before using them.



  P1 readout and MBUS frames using the norwegian or swedish DMLS AMS format can be parsed into meter specific objects or decoded into a common dictionary. Modules exists for P1 (generic format), Aidon, Kaifa and Kamstrup meters, but the easiest is to use [autodecoder.AutoDecode](han/autodecode.py) to automatically detect meter type and decode the frame into a dictionary. The dictionay content is as far as possible common between meters. Possible dictionary keys kan be found as constants in [obis_map.py](han/obis_map.py).

  Example:

  ```python
  decoder = AutoDecoder()
  frame = bytes.fromhex("e6e700" "0f" "40000000" "00" "0101" "020309060100010700ff060000011802020f00161b")
  decoded = decoder.decode_frame_content(frame)
  ```


pkgId: ed36da922a4635aee5d3c5148552add0a22271606a4de91ac9be031d09cf3f8e
name: python-amsterdam-schema-tools
arch: src
version: 6.1.1
epoch: 0
release: 1
summary: Tools to work with Amsterdam Schema.
url: https://github.com/amsterdam/schema-tools
rpm_license: Mozilla Public 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amsterdam-schema-tools-6.1.1-1.src.rpm
checksum_type: sha256
description:
  Set of libraries and tools to work with Amsterdam schema.

  Install the package with: `pip install amsterdam-schema-tools`. This installs
  the library and a command-line tool called `schema`, with various subcommands.
  A listing can be obtained from `schema --help`.

  Subcommands that talk to a PostgreSQL database expect either a `DATABASE_URL`
  environment variable or a command line option `--db-url` with a DSN.

  Many subcommands want to know where to find schema files. Most will look in a
  directory of schemas denoted by the `SCHEMA_URL` environment variable or the
  `--schema-url` command line option. E.g.,

      schema create tables --schema-url=myschemas mydataset

  will try to load the schema for `mydataset` from
  `myschemas/mydataset/dataset.json`.




  The --prefix argument controls whether table prefixes are removed in the
  schema, because that is required for Django models.

  As example we can generate a BAG schema. Point `DATABASE_URL` to `bag_v11` database and then run :

      schema show tablenames | sort | awk '/^bag_/{print}' | xargs schema introspect db bag --prefix bag_ | jq

  The **jq** formats it nicely and it can be redirected to the correct directory
  in the schemas repository directly.



  Amsterdam schema is expressed as jsonschema. However, to make it easier for people with a
  more relational mind- or toolset it is possible to express amsterdam schema as a set of
  relational tables. These tables are *meta_dataset*, *meta_table* and *meta_field*.

  It is possible to convert a jsonschema into the relational table structure and vice-versa.

  This command converts a dataset from an existing dataset in jsonschema format:

      schema import schema <id of dataset>

  To convert from relational tables back to jsonschema:

      schema show schema <id of dataset>




  The following command can be used to inspect and import the GeoJSON files:

      schema introspect geojson <dataset-id> *.geojson > schema.json
      edit schema.json  # fine-tune the table names
      schema import geojson schema.json <table1> file1.geojson
      schema import geojson schema.json <table2> file2.geojson



  The schematools library has a module that reads GOB events into database tables that are
  defines by an Amsterdam schema. This module can be used to read GOB events from a Kafka stream.
  It is also possible to read GOB events from a batch file with line-separeted events using:

      schema import events <path-to-dataset> <path-to-file-with-events>




  Datasets can be exported to different file formats. Currently supported are geopackage,
  csv and jsonlines. The command for exporting the dataset tables is:

      schema export [geopackage|csv|jsonlines] <id of dataset>

  The command has several command-line options that can be used. Documentations about these
  flags can be shown using the `--help` options.




  Included in the project is a `pre-commit` hook
  that can validate schema files
  in a project such as [amsterdam-schema](https://github.com/Amsterdam/amsterdam-schema)

  To configure it
  extend the `.pre-commit-config.yaml`
  in the project with the schema file defintions as follows:

  ```yaml
    - repo: https://github.com/Amsterdam/schema-tools
      rev: v3.5.0
      hooks:
        - id: validate-schema
          args: ['https://schemas.data.amsterdam.nl/schema@v1.2.0#']
          exclude: |
              (?x)^(
                  schema.+|             # exclude meta schemas
                  datasets/index.json
              )$
  ```

  `args` is a one element list
  containing the URL to the Amsterdam Meta Schema.

  `validate-schema` will only process `json` files.
  However not all `json` files are Amsterdam schema files.
  To exclude files or directories use `exclude` with pattern.

  `pre-commit` depends on properly tagged revisions of its hooks.
  Hence, we should not only bump version numbers on updates to this package,
  but also commit a tag with the version number; see below.



  (This is for schema-tools developers.)

  We use GitHub pull requests. If your PR should produce a new release of
  schema-tools, make sure one of the commit increments the version number in
  ``setup.cfg`` appropriately. Then,

  * merge the commit in GitHub, after review;
  * pull the code from GitHub and merge it into the master branch,
    ``git checkout master && git fetch origin && git merge --ff-only origin/master``;
  * tag the release X.Y.Z with ``git tag -a vX.Y.Z -m "Bump to vX.Y.Z"``;
  * push the tag to GitHub with ``git push origin --tags``;
  * release to PyPI: ``make upload`` (requires the PyPI secret).




  The schematools library contains two Django management commands to generate
  mock data. The first one is `create_mock_data` which generates mock data for all
  the datasets that are found at the configured schema location `SCHEMA_URL`
  (where `SCHEMA_URL` can be configure to point to a path at the local filesystem).

  The `create_mock_data` command processes all datasets. However, it is possible
  to limit this by adding positional arguments. These positional arguments can be
  dataset ids or paths to the location of the `dataset.json` on the local filesystem.

  Furthermore, the command has some options, e.g. to change
  the default number of generated records (`--size`) or to reverse meaning of the positional
  arguments using `--exclude`.

  To avoid duplicate primary keys on subsequent runs the `--start-at` options can be used
  to start autonumbering of primary keys at an offset.

  E.g. to generate 5 records for the `bag` and `gebieden` datasets, starting the
  autonumbering of primary keys at 50.

  ```
      django create_mock_data bag gebieden --size 5 --start-at 50
  ```

  To generate records for all datasets, except for the `fietspaaltjes` dataset:

  ```
      django create_mock_data fietspaaltjes --exclude  # or -x
  ```

  To generate records for the `bbga` dataset, by loading the schema from the local filesystem:

  ```
      django create_mock_data <path-to-bbga-schema>/datasets.json
  ```

  During record generation in `create_mock_data`, the relations are not added,
  so foreign key fields will be filled with NULL values.

  There is a second management command `relate_mock_data` that can be used to
  add the relations. This command support positional arguments for datasets
  in the same way as `create_mock_data`.
  Furthermore, the command also has the `--exclude` option to reverse the meaning
  of the positional dataset arguments.

  E.g. to add relations to all datasets:

  ```
      django relate_mock_data
  ```

  To add relations for `bag` and `gebieden` only:

  ```
      django relate_mock_data bag gebieden
  ```

  To add relations for all datasets except `meetbouten`:

  ```
      django relate_mock_data meetbouten --exclude  # or -x
  ```

  NB. When only a subset of the datasets is being mocked, the command can fail when datasets that
  are involved in a relation are missing, so make sure to include all relevant
  datasets.

  For convenience an additional management command `truncate_tables` has been added,
  to truncate all tables.


pkgId: b9f1cb26969e957003c5b70ef5113415c69923390f506f5d9c7c38d556e82e5a
name: python-amulet-compiler-target
arch: src
version: 1.0
epoch: 0
release: 1
summary: A token library to pin compile-time requirements.
url: https://pypi.org/project/amulet-compiler-target/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amulet-compiler-target-1.0-1.src.rpm
checksum_type: sha256
description:
  This library exists to ensure that all of our libraries are compiled using the same settings
  because PyPi and Pip lack tooling to ensure that the Application Binary Interface (ABI)
  of multiple separately compiled libraries remain compatible.

  The requirements for each version are defined in the versionX.md files.

  Each of our libraries must include this as a pinned runtime dependency to ensure that only
  libraries compatible with these settings can be installed.



  Our libraries use semantic versioning in the format MAJOR.MINOR.PATCH.SUB however this is for API not ABI.

  A MAJOR change breaks API and ABI compatibility.

  A MINOR change is a backwards compatible API change but should be considered a breaking ABI change.

  A PATCH change must not change the API or ABI.

  A SUB change can be used if the code has not changed but we want to update the compiler target version.

  The source distribution requirements must be in the form `library ~= 1.1`

  Compiled distribution requirements must be in the form `library ~= 1.1.0`


pkgId: 21fbed4e14a687a1f3f0e485259fe73829f41369634697485f2378fa1e37b31e
name: python-amuletml
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://pypi.org/project/amuletml/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amuletml-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  Amulet is a Python machine learning (ML) package to evaluate the susceptibility of different risks to security, privacy, and fairness.

description:
  Amulet is a Python machine learning (ML) package to evaluate the susceptibility of different risks to security, privacy, and fairness. Amulet is applicable to evaluate how algorithms designed to reduce one risk may impact another unrelated risk and compare different attacks/defenses for a given risk.

  Amulet builds upon prior work titled [“SoK: Unintended Interactions among Machine Learning Defenses and Risks”](https://arxiv.org/abs/2312.04542) which appears in IEEE Symposium on Security and Privacy 2024. The SoK covers only two interactions and identifies the design of a software library to evaluate unintended interactions as future work. Amulet addresses this gap by including eight different risks each covering their own attacks, defenses and metrics.

  Amulet is:
  - Comprehensive: Covers the most representative attacks/defenses/metrics for different risks.
  - Extensible: Easy to include additional risks, attacks, defenses, or metrics.
  - Consistent: Allows using different attacks/defenses/metrics with a consistent, easy-to-use API.
  - Applicable: Allows evaluating unintended interactions among defenses and attacks.


  Built to work with PyTorch, you can incorporate Amulet into your current ML pipeline to test how your model interacts with these state-of-the-art defenses and risks. Alternatively, you can use the example pipelines to bootstrap your pipeline.



  **Note:** The package requires the CUDA version to be 11.8 or above for PyTorch 2.2

  The easiest way to start is via `pip`:

  `pip install amuletml`



  To test your installation, please run [amulet/examples/get_started.py](https://github.com/ssg-research/amulet/blob/main/examples/get_started.py). This script also serves as a starting point to learn how to use the library.



  For more information on the basics about the library, please see the [Getting Started guide](https://github.com/ssg-research/amulet/blob/main/docs/GETTING_STARTED.md).

  To see the attacks, defenses, and risks (modules) that Amulet implements, please refer to the **Module Heirarchy** (link TBD) in the Tutorial (link TBD).

  For each module, please see [amulet/examples](https://github.com/ssg-research/amulet/tree/main/examples) for implementations of pipelines that include recommendations on how to run each module.



  See [CONTRIBUTING](https://github.com/ssg-research/amulet/blob/main/docs/CONTRIBUTING.md) for guidance.


pkgId: a30c895df5f8f8066daeb984ab4654e8a4f53f2f905d12eac301869401117354
name: python-amulog
arch: src
version: 0.3.10
epoch: 0
release: 1
summary: A system log management tool with automatically generated log templates.
url: https://github.com/cpflat/amulog/
rpm_license: The 3-Clause BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amulog-0.3.10-1.src.rpm
checksum_type: sha256
description:
  - Support multiple databases: sqlite and mysql
  - Smart log segmentation with `log2seq <https://github.com/amulog/log2seq>`_
  - Multiple template generation algorithms such as: Drain, SHISO, LenMa, FT-tree, Dlog, etc.
  - Support Online (incremental) and Offline (hindsight) use
  - Suspend and resume the template generation process
  - Import and Export log templates if you need
  - Edit log templates manually if you need
  - Search API with datetime, hostname and log template IDs


pkgId: e58116a3ef30d8b371bef8bad5b0d64cfada9f75d5ea3c1f9726e94bb5354fe7
name: python-amundsen-common
arch: src
version: 0.32.0
epoch: 0
release: 1
summary: Common code library for Amundsen
url: https://github.com/amundsen-io/amundsen/tree/main/common
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-amundsen-common-0.32.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/amundsen-common.svg)](https://badge.fury.io/py/amundsen-common)
  [![License](http://img.shields.io/:license-Apache%202-blue.svg)](LICENSE)
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)
  [![Slack Status](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://amundsenworkspace.slack.com/join/shared_invite/enQtNTk2ODQ1NDU1NDI0LTc3MzQyZmM0ZGFjNzg5MzY1MzJlZTg4YjQ4YTU0ZmMxYWU2MmVlMzhhY2MzMTc1MDg0MzRjNTA4MzRkMGE0Nzk)

  Amundsen Common library holds common codes among micro services in Amundsen.
  For information about Amundsen and our other services, visit the [main repository](https://github.com/amundsen-io/amundsen). Please also see our instructions for a [quick start](https://github.com/amundsen-io/amundsen/blob/master/docs/installation.md#bootstrap-a-default-version-of-amundsen-using-docker) setup  of Amundsen with dummy data, and an [overview of the architecture](https://github.com/amundsen-io/amundsen/blob/master/docs/architecture.md#architecture).


  - Python >= 3.8


  - https://www.amundsen.io/amundsen/


pkgId: f8461ef557c4748a233da7e6e0f6c5df5191893952ba80e3bb1a8b316d85ee85
name: python-anabook
arch: src
version: 1.31
epoch: 0
release: 1
url: https://github.com/FreddyAlvarado/anabook
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anabook-1.31-1.src.rpm
checksum_type: sha256
summary:
  Funciones para analisis descriptivo y utilitarios usados en el desarrollo de modelos de Aprendizaje Automatico


pkgId: 9c894982ce7dae84f388ecc85fe9088e854872c67a75387e2e16a55b56afa447
name: python-anaconda
arch: src
version: 0.0.1.1
epoch: 0
release: 1
summary: Please use the Anaconda installer.
url: https://pypi.org/project/anaconda/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaconda-0.0.1.1-1.src.rpm
checksum_type: sha256
description:
  Anaconda Python cannot be installed via pip or other PyPI-based installers.
  Please use the Anaconda Installer to bootstrap Anaconda Python onto your system.


pkgId: 2ad5351f177512cc3f3637f71fa430d2c34e26e27adbfdfde947c42c4f0be45f
name: python-anaconda-cli-base
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A base CLI entrypoint supporting Anaconda CLI plugins
url: https://pypi.org/project/anaconda-cli-base/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaconda-cli-base-0.4.1-1.src.rpm
checksum_type: sha256
description:
  A base CLI entrypoint supporting Anaconda CLI plugins using [Typer](https://github.com/fastapi/typer).



  To develop a subcommand in a third-party package, first create a `typer.Typer()` app with one or more commands.
  See [this example](https://typer.tiangolo.com/#example-upgrade). The commands defined in your package will be prefixed
  with the *subcommand* you define when you register the plugin.

  In your `pyproject.toml` subcommands can be registered as follows:

  ```toml


  [project.entry-points."anaconda_cli.subcommand"]
  auth = "anaconda_cloud_auth.cli:app"
  ```

  In the example above:

  * `"anaconda_cloud_cli.subcommand"` is the required string to use for registration. The quotes are important.
  * `auth` is the name of the new subcommand, i.e. `anaconda auth`
    * All `typer.Typer` commands you define in your package are accessible the registered subcommand
    * i.e. `anaconda auth <command>`.
  * `anaconda_cloud_auth.cli:app` signifies the object named `app` in the `anaconda_cloud_auth.cli` module is the entry point for the subcommand.



  By default any exception raised during CLI execution in your registered plugin will be caught and only a minimal
  message will be displayed to the user.

  You can define a custom callback for individual exceptions that may be thrown from your subcommand. You can
  register handlers for standard library exceptions or custom defined exceptions. It may be best to use custom
  exceptions to avoid unintended consequences for other plugins.

  To register the callback decorate a function that takes an exception as input, and return an integer error code.
  The error code will be sent back through the CLI and your subcommand will exit with that error code.

  ```python
  from typing import Type
  from anaconda_cli_base.exceptions import register_error_handler

  @register_error_handler(MyCustomException)
  def better_exception_handling(e: Type[Exception]) -> int:
      
      return 1

  @register_error_handler(AnotherException)
  def just_ignore_it(e: Type[Exception])
      
      return 0


  @register_error_handler(YetAnotherException)
  def fix_the_error_and_try_again(e: Type[Exception]) -> int:
      
      return -1
  ```

  In the second example the handler returns `-1`. This means that the handler has attempted to correct the error
  and the CLI subcommand should be re-tried. The handler could call another interactive command, like a login action,
  before attempting the CLI subcommand again.

  See the [anaconda-cloud-auth](https://github.com/anaconda/anaconda-cloud-tools/blob/main/libs/anaconda-cloud-auth/src/anaconda_cloud_auth/cli.py) plugin for an example custom handler.



  If your plugin wants to utilize the Anaconda config file, default location `~/.anaconda/config.toml`, to read configuration
  parameters you can derive from `anaconda_cli_base.config.AnacondaBaseSettings` to add a section in the config file for
  your plugin.
   Each subclass of `AnacondaBaseSettings`
  defines the section header. The base class is configured so that parameters defined in subclasses can be read in the
  following priority from lowest to highest.

  1. default value in the subclass of `AnacondaBaseSettings`
  1. Global config file at ~/.anaconda/config.toml
  1. `ANACONDA_<PLUGIN-NAME>_<FIELD>` variables defined in the .env file in your working directory
  1. `ANACONDA_<PLUGIN-NAME>_<FIELD>` env variables set in your shell or on command invocation
  1. value passed as kwarg when using the config subclass directly

  Notes:

  * `AnacondaBaseSettings` is a subclass of `BaseSettings` from [pydantic-settings](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#usage).
  * Nested pydantic models are also supported.

  Here's an example subclass

  ```python
  from anaconda_cli_base.config import AnacondaBaseSettings

  class MyPluginConfig(AnacondaBaseSettings, plugin_name="my_plugin"):
      foo: str = "bar"
  ```

  To read the config value in your plugin according to the above
  priority:

  ```python
  config = MyPluginConfig()
  assert config.foo == "bar"
  ```

  Since there is no value of `foo` in the config file it assumes the default value from the subclass definition.

  The value of `foo` can now be written to the config file under the section `my_plugin`

  ```toml

  [plugin.my_plugin]
  foo = "baz"
  ```

  Now that the config file has been written, the value of `foo` is read from the
  config.toml file:

  ```python
  config = MyPluginConfig()
  assert config.foo == "baz"
  ```

  See the [tests](https://github.com/anaconda/anaconda-cloud-tools/blob/feat/cli-base-config-file/libs/anaconda-cli-base/tests/test_config.py) for more examples.



  Ensure you have `conda` installed.
  Then run:

  ```shell
  make setup
  ```



  ```shell
  make test
  ```


  ```shell
  make tox
  ```


pkgId: a2bde36a690c5b4a6de1719d08f7ddd6126b7ed25b0a53f68b914c77956bbbf9
name: python-anaconda-cloud-auth
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: A client auth library for Anaconda.cloud APIs
url: https://pypi.org/project/anaconda-cloud-auth/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaconda-cloud-auth-0.7.2-1.src.rpm
checksum_type: sha256
description:
  A client library for Anaconda.cloud APIs to authenticate and securely store API keys.
  This library is used by other Anaconda.cloud client packages to provide a centralized auth
  capability for the ecosystem. You will need to use this package to login to Anaconda.cloud
  before utilizing many of the other client packages.

  This package provides a [requests](https://requests.readthedocs.io/en/latest/)
  client class that handles loading the API key for requests made to Anaconda Cloud services.

  This package provides a [Panel OAuth plugin](https://panel.holoviz.org/how_to/authentication/configuration.html)
  called `anaconda_cloud`.



  ```text
  conda install anaconda-cloud-auth
  ```



  The primary usage of this package is to provide CLI actions for login, logout, user information, and api-keys
  to Anaconda Cloud API Services.

  ```text
  ❯ anaconda cloud

   Usage: anaconda cloud [OPTIONS] COMMAND [ARGS]...

   Anaconda.cloud auth commands

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────╮
  │ --version  -V                                                                              │
  │ --help               Show this message and exit.                                           │
  ╰────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ Commands ─────────────────────────────────────────────────────────────────────────────────╮
  │ api-key   Display API Key for signed-in user                                               │
  │ login     Login                                                                            │
  │ logout    Logout                                                                           │
  │ whoami    Display information about the currently signed-in user                           │
  ╰────────────────────────────────────────────────────────────────────────────────────────────╯
  ```



  You can configure `anaconda-cloud-auth` by either

  1. Setting parameters in the `plugin.cloud` section of the `~/.anaconda/config.toml` file
  1. Setting one or more `ANACONDA_CLOUD_` environment variables or use a `.env` file in your working directory

  `ANACONDA_CLOUD_` env vars or `.env` file take precedence over the `~/.anaconda/config.toml` file.



  The following parameters in the `plugin.cloud` section control the login actions and API requests to Anaconda Cloud Services.

  | Parameter | Env variable | Description | Default value |
  |-|-|-|-|
  | `domain` | `ANACONDA_CLOUD_DOMAIN` | Authentication and API request domain | `"anaconda.cloud"` |
  | `ssl_verify` | `ANACONDA_CLOUD_SSL_VERIFY` | SSL verification for all requests | `True` |
  | `preferred_token_storage` | `ANACONDA_CLOUD_PREFERRED_TOKEN_STORAGE` | Where to store the login token, can be `"anaconda-keyring"` or `"system"` | `"anaconda-keyring"` |
  | `api_key` | `ANACONDA_CLOUD_API_KEY` | API key, if `None` defaults to keyring storage | `None` |
  | `extra_headers` | `ANACONDA_CLOUD_EXTRA_HEADERS` | Extra request headers in JSON format | `None` |



  Here's an example `~/.anaconda/config.toml` where SSL verification is turned
  off for login and API requests and the preferred token storage is `anaconda-keyring`.

  ```toml
  [plugin.cloud]
  ssl_verify = false
  preferred_token_storage = "system"
  ```



  When you `login` with `anaconda-cloud-auth` an auth token is stored in the preferred keyring storage location and is
  deleted when you run `logout`. The auth token will need to be renewed once a year.

  The `preferred_storage` configuration parameter in the `plugin.cloud` section of the config.toml file takes two
  possible values

  | Storage location | Description |
  |-|-|
  | `"system"` | Use the system keyring if available, otherwise use `anaconda-keyring` |
  | `"anaconda-keyring"` | A file-based keyring at `~/.anaconda/keyring` |

  `"anaconda-keyring"` is the default value.



  If you want to utilize Anaconda Cloud Services on a system where you do not have interactive access to a browser to
  use the `login` command you have two options

  1. Use `anaconda cloud api-key` command on a system where you can login to print the API key to the terminal. You can then
  utilize the API key on the non-interactive system with the `ANACONDA_CLOUD_API_KEY` env var (or in `.env` file) or set
  the `key` parameter in the `plugin.cloud_api` section of the `~/.anaconda/config.toml` file.
  1. With `preferred_token_storage` set to `"anaconda-keyring"` run the `login` command to create the `~/.anaconda/keyring`
  file. Then copy `~/.anaconda/keyring` to the non-interactive system.



  ```python
  from anaconda_cloud_auth import login

  login()
  ```

  The `login()` function initiates a browser-based login flow. It will automatically
  open your browser and once you have completed the login flow it will store an
  API key on your system.

  Typically, these API keys will have a one year expiration so you will only need
  to login once and requests using the client class will read the token from the
  keyring storage.

  If you call `login()` while there is a valid (non-expired) API key no action is
  taken. You can replace the valid API key with `login(force=True)`.

  To remove the API key from your keyring storage use the `logout()` function.

  ```python
  from anaconda_cloud_auth import logout

  logout()
  ```



  The BaseClient class is a subclass of [requests.Session](https://requests.readthedocs.io/en/latest/user/advanced/#session-objects).
  It will attempt load the API key from the keyring on each request unless overridden
  by the `api_key` argument.

  The BaseClient class can be used for non-authenticated requests even when
  the user has not logged in or provided an API in the request.

  ```python
  from anaconda_cloud_auth.client import BaseClient

  client = BaseClient()

  response = client.get("/api/<endpoint>")
  response.raise_for_status()
  print(response.json())
  ```

  BaseClient accepts the following optional arguments.

  * `domain`: Domain to use for requests, defaults to `anaconda.cloud`
  * `ssl_verify`: Enable SSL verification, defaults to `True`
  * `api_key`: API key to use for requests, if unspecified uses token set by `anaconda login`
  * `user_agent`: Defaults to `anaconda-cloud-auth/<package-version>`
  * `api_version`: Requested API version, defaults to latest available from the domain
  * `extra_headers`: Dictionary or JSON string of extra headers to send in requests

  To create a Client class specific to your package, subclass BaseClient and set
  an appropriate user-agent and API version for your needs. This is automatically done
  if you use the [cookiecutter](https://github.com/anaconda/anaconda-cloud-tools/tree/main/cookiecutter)
  in this repository to create a new package.

  ```python
  from anaconda_cloud_auth.client import BaseClient
  class Client(BaseClient):
      _user_agent = "anaconda-cloud-<package>/<version>"
      _api_version = "<api-version>"
  ```



  This plugin defines an [error handler](https://github.com/anaconda/anaconda-cloud-tools/tree/main/libs/anaconda-cli-base#error-handling) for the `HTTPError` exception when using `.raise_for_status()` on a response
  using BaseClient or subclasses of BaseClient. Errors are not caught automatically when using the BaseClient
  or subclasses outside of `anaconda` CLI subcommands.



  For the following cases if running the CLI command interactively the user is asked if they wish to continue with
  interactive login. Once completed the command will be re-tried.

  * `TokenNotFoundError`: The subcommand requested to load the token from the keyring but none were present
  * `TokenExpiredError`: The token was successfully loaded but has expired
  * `AuthenticationMissing`: Derived from `requests.exceptions.HTTPError`, the request was made without an API key or token to an endpoint that requires authentication.
  * `InvalidAuthentication`: Derived from `requests.exceptions.HTTPError`, the request was made using an API key or token but Anaconda Cloud determines that the API was invalid

  Here's an example demonstrating that the user has not previously run `anaconda login` but attempted a CLI command that at some point requires authentication. By typing `y` the login action is triggered and their browser will open.

  ```text
  ❯ anaconda cloud api-key
  TokenNotFoundError: Login is required to complete this action.
  Continue with interactive login? [y/n]: y
  <api-key>
  ```

  If the user typed `n` or the command was not run on an interactive terminal an error message is shown instructing
  the user how to login or configure the API key.

  ```text
  ❯ anaconda cloud whoami
  AuthenticationMissingError: Login is required to complete this action.
  Continue with interactive login? [y/n]: n

  To configure your credentials you can run
    anaconda login --at cloud

  or set your API key using the ANACONDA_CLOUD_API_KEY env var

  or set

  [plugin.cloud]
  api_key = "<api-key>"

  in ~/.anaconda/config.toml

  To see a more detailed error message run the command again as
    anaconda --verbose cloud whoami
  ```



  In addition to the two special cases above all HTTPError exceptions thrown during CLI subcommands will be handled
  to provide the error code and reason.

  For example a subcommand using BaseClient or a subclass of it may make a bad request.

  ```python
  @plugin.subcommand('do-something')
  def do_something(inputs: Annotated[Any, typer.Argument()]):
      client = Client()
      res = client.post('api/something', data=inputs)
      res.raise_for_status()
  ```

  For this example subcommand the user may provide incorrect inputs that are passed to the endpoint. By using
  `.raise_for_status()` the error is passed along to the CLI user and a short response is printed.

  ```text
  > anaconda plugin do-something 'input-data'
  HTTPError: 422 Client Error: Unprocessable Entity for url: https://anaconda.cloud/api/something

  To see a more detailed error message run the command again as
    anaconda --verbose plugin do-something
  ```



  In order to use the `anaconda_cloud` auth plugin you will need an OAuth client
  ID (key) and secret. The client must be configured as follows

  ```text
  Set scopes: offline_access, openid, email, profile
  Set redirect url to http://localhost:5006
  Set grant type: Authorization Code
  Set response types: ID Token, Token, Code
  Set access token type: JWT
  Set Authentication Method: HTTP Body
  ```

  To run the app with the anaconda_cloud auth provider you will need to set several
  environment variables or command-line arguments. See the
  [Panel OAuth documentation](https://panel.holoviz.org/how_to/authentication/configuration.html)
  for more details

  ```text
  PANEL_OAUTH_PROVIDER=anaconda_cloud or --oauth-provider anaconda_cloud
  PANEL_OAUTH_KEY=<key>               or --oauth-key=<key>
  PANEL_OAUTH_SECRET=<secret>         or --oauth-secret=<key>
  PANEL_COOKIE_SECRET=<cookie-name>   or --cookie-secret=<value>
  PANEL_OAUTH_REFRESH_TOKENS=1        or --oauth-refresh-tokens
  PANEL_OAUTH_OPTIONAL=1              or --oauth-optional
  ```

  ```text
  panel serve <arguments> ...
  ```

  If you do not specify the `.env` file, the production configuration should be the default.
  Please file an issue if you see any errors.



  Ensure you have `conda` installed.
  Then run:

  ```shell
  make setup
  ```



  ```shell
  make test
  ```



  ```shell
  make tox
  ```


pkgId: 375ad37e814b8774d9aeb2dac12928cd65015d93e41747b5331b88daef25345c
name: python-anaconda-cloud-cli
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: The Anaconda Cloud CLI
url: https://pypi.org/project/anaconda-cloud-cli/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaconda-cloud-cli-0.3.0-1.src.rpm
checksum_type: sha256
description:
  **DEPRECATED**

  This package is now deprecated in favor of `anaconda-cli-base`, for which
  anaconda-client 1.13 is a plugin.

  The current version of `anaconda-cloud-cli` has no dependencies and does not
  install modules to allow clean upgrades in pre-existing environments.



  The base CLI for Anaconda Cloud.
  It currently provides the handling of cloud login/logout, and backwards-compatible passthrough of arguments to the core `anaconda-client` CLI.

  This CLI is intended to provide identical behavior to `anaconda-client`, except for minor changes to the login/logout flow, to provide a gentle deprecation path.



  Ensure you have `conda` installed.
  Then run:
  ```shell
  make setup
  ```


  ```shell
  make test
  ```


  ```shell
  make tox
  ```


pkgId: a6a430f3dcffe2790d04bf8be68ce9123bb490689a48603a0bb8df2f7fc40a7e
name: python-anacondacode
arch: src
version: 0.0.3.post5
epoch: 0
release: 1
summary: anacondacode
url: https://github.com/salabim/anacondacode
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anacondacode-0.0.3.post5-1.src.rpm
checksum_type: sha256
description:
  This module contains one function: `runner`

  The function `runner` is intended to be used in Anaconda code cell on an Excel workbook.
  It has one parameter: `data`, which can be:

  - a reference to an Excel range via the REF function (a list of lists)
  - a pandas dataframe
  - a numpy array

  The data should refer to cells that contain valid Python code. In order to avoid problems, we recommend
  to format these cells as text.
  The result (if any) of the code should be put in the global `output`.

  Each column has uses the same global AnacondaCode namespace.
  But, a column can also be used as were it a module. This is done by placing a

  ```# module = modulename```

  line in the code column.
  The given module name then becomes available for ordinary imports in the other code columns.
  E.g.

  <img src="https://www.salabim.org/anacondacode/anacondacode_poc.png" width=900 align=left>

  The global variable `output` can be used to return an accepted value to the sheet (in this case a list of tuples).

  You can download the above sheet at: www.salabim.org/anacondacode/anacondacode_poc.xlsx

  For this and more examples, see the samples folder in the anaconda repository (www.github.com/salabim/anacondacode).


  Install the module `anacondacode` from PyPI as described in section 'Managing software packages' of https://docs.anaconda.com/excel/code/


  This module is in no way affiliated with Anaconda, Inc.


pkgId: 192e9dc231818ae5dede4dbb19d9c5a2557c213aa317e795fe91633067e41c8a
name: python-anakin-language-server
arch: src
version: 1.22
epoch: 0
release: 1
summary: Yet another Jedi Python language server
url: https://github.com/muffinmad/anakin-language-server
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anakin-language-server-1.22-1.src.rpm
checksum_type: sha256
description:
  [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)


  Yet another Jedi Python language server



  - Python >= 3.6
  - pygls >= 1.3, <1.4
  - Jedi >= 0.19
  - pyflakes ~= 2.2
  - pycodestyle ~= 2.5
  - yapf ~=0.30


  - mypy



  - `textDocument/completion`
  - `textDocument/hover`
  - `textDocument/signatureHelp`
  - `textDocument/definition`
  - `textDocument/references`
  - `textDocument/publishDiagnostics`
  - `textDocument/documentSymbol`
  - `textDocument/codeAction` ([Inline variable](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.Script.inline))
  - `textDocument/formatting`
  - `textDocument/rangeFormatting`
  - `textDocument/rename`
  - `textDocument/documentHighlight`



  - `venv` - path to virtualenv. This option will be passed to Jedi's [create\_environment](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.create_environment).

  Also one can set `VIRTUAL_ENV` or `CONDA_PREFIX` before running `anakinls` so Jedi will find proper environment. See [get\_default\_environment](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.get_default_environment).




  Diagnostics are published on document open and save.

  Diagnostics providers:

  - **Jedi**

    See [get\_syntax\_errors](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.Script.get_syntax_errors).

  - **pyflakes**
  - **pycodestyle**

    Server restart is needed after changing one of the [configuration files](https://pycodestyle.pycqa.org/en/latest/intro.html#configuration).

  - **mypy**

    Install `mypy` in the same environment as `anakinls` and set `mypy_enabled` configuration option.



  Configuration options must be passed under `anakinls` key in `workspace/didChangeConfiguration` notification.

  Available options:

  |Option|Description|Default|
  |-|-|-|
  |`help_on_hover`|Use [`help`](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.Script.help) instead of [`infer`](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.Script.infer) for `textDocument/hover`.|`True`|
  |`completion_snippet_first`|Tweak `sortText` property so snippet completion appear before plain completion.|`False`|
  |`completion_fuzzy`|Value of the `fuzzy` parameter for [`complete`](https://jedi.readthedocs.io/en/latest/docs/api.html#jedi.Script.complete).|`False`|
  |`diagnostic_on_open`|Publish diagnostics on `textDocument/didOpen`|`True`|
  |`diagnostic_on_change`|Publish diagnostics on `textDocument/didChange`|`False`|
  |`diagnostic_on_save`|Publish diagnostics on `textDocument/didSave`|`True`|
  |`pyflakes_errors`|Diagnostic severity will be set to `Error` if Pyflakes message class name is in this list. See [Pyflakes messages](https://github.com/PyCQA/pyflakes/blob/master/pyflakes/messages.py).|`['UndefinedName']`|
  |`pycodestyle_config`|In addition to project and user level config, specify pycodestyle config file. Same as `--config` option for `pycodestyle`.|`None`|
  |`mypy_enabled`|Use [`mypy`](https://mypy.readthedocs.io/en/stable/index.html) to provide diagnostics.|`False`|
  |`yapf_style_config`|Either a style name or a path to a file that contains formatting style settings.|`'pep8'`|
  |`jedi_settings`|Global [Jedi settings](https://jedi.readthedocs.io/en/latest/docs/settings.html).<br>E.g. set it to `{"case_insensitive_completion": False}` to turn off case insensitive completion|`{}`|



  Here is [eglot](https://github.com/joaotavora/eglot) configuration:

  ```elisp
  (defvar my/lsp-venv nil
    "Name of virtualenv.
  Set it in project's dir-locals file.")

  (defclass my/eglot-anakinls (eglot-lsp-server) ()
    :documentation
    "Own eglot server class.")

  (cl-defmethod eglot-initialization-options ((_server my/eglot-anakinls))
    "Pass initialization param to anakinls."
    `(:venv ,(when my/lsp-venv
               (expand-file-name
                (concat "~/.virtualenvs/" my/lsp-venv)))))

  ;; Add this server to eglot programs to handle python-mode and run `anakinls'
  (add-to-list 'eglot-server-programs
               '(python-mode my/eglot-anakinls "anakinls"))

  ;; Also treat UnusedVariable as error
  (setq-default eglot-workspace-configuration
                '((:anakinls :pyflakes_errors ["UndefinedName" "UnusedVariable"])))

  ```



  ```
  pip install anakin-language-server
  ```



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

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


pkgId: f199cdca6317d49db33ae7f764672ada554832367ad358fefc47b16fd0c30fc7
name: python-analogvnn
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: A fully modular framework for modeling and optimizing analog/photonic neural networks
url: https://github.com/Vivswan/AnalogVNN
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analogvnn-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [![arXiv](https://img.shields.io/badge/arXiv-2210.10048-orange.svg)](https://arxiv.org/abs/2210.10048)
  [![AML](https://img.shields.io/badge/AML-10.1063/5.0134156-orange.svg)](https://doi.org/10.1063/5.0134156)
  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Vivswan/AnalogVNN/blob/release/docs/_static/AnalogVNN_Demo.ipynb)

  [![PyPI version](https://badge.fury.io/py/analogvnn.svg)](https://badge.fury.io/py/analogvnn)
  [![Documentation Status](https://readthedocs.org/projects/analogvnn/badge/?version=stable)](https://analogvnn.readthedocs.io/en/stable/?badge=stable)
  [![Python](https://img.shields.io/badge/python-3.7--3.11-blue)](https://badge.fury.io/py/analogvnn)
  [![License: MPL 2.0](https://img.shields.io/badge/License-MPL_2.0-blue.svg)](https://opensource.org/licenses/MPL-2.0)

  Documentation: [https://analogvnn.readthedocs.io/](https://analogvnn.readthedocs.io/)



  - Install [PyTorch](https://pytorch.org/)
  - Install AnalogVNN using [pip](https://pypi.org/project/analogvnn/)

  ```bash
    
    pip install analogvnn

    
    pip install analogvnn[full]
  ```



  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Vivswan/AnalogVNN/blob/release/docs/_static/AnalogVNN_Demo.ipynb)

  - Sample code with AnalogVNN: [sample_code.py](https://github.com/Vivswan/AnalogVNN/blob/release/sample_code.py)
  - Sample code without
    AnalogVNN: [sample_code_non_analog.py](https://github.com/Vivswan/AnalogVNN/blob/release/sample_code_non_analog.py)
  - Sample code with AnalogVNN and
    Logs: [sample_code_with_logs.py](https://github.com/Vivswan/AnalogVNN/blob/release/sample_code_with_logs.py)
  - Jupyter
    Notebook: [AnalogVNN_Demo.ipynb](https://github.com/Vivswan/AnalogVNN/blob/release/docs/_static/AnalogVNN_Demo.ipynb)



  [//]: # (![3 Layered Linear Photonic Analog Neural Network]&#40;docs/_static/analogvnn_model.png&#41;)

  ![3 Layered Linear Photonic Analog Neural Network](https://github.com/Vivswan/AnalogVNN/raw/release/docs/_static/analogvnn_model.png)

  **AnalogVNN** is a simulation framework built on PyTorch which can simulate the effects of
  optoelectronic noise, limited precision, and signal normalization present in photonic
  neural network accelerators. We use this framework to train and optimize linear and
  convolutional neural networks with up to 9 layers and ~1.7 million parameters, while
  gaining insights into how normalization, activation function, reduced precision, and
  noise influence accuracy in analog photonic neural networks. By following the same layer
  structure design present in PyTorch, the AnalogVNN framework allows users to convert most
  digital neural network models to their analog counterparts with just a few lines of code,
  taking full advantage of the open-source optimization, deep learning, and GPU acceleration
  libraries available through PyTorch.

  AnalogVNN Paper: [https://doi.org/10.1063/5.0134156](https://doi.org/10.1063/5.0134156)



  We would appreciate if you cite the following paper in your publications for which you used AnalogVNN:

  ```bibtex
  @article{shah2023analogvnn,
    title={AnalogVNN: A fully modular framework for modeling and optimizing photonic neural networks},
    author={Shah, Vivswan and Youngblood, Nathan},
    journal={APL Machine Learning},
    volume={1},
    number={2},
    year={2023},
    publisher={AIP Publishing}
  }
  ```

  Or in textual form:

  ```text
  Vivswan Shah, and Nathan Youngblood. "AnalogVNN: A fully modular framework for modeling
  and optimizing photonic neural networks." APL Machine Learning 1.2 (2023).
  DOI: 10.1063/5.0134156
  ```


pkgId: 8231608fcea6528384761d4c732b707a5508d4e86449ad8b21844036fa857e98
name: python-analysis-engine
arch: src
version: 2.0.14
epoch: 0
release: 1
summary: Analysis for the UK Department for Transport's major projects portfolio
url: https://github.com/banillie/analysis_engine
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analysis-engine-2.0.14-1.src.rpm
checksum_type: sha256
description:
  Software for portfolio management reporting and analysis in the UK Department for Transport, operated via command line
  interface (CLI) prompts.


  Python must be installed on your computer. If not already installed, it can be installed via the python website
  [here](https://www.python.org/downloads/). **IMPORTANT** ensure that `Add Python to PATH` is ticked when provided
  with the option as part of the installation wizard.

  Open the command line terminal (Windows) or bash shell and install via `pip install analysis_engine`.


  In order to operate the correct directories and files must be set-up and saved on the user's computer.
  `analysis_engine` is able to handle different operating systems.

  Create the following directories in your `My Documents` directory:

      |-- ipdc
          |-- core_data
              |-- json
          |-- input
          |-- output
      |-- top250
          |-- core_data
              |-- json
          |-- input
          |-- output


  Each reporting process e.g. ipdc and top250, respective `core_data` directorates require:
  1) excel master data files;
  2) excel project information file; and,
  3) A confi.ini file. This file lists and master data and project information file names.

  As a minimum the `input` folder should have the following documents `summary_temp.docx`,
  `summary_temp_landscape.docx`. In addition `ipdc\input` should have the
  `dashboards_master.xlsx` file.

  All outputs from analysis_engine will be saved into the `output` directory.

  The `json` folder is where analysis_engine saves master data in an easily accessible
  format (.json) and after setup can be ignored by the user.

  Unfortunately there is one further manual installation, related to a package within analysis_engine
  which enables high quality rendering of graphical outputs to word documents. On Windows do the following:

  1) Download zip of poppler release from this link https://github.com/oschwartz10612/poppler-windows/releases/download/v21.03.0/Release-21.03.0.zip.
  2) unzip and move the whole directory to My Documents.
  3) Add the poppler bin directory to PATH following these instructions
     https://www.architectryan.com/2018/03/17/add-to-the-path-on-windows-10/
  4) Reboot computer.

  Mac users should follow instructions here https://pypi.org/project/pdf2image/

  Most Linux distributions should not require any manual installation.



  To operate analysis_engine the user must enter the initial **_command_**
  `analysis` followed by a _**subcommand**_ to specify the reporting process e.g
  `ipdc` or `top250` and then finally an analytical output **_argument_**, the options
  for which are set out below.

  **NOTE** the `--help` option is available throughout the entire command
  line prompt construction process and the user should use it for guidance on what subcommands
  and arguments are available for use.

  analysis_engine currently has the following _arguments_:

  `initiate` The user must enter this command
  every time master data, contained in the core_data directory, is updated.
  The initiate checks and validates the data in a number of ways.

  `dashboards` populates the IPDC PfM report dashboard. A blank template dashboard
  must be saved in the ipdc/input directory. (Not currently available for top250.)

  `dandelion` produces the portfolio dandelion info-graphic.

  `costs` produces a cost profile trend graph and data. (Not currently available for top250.)

  `milestones` produces milestone schedule graphs and data.

  `vfm` produces vfm data. (Not currently available for top250.)

  `summaries` produces project summary reports.

  `risks` produces risk data. (Not currently available for top250.)

  `dcas` produces dca data. (Not currently available for top250.)

  `speedial` prints out changes in project dca ratings. (Not currently available for top250.)

  `query` returns (from master data) specific data required by the user.

  The default for each argument is to return outputs with current and last quarter data.

  Further to each argument the user can specify one or many
  further **_optional_arguments_** to alter the analytical output produced. There are
  many optional_arguments available, which vary for each argument,
  and the user should use the `--help` option to specify those that are available.


pkgId: 50fa43909d72570c023965de7c2ef931714d8bd2e1a9eaf55bf58d122119408a
name: python-analysis-runner
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Analysis runner to help make analysis results reproducible
url: https://github.com/populationgenomics/analysis-runner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analysis-runner-3.1.2-1.src.rpm
checksum_type: sha256
description:
  This tool helps to [improve analysis provenance](https://github.com/populationgenomics/team-docs/blob/main/reproducible_analyses.md) and theoretical reproducibility by automating the following aspects:

  - Allow quick iteration using an environment that resembles production.
  - Only allow access to production datasets through code that has been reviewed.
  - Link the output data with the exact program invocation of how the data has been generated.

  One of our main workflow pipeline systems at the CPG is [Hail Batch](https://hail.is/docs/batch/getting_started.html). By default, its pipelines are defined by running a Python program _locally_ and submitting the resulting DAG to the Hail Batch server. By specifying a repo, commit, and file, this tool will run your script inside a "driver" image on Hail Batch, with the correct permissions.

  All invocations are logged to metamist, in the [analysis-runner page](https://sample-metadata.populationgenomics.org.au/analysis-runner/).

  When using the analysis-runner, the jobs are run as a specific Hail Batch service account to give appropriate permissions based on the dataset, and access level ("test", "standard", or "full", as documented in the team docs [storage policies](https://github.com/populationgenomics/team-docs/tree/main/storage_policies#analysis-runner)). This helps with bucket permission management and billing budgets.

  By default, we run your script in a driver image, that contains a number of common tools - but you can in fact run any container inside the cpg-common artifact registry (and any container if running using the test access level).

  The analysis-runner is also integrated with our Cromwell server to run WDL based workflows.



  The analysis-runner CLI is used to start pipelines based on a GitHub repository, commit, and command to run.

  First, make sure that your environment provides Python 3.10 or newer. We recommend using `pyenv` to manage your python versions

  ```sh
  pyenv install 3.10.12
  pyenv global 3.10.12
  > python3 --version
  Python 3.10.12
  ```

  Then install the `analysis-runner` Python package using `pip`:

  ```bash
  python3 -m pip install analysis-runner
  ```

  Run `analysis-runner --help` to see usage information.

  Make sure that you're logged into GCP with _application-default_ credentials:

  ```bash
  gcloud auth application-default login
  ```

  If you're in the directory of the project you want to run, you can omit the `--commit` and `--repository` parameters, which will use your current git remote and commit HEAD.

  For example:

  ```bash
  analysis-runner \
      --dataset <dataset> \
      --description <description> \
      --access-level <level> \
      --output-dir <directory-within-bucket> \
      script_to_run.py with arguments
  ```

  `<level>` corresponds to an [access level](https://github.com/populationgenomics/team-docs/tree/main/storage_policies#analysis-runner) as defined in the storage policies.

  `<directory-within-bucket>` does _not_ contain a prefix like `gs://cpg-fewgenomes-main/`. For example, if you want your results to be stored in `gs://cpg-fewgenomes-main/1kg_pca/v2`, specify `--output-dir 1kg_pca/v2`.

  If you provide a `--repository`, you MUST supply a `--commit <SHA>`, e.g.:

  ```bash
  analysis-runner \
      --repository my-approved-repo \
      --commit <commit-sha> \
      --dataset <dataset> \
      --description <description> \
      --access-level <level>
      --output-dir <directory-within-bucket> \
      script_to_run.py with arguments
  ```

  For more examples (including for running an R script and dataproc), see the
  [examples](examples) directory.



  If you are submitting an analysis-runner job that needs to clone a private repository owned by populationgenomics on GitHub (eg submitting a script to analysis-runner from a private repository), the analysis-runner should insert the following items into your `config.toml`:

  ```toml
  [infrastructure]
  git_credentials_secret_name = '<ask_software_team_for_secret_name>'
  git_credentials_secret_project = '<ask_software_team_for_secret_project>'
  ```

  If you are specifying multiple configuration files, please don't accidentally override these values.



  The default driver image that's used to run scripts comes with Hail and some statistics libraries preinstalled (see the corresponding [Hail Dockerfile](driver/Dockerfile.hail)). It's possible to use any custom Docker image instead, using the `--image` parameter. Note that any such image needs to contain the critical dependencies as specified in the [`base` image](driver/Dockerfile.base).

  For R scripts, we add the R-tidyverse set of packages to the base image, see the corresponding [R Dockerfile](driver/Dockerfile.r) and the [R example](examples/r) for more details.



  The analysis-runner package has a number of functions that make it easier to run reproducible analysis through Hail Batch.

  This is installed in the analysis runner driver image, ie: you can access the analysis_runner module when running scripts through the analysis-runner.



  ```python
  from cpg_utils.hail_batch import get_batch
  from analysis_runner.git import (
    prepare_git_job,
    get_repo_name_from_current_directory,
    get_git_commit_ref_of_current_repository,
  )

  b = get_batch(name='do-some-analysis')
  j = b.new_job('checkout_repo')
  prepare_git_job(
    job=j,
    
    repo_name=get_repo_name_from_current_directory(),
    
    commit=get_git_commit_ref_of_current_repository(),
  )


  j.command('examples/bash/hello.sh')
  ```



  ```python
  from cpg_utils.hail_batch import get_batch
  from analysis_runner.dataproc import setup_dataproc

  b = get_batch(name='do-some-analysis')




  cluster = dataproc.setup_dataproc(
      b,
      max_age='1h',
      packages=['click', 'selenium'],
      cluster_name='My Cluster with max-age=1h',
  )
  cluster.add_job('examples/dataproc/query.py', job_name='example')
  ```



  You can ignore this section if you just want to run the tool.

  To set up a development environment for the analysis runner using pip, run
  the following:

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



  The server can be deployed by manually running the [`deploy_server.yaml`](https://github.com/populationgenomics/analysis-runner/actions/workflows/deploy_server.yaml) GitHub action. This will also deploy the driver image.

  The CLI tool is shipped as a pip package, this happens automatically on pushes to `main.py`. To build a new version, you should add a [bump2version](https://pypi.org/project/bump2version/) commit to your branch.


pkgId: fbd855fe28d102bd96b9462f6f7d7edf80e18742b8c02022003db3e86d1fbe4f
name: python-analysistoolbox
arch: src
version: 2.1.5
epoch: 0
release: 1
url: https://github.com/KyleProtho/AnalysisToolBox/tree/master/analysistoolbox
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analysistoolbox-2.1.5-1.src.rpm
checksum_type: sha256
summary:
  A collection tools in Python for data collection and processing, statistics, analytics, and intelligence analysis.

description:
  Analysis Tool Box (i.e. "analysistoolbox") is a collection of tools in Python for data collection and processing, statisitics, analytics, and intelligence analysis.



  To install the package, run the following command in the root directory of the project:

  ```bash
  pip install analysistoolbox
  ```

  Visualizations are created using the matplotlib and seaborn libraries. While you can select whichever seaborn style you'd like, the following Seaborn style tends to get the best looking plots:

  ```python
  sns.set(
      style="white",
      font="Arial",
      context="paper"
  )
  ```



  There are many modules in the analysistoolbox package, each with their own functions. The following is a list of the modules:

  * Calculus
  * Data collection
  * Data processing
  * Descriptive analytics
  * File management
  * Hypothesis testing
  * Linear algebra
  * Predictive analytics
  * Statistics
  * Visualizations



  There are several functions in the Calculus submodule. The following is a list of the functions:

  * FindDerivative
  * FindLimitOfFunction
  * FindMinimumSquareLoss
  * PlotFunction



  The **FindDerivative** function calculates the derivative of a given function. It uses the sympy library, a Python library for symbolic mathematics, to perform the differentiation. The function also has the capability to print the original function and its derivative, return the derivative function, and plot both the original function and its derivative.

  ```python

  from analysistoolbox.calculus import FindDerivative
  import sympy


  x = sympy.symbols('x')


  f_of_x = x**3 + 2*x**2 + 3*x + 4


  FindDerivative(
      f_of_x,
      print_functions=True,
      return_derivative_function=True,
      plot_functions=True
  )
  ```



  The **FindLimitOfFunction** function finds the limit of a function at a specific point and optionally plot the function and its tangent line at that point. The script uses the matplotlib and numpy libraries for plotting and numerical operations respectively.

  ```python

  from analysistoolbox.calculus import FindLimitOfFunction
  import numpy as np
  import sympy


  x = sympy.symbols('x')


  f_of_x = np.sin(x) / x


  FindLimitOfFunction(
      f_of_x,
      point=0,
      step=0.01,
      plot_function=True,
      x_minimum=-10,
      x_maximum=10,
      n=1000,
      tangent_line_window=1
  )
  ```



  The **FindMinimumSquareLoss** function calculates the minimum square loss between observed and predicted values. This function is often used in machine learning and statistics to measure the average squared difference between the actual and predicted outcomes.

  ```python

  from analysistoolbox.calculus import FindMinimumSquareLoss


  observed_values = [1, 2, 3, 4, 5]
  predicted_values = [1.1, 1.9, 3.2, 3.7, 5.1]


  minimum_square_loss = FindMinimumSquareLoss(
      observed_values,
      predicted_values,
      show_plot=True
  )


  print(f"The minimum square loss is: {minimum_square_loss}")
  ```



  The **PlotFunction** function plots a mathematical function of x. It takes a lambda function as input and allows for customization of the plot.

  ```python

  from analysistoolbox.calculus import PlotFunction
  import sympy


  x = sympy.symbols('x')


  f_of_x = lambda x: x**2


  PlotFunction(f_of_x)
  ```



  There are several functions in the Data Collection submodule. The following is a list of the functions:

  * ExtractTextFromPDF
  * FetchPDFFromURL
  * FetchUSShapefile
  * FetchWebsiteText
  * GetGoogleSearchResults
  * GetZipFile



  The **ExtractTextFromPDF** function extracts text from a PDF file, cleans it, then saves it to a text file.

  ```python

  from analysistoolbox.data_collection import ExtractTextFromPDF


  ExtractTextFromPDF(
      filepath_to_pdf="/path/to/your/input.pdf",
      filepath_for_exported_text="/path/to/your/output.txt",
      start_page=1,
      end_page=None
  )
  ```



  The **FetchPDFFromURL** function downloads a PDF file from a URL and saves it to a specified location.

  ```python

  from analysistoolbox.data_collection import FetchPDFFromURL


  FetchPDFFromURL(
      url="https://example.com/sample.pdf",
      filename="C:/folder/sample.pdf"
  )
  ```



  The **FetchUSShapefile** function fetches a geographical shapefile from the TIGER database of the U.S. Census Bureau.

  ```python

  from analysistoolbox.data_collection import FetchUSShapefile


  shapefile = FetchUSShapefile(
      state='PA',
      county='Allegheny',
      geography='tract',
      census_year=2021
  )


  print(shapefile.head())
  ```



  The **FetchWebsiteText** function fetches the text from a website and saves it to a text file.

  ```python

  from analysistoolbox.data_collection import FetchWebsiteText


  text = FetchWebsiteText(
      url="https://www.example.com",
      browserless_api_key="your_browserless_api_key"
  )


  print(text)
  ```



  The **GetGoogleSearchResults** function fetches Google search results for a given query using the Serper API.

  ```python

  from analysistoolbox.data_collection import GetGoogleSearchResults



  results = GetGoogleSearchResults(
      query="Python programming",
      serper_api_key='your_serper_api_key',
      number_of_results=5,
      apply_autocorrect=True,
      display_results=True
  )


  print(results)
  ```



  The **GetZipFile** function downloads a zip file from a url and saves it to a specified folder. It can also unzip the file and print the contents of the zip file.

  ```python

  from analysistoolbox.data_collection import GetZipFile


  GetZipFile(
      url="http://example.com/file.zip",
      path_to_save_folder="/path/to/save/folder"
  )
  ```



  There are several functions in the Data Processing submodule. The following is a list of the functions:

  * AddDateNumberColumns
  * AddLeadingZeros
  * AddRowCountColumn
  * AddTPeriodColumn
  * AddTukeyOutlierColumn
  * CleanTextColumns
  * ConductAnomalyDetection
  * ConductEntityMatching
  * ConvertOddsToProbability
  * CountMissingDataByGroup
  * CreateBinnedColumn
  * CreateDataOverview
  * CreateRandomSampleGroups
  * CreateRareCategoryColumn
  * CreateStratifiedRandomSampleGroups
  * ImputeMissingValuesUsingNearestNeighbors
  * VerifyGranularity



  The **AddDateNumberColumns** function adds columns for the year, month, quarter, week, day of the month, and day of the week to a dataframe.

  ```python

  from analysistoolbox.data_processing import AddDateNumberColumns
  from datetime import datetime
  import pandas as pd


  data = {'Date': [datetime(2020, 1, 1), datetime(2020, 2, 1), datetime(2020, 3, 1), datetime(2020, 4, 1)]}
  df = pd.DataFrame(data)


  df = AddDateNumberColumns(
      dataframe=df,
      date_column_name='Date'
  )


  print(df)
  ```



  The **AddLeadingZeros** function adds leading zeros to a column. If fixed_length is not specified, the longest string in the column is used as the fixed length. If add_as_new_column is set to True, the new column is added to the dataframe. Otherwise, the original column is updated.

  ```python

  from analysistoolbox.data_processing import AddLeadingZeros
  import pandas as pd


  data = {'ID': [1, 23, 456, 7890]}
  df = pd.DataFrame(data)


  df = AddLeadingZeros(
      dataframe=df,
      column_name='ID',
      add_as_new_column=True
  )


  print(df)
  ```



  The **AddRowCountColumn** function adds a column to a dataframe that contains the row number for each row, based on a group (or groups) of columns. The function can also sort the dataframe by a column or columns before adding the row count column.

  ```python

  from analysistoolbox.data_processing import AddRowCountColumn
  import pandas as pd


  data = {
      'Payment Method': ['Check', 'Credit Card', 'Check', 'Credit Card', 'Check', 'Credit Card', 'Check', 'Credit Card'],
      'Transaction Value': [100, 200, 300, 400, 500, 600, 700, 800],
      'Transaction Order': [1, 2, 3, 4, 5, 6, 7, 8]
  }
  df = pd.DataFrame(data)


  df_updated = AddRowCountColumn(
      dataframe=df,
      list_of_grouping_variables=['Payment Method'],
      list_of_order_columns=['Transaction Order'],
      list_of_ascending_order_args=[True]
  )


  print(df_updated)
  ```



  The **AddTPeriodColumn** function adds a T-period column to a dataframe. The T-period column is the number of intervals (e.g., days or weeks) since the earliest date in the dataframe.

  ```python

  from analysistoolbox.data_processing import AddTPeriodColumn
  from datetime import datetime
  import pandas as pd


  data = {
      'date': pd.date_range(start='1/1/2020', end='1/10/2020'),
      'value': range(1, 11)
  }
  df = pd.DataFrame(data)


  df_updated = AddTPeriodColumn(
      dataframe=df,
      date_column_name='date',
      t_period_interval='days'
  )


  print(df_updated)
  ```



  The **AddTukeyOutlierColumn** function adds a column to a dataframe that indicates whether a value is an outlier. The function uses the Tukey method to identify outliers.

  ```python

  from analysistoolbox.data_processing import AddTukeyOutlierColumn
  import pandas as pd


  data = pd.DataFrame({'values': [1, 2, 3, 4, 5, 6, 7, 8, 9, 20]})


  df_updated = AddTukeyOutlierColumn(
      dataframe=data,
      value_column_name='values',
      tukey_boundary_multiplier=1.5,
      plot_tukey_outliers=True
  )


  print(df_updated)
  ```



  The **CleanTextColumns** function cleans string-type columns in a pandas DataFrame by removing all leading and trailing spaces.

  ```python

  from analysistoolbox.data_processing import CleanTextColumns
  import pandas as pd


  df = pd.DataFrame({
      'A': [' hello', 'world ', ' python '],
      'B': [1, 2, 3],
  })


  df_clean = CleanTextColumns(df)
  ```



  The **ConductAnomalyDetection** function performs anomaly detection on a given dataset using the z-score method.

  ```python

  from analysistoolbox.data_processing import ConductAnomalyDetection
  import pandas as pd


  df = pd.DataFrame({
      'A': [1, 2, 3, 1000],
      'B': [4, 5, 6, 2000],
  })


  df_anomaly_detected = ConductAnomalyDetection(
      dataframe=df,
      list_of_columns_to_analyze=['A', 'B']
  )


  print(df_anomaly_detected)
  ```



  The **ConductEntityMatching** function performs entity matching between two dataframes using various fuzzy matching algorithms.

  ```python
  from analysistoolbox.data_processing import ConductEntityMatching
  import pandas as pd


  dataframe_1 = pd.DataFrame({
      'ID': ['1', '2', '3'],
      'Name': ['John Doe', 'Jane Smith', 'Bob Johnson'],
      'City': ['New York', 'Los Angeles', 'Chicago']
  })

  dataframe_2 = pd.DataFrame({
      'ID': ['a', 'b', 'c'],
      'Name': ['Jon Doe', 'Jane Smyth', 'Robert Johnson'],
      'City': ['NYC', 'LA', 'Chicago']
  })


  matched_entities = ConductEntityMatching(
      dataframe_1=dataframe_1,
      dataframe_1_primary_key='ID',
      dataframe_2=dataframe_2,
      dataframe_2_primary_key='ID',
      levenshtein_distance_filter=3,
      match_score_threshold=80,
      columns_to_compare=['Name', 'City'],
      match_methods=['Partial Token Set Ratio', 'Weighted Ratio']
  )
  ```



  The **ConvertOddsToProbability** function converts odds to probability in a new column.

  ```python

  from analysistoolbox.data_processing import ConvertOddsToProbability
  import pandas as pd


  data = {
      'Team': ['Team1', 'Team2', 'Team3', 'Team4'],
      'Odds': [2.5, 1.5, 3.0, np.nan]
  }
  df = pd.DataFrame(data)


  print("Original DataFrame:")
  print(df)


  df = ConvertOddsToProbability(
      dataframe=df,
      odds_column='Odds'
  )
  ```



  The **CountMissingDataByGroup** function counts the number of records with missing data in a Pandas dataframe, grouped by specified columns.

  ```python

  from analysistoolbox.data_processing import CountMissingDataByGroup
  import pandas as pd
  import numpy as np


  data = {
      'Group': ['A', 'B', 'A', 'B', 'A', 'B'],
      'Value1': [1, 2, np.nan, 4, 5, np.nan],
      'Value2': [np.nan, 8, 9, 10, np.nan, 12]
  }
  df = pd.DataFrame(data)


  CountMissingDataByGroup(
      dataframe=df,
      list_of_grouping_columns=['Group']
  )
  ```



  The **CreateBinnedColumn** function creates a new column in a Pandas dataframe based on a numeric variable. Binning is a process of transforming continuous numerical variables into discrete categorical 'bins'.

  ```python

  from analysistoolbox.data_processing import CreateBinnedColumn
  import pandas as pd
  import numpy as np


  data = {
      'Group': ['A', 'B', 'A', 'B', 'A', 'B'],
      'Value1': [1, 2, 3, 4, 5, 6],
      'Value2': [7, 8, 9, 10, 11, 12]
  }
  df = pd.DataFrame(data)


  df_binned = CreateBinnedColumn(
      dataframe=df,
      numeric_column_name='Value1',
      number_of_bins=3,
      binning_strategy='uniform'
  )
  ```



  The **CreateDataOverview** function creates an overview of a Pandas dataframe, including the data type, missing count, missing percentage, and summary statistics for each variable in the DataFrame.

  ```python

  from analysistoolbox.data_processing import CreateDataOverview
  import pandas as pd
  import numpy as np


  data = {
      'Column1': [1, 2, 3, np.nan, 5, 6],
      'Column2': ['a', 'b', 'c', 'd', np.nan, 'f'],
      'Column3': [7.1, 8.2, 9.3, 10.4, np.nan, 12.5]
  }
  df = pd.DataFrame(data)


  CreateDataOverview(
      dataframe=df,
      plot_missingness=True
  )
  ```



  The **CreateRandomSampleGroups** function a takes a pandas DataFrame, shuffle its rows, assign each row to one of n groups, and then return the updated DataFrame with an additional column indicating the group number.

  ```python

  from analysistoolbox.data_processing import CreateRandomSampleGroups
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
      'Age': [25, 31, 35, 19, 45],
      'Score': [85, 95, 78, 81, 92]
  }
  df = pd.DataFrame(data)


  grouped_df = CreateRandomSampleGroups(
      dataframe=df,
      number_of_groups=2,
      random_seed=123
  )
  ```



  The **CreateRareCategoryColumn** function creates a new column in a Pandas dataframe that indicates whether a categorical variable value is rare. A rare category is a category that occurs less than a specified percentage of the time.

  ```python

  from analysistoolbox.data_processing import CreateRareCategoryColumn
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Alice', 'Bob', 'Alice'],
      'Age': [25, 31, 35, 19, 45, 23, 30, 24],
      'Score': [85, 95, 78, 81, 92, 88, 90, 86]
  }
  df = pd.DataFrame(data)


  updated_df = CreateRareCategoryColumn(
      dataframe=df,
      categorical_column_name='Name',
      rare_category_label='Rare',
      rare_category_threshold=0.05,
      new_column_suffix='(rare category)'
  )
  ```



  The **CreateStratifiedRandomSampleGroups** unction performs stratified random sampling on a pandas DataFrame. Stratified random sampling is a method of sampling that involves the division of a population into smaller groups known as strata. In stratified random sampling, the strata are formed based on members' shared attributes or characteristics.

  ```python

  from analysistoolbox.data_processing import CreateStratifiedRandomSampleGroups
  import numpy as np
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Alice', 'Bob', 'Alice'],
      'Age': [25, 31, 35, 19, 45, 23, 30, 24],
      'Score': [85, 95, 78, 81, 92, 88, 90, 86]
  }
  df = pd.DataFrame(data)


  stratified_df = CreateStratifiedRandomSampleGroups(
      dataframe=df,
      number_of_groups=2,
      list_categorical_column_names=['Name'],
      random_seed=42
  )
  ```



  The **ImputeMissingValuesUsingNearestNeighbors** function imputes missing values in a dataframe using the nearest neighbors method. For each sample with missing values, it finds the n_neighbors nearest neighbors in the training set and imputes the missing values using the mean value of these neighbors.

  ```python

  from analysistoolbox.data_processing import ImputeMissingValuesUsingNearestNeighbors
  import pandas as pd
  import numpy as np


  data = {
      'A': [1, 2, np.nan, 4, 5],
      'B': [np.nan, 2, 3, 4, 5],
      'C': [1, 2, 3, np.nan, 5],
      'D': [1, 2, 3, 4, np.nan]
  }
  df = pd.DataFrame(data)


  imputed_df = ImputeMissingValuesUsingNearestNeighbors(
      dataframe=df,
      list_of_numeric_columns_to_impute=['A', 'B', 'C', 'D'],
      number_of_neighbors=2,
      averaging_method='uniform'
  )
  ```



  The **VerifyGranularity** function checks the granularity of a given dataframe based on a list of key columns. Granularity in this context refers to the level of detail or summarization in a set of data.

  ```python

  from analysistoolbox.data_processing import VerifyGranularity
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Alice', 'Bob', 'Alice'],
      'Age': [25, 31, 35, 19, 45, 23, 30, 24],
      'Score': [85, 95, 78, 81, 92, 88, 90, 86]
  }
  df = pd.DataFrame(data)


  VerifyGranularity(
      dataframe=df,
      list_of_key_columns=['Name', 'Age'],
      set_key_as_index=True,
      print_as_markdown=False
  )
  ```



  There are several functions in the Descriptive Analytics submodule. The following is a list of the functions:

  * ConductManifoldLearning
  * ConductPrincipalComponentAnalysis
  * CreateAssociationRules
  * CreateGaussianMixtureClusters
  * CreateHierarchicalClusters
  * CreateKMeansClusters
  * GenerateEDAWithLIDA



  The **ConductManifoldLearning** function performs manifold learning on a given dataframe and returns a new dataframe with the original columns and the new manifold learning components. Manifold learning is a type of unsupervised learning that is used to reduce the dimensionality of the data.

  ```python

  from analysistoolbox.descriptive_analytics import ConductManifoldLearning
  import pandas as pd
  from sklearn.datasets import load_iris


  iris = load_iris()
  iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  new_df = ConductManifoldLearning(
      dataframe=iris_df,
      list_of_numeric_columns=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_components=2,
      random_seed=42,
      show_component_summary_plots=True,
      summary_plot_size=(10, 10)
  )
  ```



  The **ConductPrincipalComponentAnalysis** function performs Principal Component Analysis (PCA) on a given dataframe. PCA is a technique used in machine learning to reduce the dimensionality of data while retaining as much information as possible.

  ```python

  from analysistoolbox.descriptive_analytics import ConductManifoldLearning
  import pandas as pd
  from sklearn.datasets import load_iris


  iris = load_iris()
  iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  result = ConductPrincipalComponentAnalysis(
      dataframe=iris_df,
      list_of_numeric_columns=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_components=2
  )
  ```



  The **CreateAssociationRules** function creates association rules from a given dataframe. Association rules are widely used in market basket analysis, where the goal is to find associations and/or correlations among a set of items.

  ```python

  from analysistoolbox.descriptive_analytics import CreateAssociationRules
  import pandas as pd


  result = CreateAssociationRules(
      dataframe=df,
      transaction_id_column='TransactionID',
      items_column='Item',
      support_threshold=0.01,
      confidence_threshold=0.2,
      plot_lift=True,
      plot_title='Association Rules',
      plot_size=(10, 7)
  )
  ```



  The **CreateGaussianMixtureClusters** function creates Gaussian mixture clusters from a given dataframe. Gaussian mixture models are a type of unsupervised learning that is used to find clusters in data. It adds the resulting clusters as a new column in the dataframe, and also calculates the probability of each data point belonging to each cluster.

  ```python

  from analysistoolbox.descriptive_analytics import CreateGaussianMixtureClusters
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()


  df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                    columns= iris['feature_names'] + ['target'])


  df_clustered = CreateGaussianMixtureClusters(
      dataframe=df,
      list_of_numeric_columns_for_clustering=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_clusters=3,
      column_name_for_clusters='Gaussian Mixture Cluster',
      scale_predictor_variables=True,
      show_cluster_summary_plots=True,
      sns_color_palette='Set2',
      summary_plot_size=(15, 15),
      random_seed=123,
      maximum_iterations=200
  )
  ```



  The **CreateHierarchicalClusters** function creates hierarchical clusters from a given dataframe. Hierarchical clustering is a type of unsupervised learning that is used to find clusters in data. It adds the resulting clusters as a new column in the dataframe.

  ```python

  from analysistoolbox.descriptive_analytics import CreateHierarchicalClusters
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  df_clustered = CreateHierarchicalClusters(
      dataframe=df,
      list_of_value_columns_for_clustering=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_clusters=3,
      column_name_for_clusters='Hierarchical Cluster',
      scale_predictor_variables=True,
      show_cluster_summary_plots=True,
      color_palette='Set2',
      summary_plot_size=(6, 4),
      random_seed=412,
      maximum_iterations=300
  )
  ```



  The **CreateKMeansClusters** function performs K-Means clustering on a given dataset and returns the dataset with an additional column indicating the cluster each record belongs to.

  ```python

  from analysistoolbox.descriptive_analytics import CreateKMeansClusters
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  df_clustered = CreateKMeansClusters(
      dataframe=df,
      list_of_value_columns_for_clustering=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_clusters=3,
      column_name_for_clusters='K-Means Cluster',
      scale_predictor_variables=True,
      show_cluster_summary_plots=True,
      color_palette='Set2',
      summary_plot_size=(6, 4),
      random_seed=412,
      maximum_iterations=300
  )
  ```



  The **GenerateEDAWithLIDA** function uses the LIDA package from Microsoft to generate exploratory data analysis (EDA) goals.

  ```python

  from analysistoolbox.descriptive_analytics import GenerateEDAWithLIDA
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  df_summary = GenerateEDAWithLIDA(
      dataframe=df,
      llm_api_key="your_llm_api_key_here",
      llm_provider="openai",
      llm_model="gpt-3.5-turbo",
      visualization_library="seaborn",
      goal_temperature=0.50,
      code_generation_temperature=0.05,
      data_summary_method="llm",
      number_of_samples_to_show_in_summary=5,
      return_data_fields_summary=True,
      number_of_goals_to_generate=5,
      plot_recommended_visualization=True,
      show_code_for_recommended_visualization=True
  )
  ```

















  To report an issue, request a feature, or contribute to the project, please see the [CONTRIBUTING.md](CONTRIBUTING.md) file (in progress).



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


pkgId: 53e23f5838aa474361594de345991611ddd2bb2267e9be96ec66b44507be0b15
name: python-analysistoolbox
arch: src
version: 2.1.6
epoch: 0
release: 1
url: https://github.com/KyleProtho/AnalysisToolBox/tree/master/analysistoolbox
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analysistoolbox-2.1.6-1.src.rpm
checksum_type: sha256
summary:
  A collection tools in Python for data collection and processing, statistics, analytics, and intelligence analysis.

description:
  Analysis Tool Box (i.e. "analysistoolbox") is a collection of tools in Python for data collection and processing, statisitics, analytics, and intelligence analysis.



  To install the package, run the following command in the root directory of the project:

  ```bash
  pip install analysistoolbox
  ```

  Visualizations are created using the matplotlib and seaborn libraries. While you can select whichever seaborn style you'd like, the following Seaborn style tends to get the best looking plots:

  ```python
  sns.set(
      style="white",
      font="Arial",
      context="paper"
  )
  ```



  There are many modules in the analysistoolbox package, each with their own functions. The following is a list of the modules:

  * Calculus
  * Data collection
  * Data processing
  * Descriptive analytics
  * File management
  * Hypothesis testing
  * Linear algebra
  * Predictive analytics
  * Statistics
  * Visualizations



  There are several functions in the Calculus submodule. The following is a list of the functions:

  * FindDerivative
  * FindLimitOfFunction
  * FindMinimumSquareLoss
  * PlotFunction



  The **FindDerivative** function calculates the derivative of a given function. It uses the sympy library, a Python library for symbolic mathematics, to perform the differentiation. The function also has the capability to print the original function and its derivative, return the derivative function, and plot both the original function and its derivative.

  ```python

  from analysistoolbox.calculus import FindDerivative
  import sympy


  x = sympy.symbols('x')


  f_of_x = x**3 + 2*x**2 + 3*x + 4


  FindDerivative(
      f_of_x,
      print_functions=True,
      return_derivative_function=True,
      plot_functions=True
  )
  ```



  The **FindLimitOfFunction** function finds the limit of a function at a specific point and optionally plot the function and its tangent line at that point. The script uses the matplotlib and numpy libraries for plotting and numerical operations respectively.

  ```python

  from analysistoolbox.calculus import FindLimitOfFunction
  import numpy as np
  import sympy


  x = sympy.symbols('x')


  f_of_x = np.sin(x) / x


  FindLimitOfFunction(
      f_of_x,
      point=0,
      step=0.01,
      plot_function=True,
      x_minimum=-10,
      x_maximum=10,
      n=1000,
      tangent_line_window=1
  )
  ```



  The **FindMinimumSquareLoss** function calculates the minimum square loss between observed and predicted values. This function is often used in machine learning and statistics to measure the average squared difference between the actual and predicted outcomes.

  ```python

  from analysistoolbox.calculus import FindMinimumSquareLoss


  observed_values = [1, 2, 3, 4, 5]
  predicted_values = [1.1, 1.9, 3.2, 3.7, 5.1]


  minimum_square_loss = FindMinimumSquareLoss(
      observed_values,
      predicted_values,
      show_plot=True
  )


  print(f"The minimum square loss is: {minimum_square_loss}")
  ```



  The **PlotFunction** function plots a mathematical function of x. It takes a lambda function as input and allows for customization of the plot.

  ```python

  from analysistoolbox.calculus import PlotFunction
  import sympy


  x = sympy.symbols('x')


  f_of_x = lambda x: x**2


  PlotFunction(f_of_x)
  ```



  There are several functions in the Data Collection submodule. The following is a list of the functions:

  * ExtractTextFromPDF
  * FetchPDFFromURL
  * FetchUSShapefile
  * FetchWebsiteText
  * GetCompanyFilings
  * GetGoogleSearchResults
  * GetZipFile



  The **ExtractTextFromPDF** function extracts text from a PDF file, cleans it, then saves it to a text file.

  ```python

  from analysistoolbox.data_collection import ExtractTextFromPDF


  ExtractTextFromPDF(
      filepath_to_pdf="/path/to/your/input.pdf",
      filepath_for_exported_text="/path/to/your/output.txt",
      start_page=1,
      end_page=None
  )
  ```



  The **FetchPDFFromURL** function downloads a PDF file from a URL and saves it to a specified location.

  ```python

  from analysistoolbox.data_collection import FetchPDFFromURL


  FetchPDFFromURL(
      url="https://example.com/sample.pdf",
      filename="C:/folder/sample.pdf"
  )
  ```



  The **FetchUSShapefile** function fetches a geographical shapefile from the TIGER database of the U.S. Census Bureau.

  ```python

  from analysistoolbox.data_collection import FetchUSShapefile


  shapefile = FetchUSShapefile(
      state='PA',
      county='Allegheny',
      geography='tract',
      census_year=2021
  )


  print(shapefile.head())
  ```



  The **FetchWebsiteText** function fetches the text from a website and saves it to a text file.

  ```python

  from analysistoolbox.data_collection import FetchWebsiteText


  text = FetchWebsiteText(
      url="https://www.example.com",
      browserless_api_key="your_browserless_api_key"
  )


  print(text)
  ```



  The **GetCompanyFilings** function fetches company filings from the SEC EDGAR database. It returns a list of filings for a given company CIK (Central Index Key) and filing type.

  ```python

  from analysistoolbox.data_collection import GetCompanyFilings


  results = GetCompanyFilings(
          search_keywords="Online Dating",
          start_date="2024-01-01",
          end_date="2024-12-31",
          filing_type="all",
      )


  print(results)
  ```



  The **GetGoogleSearchResults** function fetches Google search results for a given query using the Serper API.

  ```python

  from analysistoolbox.data_collection import GetGoogleSearchResults



  results = GetGoogleSearchResults(
      query="Python programming",
      serper_api_key='your_serper_api_key',
      number_of_results=5,
      apply_autocorrect=True,
      display_results=True
  )


  print(results)
  ```



  The **GetZipFile** function downloads a zip file from a url and saves it to a specified folder. It can also unzip the file and print the contents of the zip file.

  ```python

  from analysistoolbox.data_collection import GetZipFile


  GetZipFile(
      url="http://example.com/file.zip",
      path_to_save_folder="/path/to/save/folder"
  )
  ```



  There are several functions in the Data Processing submodule. The following is a list of the functions:

  * AddDateNumberColumns
  * AddLeadingZeros
  * AddRowCountColumn
  * AddTPeriodColumn
  * AddTukeyOutlierColumn
  * CleanTextColumns
  * ConductAnomalyDetection
  * ConductEntityMatching
  * ConvertOddsToProbability
  * CountMissingDataByGroup
  * CreateBinnedColumn
  * CreateDataOverview
  * CreateRandomSampleGroups
  * CreateRareCategoryColumn
  * CreateStratifiedRandomSampleGroups
  * ImputeMissingValuesUsingNearestNeighbors
  * VerifyGranularity



  The **AddDateNumberColumns** function adds columns for the year, month, quarter, week, day of the month, and day of the week to a dataframe.

  ```python

  from analysistoolbox.data_processing import AddDateNumberColumns
  from datetime import datetime
  import pandas as pd


  data = {'Date': [datetime(2020, 1, 1), datetime(2020, 2, 1), datetime(2020, 3, 1), datetime(2020, 4, 1)]}
  df = pd.DataFrame(data)


  df = AddDateNumberColumns(
      dataframe=df,
      date_column_name='Date'
  )


  print(df)
  ```



  The **AddLeadingZeros** function adds leading zeros to a column. If fixed_length is not specified, the longest string in the column is used as the fixed length. If add_as_new_column is set to True, the new column is added to the dataframe. Otherwise, the original column is updated.

  ```python

  from analysistoolbox.data_processing import AddLeadingZeros
  import pandas as pd


  data = {'ID': [1, 23, 456, 7890]}
  df = pd.DataFrame(data)


  df = AddLeadingZeros(
      dataframe=df,
      column_name='ID',
      add_as_new_column=True
  )


  print(df)
  ```



  The **AddRowCountColumn** function adds a column to a dataframe that contains the row number for each row, based on a group (or groups) of columns. The function can also sort the dataframe by a column or columns before adding the row count column.

  ```python

  from analysistoolbox.data_processing import AddRowCountColumn
  import pandas as pd


  data = {
      'Payment Method': ['Check', 'Credit Card', 'Check', 'Credit Card', 'Check', 'Credit Card', 'Check', 'Credit Card'],
      'Transaction Value': [100, 200, 300, 400, 500, 600, 700, 800],
      'Transaction Order': [1, 2, 3, 4, 5, 6, 7, 8]
  }
  df = pd.DataFrame(data)


  df_updated = AddRowCountColumn(
      dataframe=df,
      list_of_grouping_variables=['Payment Method'],
      list_of_order_columns=['Transaction Order'],
      list_of_ascending_order_args=[True]
  )


  print(df_updated)
  ```



  The **AddTPeriodColumn** function adds a T-period column to a dataframe. The T-period column is the number of intervals (e.g., days or weeks) since the earliest date in the dataframe.

  ```python

  from analysistoolbox.data_processing import AddTPeriodColumn
  from datetime import datetime
  import pandas as pd


  data = {
      'date': pd.date_range(start='1/1/2020', end='1/10/2020'),
      'value': range(1, 11)
  }
  df = pd.DataFrame(data)


  df_updated = AddTPeriodColumn(
      dataframe=df,
      date_column_name='date',
      t_period_interval='days'
  )


  print(df_updated)
  ```



  The **AddTukeyOutlierColumn** function adds a column to a dataframe that indicates whether a value is an outlier. The function uses the Tukey method to identify outliers.

  ```python

  from analysistoolbox.data_processing import AddTukeyOutlierColumn
  import pandas as pd


  data = pd.DataFrame({'values': [1, 2, 3, 4, 5, 6, 7, 8, 9, 20]})


  df_updated = AddTukeyOutlierColumn(
      dataframe=data,
      value_column_name='values',
      tukey_boundary_multiplier=1.5,
      plot_tukey_outliers=True
  )


  print(df_updated)
  ```



  The **CleanTextColumns** function cleans string-type columns in a pandas DataFrame by removing all leading and trailing spaces.

  ```python

  from analysistoolbox.data_processing import CleanTextColumns
  import pandas as pd


  df = pd.DataFrame({
      'A': [' hello', 'world ', ' python '],
      'B': [1, 2, 3],
  })


  df_clean = CleanTextColumns(df)
  ```



  The **ConductAnomalyDetection** function performs anomaly detection on a given dataset using the z-score method.

  ```python

  from analysistoolbox.data_processing import ConductAnomalyDetection
  import pandas as pd


  df = pd.DataFrame({
      'A': [1, 2, 3, 1000],
      'B': [4, 5, 6, 2000],
  })


  df_anomaly_detected = ConductAnomalyDetection(
      dataframe=df,
      list_of_columns_to_analyze=['A', 'B']
  )


  print(df_anomaly_detected)
  ```



  The **ConductEntityMatching** function performs entity matching between two dataframes using various fuzzy matching algorithms.

  ```python
  from analysistoolbox.data_processing import ConductEntityMatching
  import pandas as pd


  dataframe_1 = pd.DataFrame({
      'ID': ['1', '2', '3'],
      'Name': ['John Doe', 'Jane Smith', 'Bob Johnson'],
      'City': ['New York', 'Los Angeles', 'Chicago']
  })

  dataframe_2 = pd.DataFrame({
      'ID': ['a', 'b', 'c'],
      'Name': ['Jon Doe', 'Jane Smyth', 'Robert Johnson'],
      'City': ['NYC', 'LA', 'Chicago']
  })


  matched_entities = ConductEntityMatching(
      dataframe_1=dataframe_1,
      dataframe_1_primary_key='ID',
      dataframe_2=dataframe_2,
      dataframe_2_primary_key='ID',
      levenshtein_distance_filter=3,
      match_score_threshold=80,
      columns_to_compare=['Name', 'City'],
      match_methods=['Partial Token Set Ratio', 'Weighted Ratio']
  )
  ```



  The **ConvertOddsToProbability** function converts odds to probability in a new column.

  ```python

  from analysistoolbox.data_processing import ConvertOddsToProbability
  import pandas as pd


  data = {
      'Team': ['Team1', 'Team2', 'Team3', 'Team4'],
      'Odds': [2.5, 1.5, 3.0, np.nan]
  }
  df = pd.DataFrame(data)


  print("Original DataFrame:")
  print(df)


  df = ConvertOddsToProbability(
      dataframe=df,
      odds_column='Odds'
  )
  ```



  The **CountMissingDataByGroup** function counts the number of records with missing data in a Pandas dataframe, grouped by specified columns.

  ```python

  from analysistoolbox.data_processing import CountMissingDataByGroup
  import pandas as pd
  import numpy as np


  data = {
      'Group': ['A', 'B', 'A', 'B', 'A', 'B'],
      'Value1': [1, 2, np.nan, 4, 5, np.nan],
      'Value2': [np.nan, 8, 9, 10, np.nan, 12]
  }
  df = pd.DataFrame(data)


  CountMissingDataByGroup(
      dataframe=df,
      list_of_grouping_columns=['Group']
  )
  ```



  The **CreateBinnedColumn** function creates a new column in a Pandas dataframe based on a numeric variable. Binning is a process of transforming continuous numerical variables into discrete categorical 'bins'.

  ```python

  from analysistoolbox.data_processing import CreateBinnedColumn
  import pandas as pd
  import numpy as np


  data = {
      'Group': ['A', 'B', 'A', 'B', 'A', 'B'],
      'Value1': [1, 2, 3, 4, 5, 6],
      'Value2': [7, 8, 9, 10, 11, 12]
  }
  df = pd.DataFrame(data)


  df_binned = CreateBinnedColumn(
      dataframe=df,
      numeric_column_name='Value1',
      number_of_bins=3,
      binning_strategy='uniform'
  )
  ```



  The **CreateDataOverview** function creates an overview of a Pandas dataframe, including the data type, missing count, missing percentage, and summary statistics for each variable in the DataFrame.

  ```python

  from analysistoolbox.data_processing import CreateDataOverview
  import pandas as pd
  import numpy as np


  data = {
      'Column1': [1, 2, 3, np.nan, 5, 6],
      'Column2': ['a', 'b', 'c', 'd', np.nan, 'f'],
      'Column3': [7.1, 8.2, 9.3, 10.4, np.nan, 12.5]
  }
  df = pd.DataFrame(data)


  CreateDataOverview(
      dataframe=df,
      plot_missingness=True
  )
  ```



  The **CreateRandomSampleGroups** function a takes a pandas DataFrame, shuffle its rows, assign each row to one of n groups, and then return the updated DataFrame with an additional column indicating the group number.

  ```python

  from analysistoolbox.data_processing import CreateRandomSampleGroups
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
      'Age': [25, 31, 35, 19, 45],
      'Score': [85, 95, 78, 81, 92]
  }
  df = pd.DataFrame(data)


  grouped_df = CreateRandomSampleGroups(
      dataframe=df,
      number_of_groups=2,
      random_seed=123
  )
  ```



  The **CreateRareCategoryColumn** function creates a new column in a Pandas dataframe that indicates whether a categorical variable value is rare. A rare category is a category that occurs less than a specified percentage of the time.

  ```python

  from analysistoolbox.data_processing import CreateRareCategoryColumn
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Alice', 'Bob', 'Alice'],
      'Age': [25, 31, 35, 19, 45, 23, 30, 24],
      'Score': [85, 95, 78, 81, 92, 88, 90, 86]
  }
  df = pd.DataFrame(data)


  updated_df = CreateRareCategoryColumn(
      dataframe=df,
      categorical_column_name='Name',
      rare_category_label='Rare',
      rare_category_threshold=0.05,
      new_column_suffix='(rare category)'
  )
  ```



  The **CreateStratifiedRandomSampleGroups** unction performs stratified random sampling on a pandas DataFrame. Stratified random sampling is a method of sampling that involves the division of a population into smaller groups known as strata. In stratified random sampling, the strata are formed based on members' shared attributes or characteristics.

  ```python

  from analysistoolbox.data_processing import CreateStratifiedRandomSampleGroups
  import numpy as np
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Alice', 'Bob', 'Alice'],
      'Age': [25, 31, 35, 19, 45, 23, 30, 24],
      'Score': [85, 95, 78, 81, 92, 88, 90, 86]
  }
  df = pd.DataFrame(data)


  stratified_df = CreateStratifiedRandomSampleGroups(
      dataframe=df,
      number_of_groups=2,
      list_categorical_column_names=['Name'],
      random_seed=42
  )
  ```



  The **ImputeMissingValuesUsingNearestNeighbors** function imputes missing values in a dataframe using the nearest neighbors method. For each sample with missing values, it finds the n_neighbors nearest neighbors in the training set and imputes the missing values using the mean value of these neighbors.

  ```python

  from analysistoolbox.data_processing import ImputeMissingValuesUsingNearestNeighbors
  import pandas as pd
  import numpy as np


  data = {
      'A': [1, 2, np.nan, 4, 5],
      'B': [np.nan, 2, 3, 4, 5],
      'C': [1, 2, 3, np.nan, 5],
      'D': [1, 2, 3, 4, np.nan]
  }
  df = pd.DataFrame(data)


  imputed_df = ImputeMissingValuesUsingNearestNeighbors(
      dataframe=df,
      list_of_numeric_columns_to_impute=['A', 'B', 'C', 'D'],
      number_of_neighbors=2,
      averaging_method='uniform'
  )
  ```



  The **VerifyGranularity** function checks the granularity of a given dataframe based on a list of key columns. Granularity in this context refers to the level of detail or summarization in a set of data.

  ```python

  from analysistoolbox.data_processing import VerifyGranularity
  import pandas as pd


  data = {
      'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Alice', 'Bob', 'Alice'],
      'Age': [25, 31, 35, 19, 45, 23, 30, 24],
      'Score': [85, 95, 78, 81, 92, 88, 90, 86]
  }
  df = pd.DataFrame(data)


  VerifyGranularity(
      dataframe=df,
      list_of_key_columns=['Name', 'Age'],
      set_key_as_index=True,
      print_as_markdown=False
  )
  ```



  There are several functions in the Descriptive Analytics submodule. The following is a list of the functions:

  * ConductManifoldLearning
  * ConductPrincipalComponentAnalysis
  * CreateAssociationRules
  * CreateGaussianMixtureClusters
  * CreateHierarchicalClusters
  * CreateKMeansClusters
  * GenerateEDAWithLIDA



  The **ConductManifoldLearning** function performs manifold learning on a given dataframe and returns a new dataframe with the original columns and the new manifold learning components. Manifold learning is a type of unsupervised learning that is used to reduce the dimensionality of the data.

  ```python

  from analysistoolbox.descriptive_analytics import ConductManifoldLearning
  import pandas as pd
  from sklearn.datasets import load_iris


  iris = load_iris()
  iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  new_df = ConductManifoldLearning(
      dataframe=iris_df,
      list_of_numeric_columns=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_components=2,
      random_seed=42,
      show_component_summary_plots=True,
      summary_plot_size=(10, 10)
  )
  ```



  The **ConductPrincipalComponentAnalysis** function performs Principal Component Analysis (PCA) on a given dataframe. PCA is a technique used in machine learning to reduce the dimensionality of data while retaining as much information as possible.

  ```python

  from analysistoolbox.descriptive_analytics import ConductManifoldLearning
  import pandas as pd
  from sklearn.datasets import load_iris


  iris = load_iris()
  iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  result = ConductPrincipalComponentAnalysis(
      dataframe=iris_df,
      list_of_numeric_columns=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_components=2
  )
  ```



  The **CreateAssociationRules** function creates association rules from a given dataframe. Association rules are widely used in market basket analysis, where the goal is to find associations and/or correlations among a set of items.

  ```python

  from analysistoolbox.descriptive_analytics import CreateAssociationRules
  import pandas as pd


  result = CreateAssociationRules(
      dataframe=df,
      transaction_id_column='TransactionID',
      items_column='Item',
      support_threshold=0.01,
      confidence_threshold=0.2,
      plot_lift=True,
      plot_title='Association Rules',
      plot_size=(10, 7)
  )
  ```



  The **CreateGaussianMixtureClusters** function creates Gaussian mixture clusters from a given dataframe. Gaussian mixture models are a type of unsupervised learning that is used to find clusters in data. It adds the resulting clusters as a new column in the dataframe, and also calculates the probability of each data point belonging to each cluster.

  ```python

  from analysistoolbox.descriptive_analytics import CreateGaussianMixtureClusters
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()


  df = pd.DataFrame(data= np.c_[iris['data'], iris['target']],
                    columns= iris['feature_names'] + ['target'])


  df_clustered = CreateGaussianMixtureClusters(
      dataframe=df,
      list_of_numeric_columns_for_clustering=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_clusters=3,
      column_name_for_clusters='Gaussian Mixture Cluster',
      scale_predictor_variables=True,
      show_cluster_summary_plots=True,
      sns_color_palette='Set2',
      summary_plot_size=(15, 15),
      random_seed=123,
      maximum_iterations=200
  )
  ```



  The **CreateHierarchicalClusters** function creates hierarchical clusters from a given dataframe. Hierarchical clustering is a type of unsupervised learning that is used to find clusters in data. It adds the resulting clusters as a new column in the dataframe.

  ```python

  from analysistoolbox.descriptive_analytics import CreateHierarchicalClusters
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  df_clustered = CreateHierarchicalClusters(
      dataframe=df,
      list_of_value_columns_for_clustering=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_clusters=3,
      column_name_for_clusters='Hierarchical Cluster',
      scale_predictor_variables=True,
      show_cluster_summary_plots=True,
      color_palette='Set2',
      summary_plot_size=(6, 4),
      random_seed=412,
      maximum_iterations=300
  )
  ```



  The **CreateKMeansClusters** function performs K-Means clustering on a given dataset and returns the dataset with an additional column indicating the cluster each record belongs to.

  ```python

  from analysistoolbox.descriptive_analytics import CreateKMeansClusters
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  df_clustered = CreateKMeansClusters(
      dataframe=df,
      list_of_value_columns_for_clustering=['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
      number_of_clusters=3,
      column_name_for_clusters='K-Means Cluster',
      scale_predictor_variables=True,
      show_cluster_summary_plots=True,
      color_palette='Set2',
      summary_plot_size=(6, 4),
      random_seed=412,
      maximum_iterations=300
  )
  ```



  The **GenerateEDAWithLIDA** function uses the LIDA package from Microsoft to generate exploratory data analysis (EDA) goals.

  ```python

  from analysistoolbox.descriptive_analytics import GenerateEDAWithLIDA
  import pandas as pd
  from sklearn import datasets


  iris = datasets.load_iris()
  df = pd.DataFrame(data=iris.data, columns=iris.feature_names)


  df_summary = GenerateEDAWithLIDA(
      dataframe=df,
      llm_api_key="your_llm_api_key_here",
      llm_provider="openai",
      llm_model="gpt-3.5-turbo",
      visualization_library="seaborn",
      goal_temperature=0.50,
      code_generation_temperature=0.05,
      data_summary_method="llm",
      number_of_samples_to_show_in_summary=5,
      return_data_fields_summary=True,
      number_of_goals_to_generate=5,
      plot_recommended_visualization=True,
      show_code_for_recommended_visualization=True
  )
  ```

















  To report an issue, request a feature, or contribute to the project, please see the [CONTRIBUTING.md](CONTRIBUTING.md) file (in progress).



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


pkgId: cfef52f5e2b05c5bfd35fc2fdf3da2a079556e091488fc4aaf0534f280e4f82a
name: python-analytic-workspace-client
arch: src
version: 1.31.0
epoch: 0
release: 1
summary: Библиотека для подключения к Analytic Workspace
url: https://analyticworkspace.ru/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analytic-workspace-client-1.31.0-1.src.rpm
checksum_type: sha256
description:
  Перейдите по ссылке https://aw.example.ru/data-master/get-token (вместо https://aw.example.ru/ укажите адрес вашего сервера Analytic Workspace).

  Значение токена лучше всего сохранить в отдельном файл или поместить в переменную окружения `AW_DATA_TOKEN`.



  ```python
  from aw_client import Session


  with open('aw_token', 'rt') as f:
      aw_token = f.read()

  session = Session(token=aw_token, aw_url='https://aw.example.ru')




  df = session.load(model_id=123)  # df: pandas.DataFrame

  display(df)
  ```


pkgId: 75f4b18706de8fba5945bfedc09af4280f9ded59d86f50ff0494d8d98b9e2d0b
name: python-analytics-mayhem-adobe
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: Manage Adobe Analytics Reports API v2 requests to build reports programmatically.
url: https://github.com/konosp/adobe-analytics-reports-api-v2.0
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analytics-mayhem-adobe-0.0.10-1.src.rpm
checksum_type: sha256
description:
  Download Reports data utilising the Adobe.io version 2.0 API.

  ![](https://github.com/konosp/adobe-analytics-reports-api-v2.0/workflows/Package%20Testing/badge.svg)

  For more Digital Analytics related reading, check https://analyticsmayhem.com


  1. JWT
  2. OAuth (tested only through Jupyter Notebook!)


  In order to run the package, first you need to gain access to a service account from Adobe.io. The method used is JWT authentication. More instructions on how to create the integration at: https://www.adobe.io/authentication/auth-methods.html#!AdobeDocs/adobeio-auth/master/JWT/JWT.md. After you have completed the integration, you will need to have available the following information:
  - Organization ID (issuer): It is in the format of < organisation id >@AdobeOrg
  - Technical Account ID: < tech account id >@techacct.adobe.com
  - Client ID: Information is available on the completion of the Service Account integration
  - Client Secret: Information is available on the completion of the Service Account integration
  - Account ID: Instructions on how to obtain it at https://youtu.be/lrg1MuVi0Fo?t=96
  - Report suite: Report suite ID from which you want to download the data.

  Make sure that the integration is associated with an Adobe Analytics product profile that is granted access to the necessary metrics and dimensions.


  To perform an OAuth authentication you need to create an integration at the Adobe I/O Console as described in the guide by Adobe at https://github.com/AdobeDocs/analytics-2.0-apis/blob/master/create-oauth-client.md. The result of the integration provides the following information:
  - Client ID (API Key)
  - Client Secret


  ```
  pip install analytics-mayhem-adobe
  ```




  After you have configured the integration and downloaded the package, the following setup is needed:
  ```
  from analytics.mayhem.adobe import analytics_client
  import os

  ADOBE_ORG_ID = os.environ['ADOBE_ORG_ID']
  SUBJECT_ACCOUNT = os.environ['SUBJECT_ACCOUNT']
  CLIENT_ID = os.environ['CLIENT_ID']
  CLIENT_SECRET = os.environ['CLIENT_SECRET']
  PRIVATE_KEY_LOCATION = os.environ['PRIVATE_KEY_LOCATION']
  GLOBAL_COMPANY_ID = os.environ['GLOBAL_COMPANY_ID']
  REPORT_SUITE_ID = os.environ['REPORT_SUITE_ID']
  ```
  Next initialise the Adobe client:
  ```
  aa = analytics_client(
          adobe_org_id = ADOBE_ORG_ID,
          subject_account = SUBJECT_ACCOUNT,
          client_id = CLIENT_ID,
          client_secret = CLIENT_SECRET,
          account_id = GLOBAL_COMPANY_ID,
          private_key_location = PRIVATE_KEY_LOCATION
  )

  aa.set_report_suite(report_suite_id = REPORT_SUITE_ID)
  ```


  Import the package and initiate the required parameters
  ```
  from analytics.mayhem.adobe import analytics_client

  client_id = '<client id>'
  client_secret = '<client secret>'
  global_company_id = '<global company id>'
  ```
  Initialise the Adobe client:
  ```
  aa = analytics_client(
          auth_client_id = client_id,
          client_secret = client_secret,
          account_id = global_company_id
  )
  ```
  Perform the authentication
  ```
  aa._authenticate()
  ```
  This will open a new window and will request you to login to Adobe. After you complete the login process, you will be redirect to the URL you configured as redirect URI during the Adobe Integration creation process. If everything is done correctly, final URL will have a URL query string parameter in the format of `www.adobe.com/?code=eyJ....`. Copy the full URL and paste it in the input text.
  For a demo notebook, please refer to the [Jupyter Notebook - OAuth example](examples/OAuth%20Demo.ipynb)



  Set the date range of the report (format: YYYY-MM-DD)
  ```
  aa.set_date_range(date_start = '2019-12-01', date_end= '2019-12-31')
  ```
  To configure specific hours for the start and end date:
  ```
  aa.set_date_range(date_start='2020-12-01', date_end='2020-12-01', hour_start= 4, hour_end= 5 )
  ```
  If `hour_end` is set, then only up to that hour in the last day data will be retrieved instead of the full day.

  ```
  aa.add_metric(metric_name= 'metrics/visits')
  aa.add_metric(metric_name= 'metrics/orders')
  aa.add_metric(metric_name= 'metrics/event1')
  aa.add_dimension(dimension_name = 'variables/mobiledevicetype')
  data = aa.get_report()
  ```
  Output:

  |itemId_lvl_1   |  value_lvl_1 | metrics/visits | metrics/orders | metrics/event1
  | --- | --- | --- | --- | --- |
  |         0     |      Other    |  5000    |    3    | 100
  |  1728229488   |       Tablet  |     200   |   45    |  30
  |  2163986270   | Mobile Phone  |    49   |    23   |  31
  |  ...    | ...  |       ...   |        ...   |      ...


  ```
  aa.add_metric(metric_name= 'metrics/visits')
  aa.add_metric(metric_name= 'metrics/orders')
  aa.add_metric(metric_name= 'metrics/event1')
  aa.add_dimension(dimension_name = 'variables/mobiledevicetype')
  aa.add_dimension(dimension_name = 'variables/lasttouchchannel')
  data = aa.get_report_multiple_breakdowns()
  ```
  Output:
  Each item in level 1 (i.e. Tablet) is broken down by the dimension in level 2 (i.e. Last Touch Channel). The package downloads all possible combinations. In a similar fashion more dimensions can be added.

  | itemId_lvl_1 | value_lvl_1 | itemId_lvl_2 |  value_lvl_2 | metrics/visits | metrics/orders  | metrics/event1 |
  | --- | --- | --- | --- | --- | --- | --- |
  |0 |Other |1 |Paid Search| 233| 39|10 |
  |0 |Other |2 |Natural Search| 424| 12  |412 |
  |0 |Other |3 |Display| 840| 41  |31 |
  | ... | ... | ... | ... | ... | ... | ... |
  | 1728229488 |Tablet |1 | Paid Search| 80| 12  |41 |
  | 1728229488 |Tablet |2 |Natural Search| 50| 41  |21 |
  | ... | ... | ... | ... | ... | ... | ... |


  To add a segment, you need the segment ID (currently only this option is supported). To obtain the ID, you need to activate the Adobe Analytics Workspace debugger (https://github.com/AdobeDocs/analytics-2.0-apis/blob/master/reporting-tricks.md). Then inspect the JSON request window and locate the segment ID under the 'globalFilters' object.

  To apply the segment:
  ```
  aa.add_global_segment(segment_id = "s1689_5ea0ca222b1c1747636dc970")
  ```

  https://github.com/konosp/adobe-analytics-reports-api-v2.0/issues

  Known missing features:
  - No support for filtering
  - No support for custom sorting


pkgId: c9f4eab17762ea817728f618d01d88ba04bb92b222a35c2766b097feeb68c28a
name: python-analytics-python
arch: src
version: 1.4.post1
epoch: 0
release: 1
summary: The hassle-free way to integrate analytics into any python application.
url: https://github.com/segmentio/analytics-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analytics-python-1.4.post1-1.src.rpm
checksum_type: sha256
description:
  This library was renamed due to a naming conflict with an official python library.
  Please use the new listing at https://pypi.org/project/segment-analytics-python/

  Segment is the simplest way to integrate analytics into your application.
  One API allows you to turn on any other analytics service. No more learning
  new APIs, repeated code, and wasted development time.

  This is the official python client that wraps the Segment REST API (https://segment.com).

  Documentation and more details at https://github.com/segmentio/analytics-python


pkgId: 752557fe571d63a65f4cf15645349b989634f228cd58f6819b5c9fefe5d0c030
name: python-analytix
arch: src
version: 5.3.0
epoch: 0
release: 1
summary: A simple yet powerful SDK for the YouTube Analytics API.
url: https://github.com/parafoxia/analytix
rpm_license: BSD 3-Clause 'New' or 'Revised' License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analytix-5.3.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img alt="analytix logo" src="https://raw.githubusercontent.com/parafoxia/analytix/main/assets/logo.png" width="400px">
  <br /><br />
  A simple yet powerful SDK for the YouTube Analytics API.
  <br /><br />
  <a href="https://pypi.python.org/pypi/analytix"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/analytix"></a>
  <a href="https://pypi.python.org/pypi/analytix"><img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/analytix"></a>
  <a href="https://pypi.python.org/pypi/analytix"><img alt="PyPI - Implementation" src="https://img.shields.io/pypi/implementation/analytix"></a>
  <a href="https://pepy.tech/project/analytix"><img alt="Downloads" src="https://static.pepy.tech/badge/analytix"></a>
  <br />
  <a href="https://github.com/parafoxia/analytix"><img alt="GitHub Workflow Status (CI)" src="https://img.shields.io/github/actions/workflow/status/parafoxia/analytix/ci.yml"></a>
  <a href="https://parafoxia.github.io/analytix"><img alt="GitHub Workflow Status (Publish Docs)" src="https://img.shields.io/github/actions/workflow/status/parafoxia/analytix/publish-docs.yml?label=docs"></a>
  <a href="https://github.com/parafoxia/analytix"><img alt="Code Climate coverage" src="https://img.shields.io/codeclimate/coverage/parafoxia/analytix"></a>
  <a href="https://github.com/parafoxia/analytix"><img alt="Code Climate maintainability" src="https://img.shields.io/codeclimate/maintainability/parafoxia/analytix"></a>
  <hr />
  </div>



  * Pythonic syntax lets you feel right at home
  * Dynamic error handling saves hours of troubleshooting and makes sure only valid requests count toward your API quota
  * A clever interface allows you to make multiple requests across multiple sessions without reauthorising
  * Extra support enables you to export reports in a variety of filetypes and to a number of DataFrame formats
  * Easy enough for beginners, but powerful enough for advanced users





  To install the latest stable version of analytix, use the following command:

  ```sh
  pip install analytix
  ```

  You can also install the latest development version using the following command:

  ```sh
  pip install git+https://github.com/parafoxia/analytix
  ```

  You may need to prefix these commands with a call to the Python interpreter depending on your OS and Python configuration.



  Below is a list of analytix's dependencies.
  Note that the minimum version assumes you're using CPython 3.8.
  The latest versions of each library are always supported.

  | Name              | Min. version | Required? | Usage                                                         |
  |-------------------|--------------|-----------|---------------------------------------------------------------|
  | `urllib3`         | 2.2.0        | Yes       | Making HTTP requests                                          |
  | `jwt`             | 1.2.0        | No        | Decoding JWT ID tokens (from v5.1)                            |
  | `openpyxl`        | 3.0.0        | No        | Exporting report data to Excel spreadsheets                   |
  | `pandas`          | ~1.3.0       | No        | Exporting report data to pandas DataFrames                    |
  | `polars`          | 0.15.17      | No        | Exporting report data to Polars DataFrames                    |
  | `pyarrow`         | ~5.0.0       | No        | Exporting report data to Apache Arrow tables and file formats |



  All requests to the YouTube Analytics API need to be authorised through OAuth 2.
  In order to do this, you will need a Google Developers project with the YouTube Analytics API enabled.
  You can find instructions on how to do that in the [API setup guide](https://parafoxia.github.io/analytix/starting/googleapp/).

  Once a project is set up, analytix handles authorisation — including token refreshing — for you.

  More details regarding how and when refresh tokens expire can be found on the [Google Identity documentation](https://developers.google.com/identity/protocols/oauth2#expiration).





  The following example creates a CSV file containing basic info for the 10 most viewed videos, from most to least viewed, in the US in 2022:

  ```py
  from datetime import date

  from analytix import Client

  client = Client("secrets.json")
  report = client.fetch_report(
      dimensions=("video",),
      filters={"country": "US"},
      metrics=("estimatedMinutesWatched", "views", "likes", "comments"),
      sort_options=("-estimatedMinutesWatched",),
      start_date=date(2022, 1, 1),
      end_date=date(2022, 12, 31),
      max_results=10,
  )
  report.to_csv("analytics.csv")
  ```

  If you want to analyse this data using additional tools such as *pandas*, you can directly export the report as a DataFrame or table using the `to_pandas()`, `to_arrow()`, and `to_polars()` methods of the report instance.
  You can also save the report as a `.tsv`, `.json`, `.xlsx`, `.parquet`, or `.feather` file.

  There are more examples in the [GitHub repository](https://github.com/parafoxia/analytix/tree/main/examples).



  You can also fetch groups and group items:

  ```py
  from analytix import Client


  with Client("secrets.json") as client:
      groups = client.fetch_groups()
      group_items = client.fetch_group_items(groups[0].id)
  ```



  If you want to see what analytix is doing, you can enable the packaged logger:

  ```py
  import analytix

  analytix.enable_logging()
  ```

  This defaults to showing all log messages of level INFO and above.
  To show more (or less) messages, pass a logging level as an argument.



  CPython versions 3.8 through 3.12 and PyPy versions 3.9 and 3.10 are officially supported\*.
  CPython 3.13-dev is provisionally supported\*.
  Windows, MacOS, and Linux are all supported.

  *For base analytix functionality; support cannot be guaranteed for functionality requiring external libraries.



  Contributions are very much welcome! To get started:

  * Familiarise yourself with the [code of conduct](https://github.com/parafoxia/analytix/blob/main/CODE_OF_CONDUCT.md)
  * Have a look at the [contributing guide](https://github.com/parafoxia/analytix/blob/main/CONTRIBUTING.md)



  The analytix module for Python is licensed under the [BSD 3-Clause License](https://github.com/parafoxia/analytix/blob/main/LICENSE).


pkgId: a23e935eca1d24abcf5bed05f1aa4e07e71f8bd80ecb849075d8c614b3677841
name: python-analyzere
arch: src
version: 0.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/analyzere/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analyzere-0.8-1.src.rpm
checksum_type: sha256
description:
  This is a Python wrapper for a Analyze Re REST API. It allows you to easily
  utilize the PRIME Re platform in your applications.


pkgId: db75f95d2082ffb8f95031fbaa1c7a10924a82067e1c12b8d99f9f67f35f06d1
name: python-analyzr-sdk-python
arch: src
version: 1.3.76
epoch: 0
release: 1
summary: Python SDK for Analyzr API
url: https://github.com/analyzr-ai/analyzr-sdk-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-analyzr-sdk-python-1.3.76-1.src.rpm
checksum_type: sha256
description:
  This Python client will give you access to the Analyzr API. See files in the `examples` folder
  for examples showing how to use the client. Note that a `client_id` should always be provided when querying the API; it is used for reporting purposes.
  * For general information please see https://analyzr.ai.
  * For help and support see https://help.analyzr.ai.
  * For SDK reference documentation see  https://analyzr-sdk-python.readthedocs.io.


  Getting the client set up will require the following:

  1. Install the latest version of the client on your local machine:
  ```
  pip install analyzr-sdk-python
  ```

  2. Get an API username and password from your Analyzr admin (you may need SSO credentials from your local admin instead).

  3. Confirm you are able to connect to the API, and check the API version
  as follows from a Python session:
  ```
  >>> from analyzrclient import Analyzer
  >>> analyzer = Analyzer(host="<your host>")
  >>> analyzer.login()
  Login successful
  >>> Analyzer().version()
  {'status': 200, 'response': {'version': 'x.x.xxx', 'tenant': <your tenant name>, 'copyright': '2024 (c) Go2Market Insights Inc. All rights reserved.'}}
  ```


  If you are developing the SDK and would like to test the repo, clone it locally using git then
  run the following from the root directory:
  ```
  python -m unittest tests.test_all -v   # all tests
  python -m unittest tests.test_quick -v # quick tests
  ```
  Make sure you update the `config.json` file first to include the name of your API tenant.
  To run a single test case do:
  ```
  python -m unittest tests.test_all.PropensityTest.test_logistic_regression_classifier -v
  ```


pkgId: 30d417caa85a804f059324adb3402fa40434f0c843c849413defa51ab53d9c83
name: python-anam-python-sdk
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: An unofficial package to interact with Anam's Avatar engine.
url: https://www.anam.ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anam-python-sdk-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Welcome to the Anam Python SDK! This SDK provides tools for creating and managing virtual personas using the AnamLab platform.



  - Create and manage virtual personas
  - Interact with the AnamLab platform
  - Customize persona behaviors and responses



  To install the Anam Python SDK, use:

  ```bash
  pip install anam-python-sdk
  ```

  or

  ```bash
  poetry add anam-python-sdk
  ```





  - Python 3.7 or higher
  - pip (Python package installer)



  1. Create a `.env` file in your project root directory.
  2. Add your API credentials to the `.env` file:

  ```bash
  ANAM_API_KEY=<your_api_key>
  ```


  Here's a simple example of how to use the AnamClient:

  ```python
  from anam_python_sdk.api.client import AnamClient
  from dotenv import dotenv_values


  api_cfg = dotenv_values(".env")


  client = AnamClient(cfg=api_cfg)


  persona_presets = client.get_persona_presets()
  print("Persona Presets:", persona_presets)


  personas = client.get_personas()
  print("Personas:", personas)
  ```



  For more detailed information on using the SDK, check out the [User Guide](docs/user-guide/creating-personas.md).



  For comprehensive documentation, please refer to the following sections:

  1. [Getting Started](docs/getting-started.md)
  2. [User Guide](docs/user-guide/creating-personas.md)
  3. [API Reference](docs/api-reference/model.md)
  4. [Examples](docs/examples.md)



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


pkgId: 5f170f22660b63d72999fdaa95080e40c3272ccc0ccbdc4f3a0d684e0f05be12
name: python-ananke-causal
arch: src
version: 0.5.0
epoch: 0
release: 1
url: https://gitlab.com/causal/ananke
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ananke-causal-0.5.0-1.src.rpm
checksum_type: sha256
summary:
  Ananke, named for the Greek primordial goddess of necessity and causality, is a python package for causal inference using the language of graphical models.

description:
  Visit the [website](https://ananke.readthedocs.io) to find out more.

  [Ananke](https://en.wikipedia.org/wiki/Ananke), named for the Greek
  primordial goddess of necessity and causality, is a python package for
  causal inference using the language of graphical models



  * Rohit Bhattacharya
  * Jaron Lee
  * Razieh Nabi
  * Preethi Prakash
  * Ranjani Srinivasan

  Interested contributors should check out the [CONTRIBUTING.md](CONTRIBUTING.md) for further details.



  If graph visualization is not required then install via `pip`:

  ```
  pip install ananke-causal
  ```

  Alternatively, the package may be installed from gitlab by cloning and `cd` into the directory. Then, `poetry` (see https://python-poetry.org) can be used to install:

  ```
  poetry install
  ```




  If graphing support is required, it is necessary to install [graphviz](https://www.graphviz.org/download/).



  Ubuntu:
  ```shell script
  sudo apt install graphviz libgraphviz-dev pkg-config
  ```

  Mac ([Homebrew](https://brew.sh/)):
  ```shell script
  brew install graphviz
  ```

  Fedora:
  ```shell script
  sudo yum install graphviz
  ```

  Once graphviz has been installed, then:

  ```shell script
  pip install ananke-causal[viz] # if pip is preferred

  poetry install --extras viz # if poetry is preferred
  ```



  If on M1 see this [issue](https://github.com/pygraphviz/pygraphviz/issues/398). The fix is to run the following before installing:
  ```shell script
  brew install graphviz
  python -m pip install \
      --global-option=build_ext \
      --global-option="-I$(brew --prefix graphviz)/include/" \
      --global-option="-L$(brew --prefix graphviz)/lib/" \
      pygraphviz
  ```


pkgId: 8b4d0170f72671298c2ed26861211cc267f74204463915a56682c5d9d6651989
name: python-anansescanpy
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: implementation of scANANSE for scanpy objects in Python
url: https://github.com/Arts-of-coding/AnanseScanpy
rpm_license: apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anansescanpy-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/anansescanpy/badges/version.svg)](https://anaconda.org/bioconda/anansescanpy)
  [![PyPI version](https://badge.fury.io/py/anansescanpy.svg)](https://badge.fury.io/py/anansescanpy)
  [![install with bioconda](https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg?style=flat)](http://bioconda.github.io/recipes/anansescanpy/README.html)
  [![Anaconda-Server Badge](https://anaconda.org/bioconda/anansescanpy/badges/downloads.svg)](https://anaconda.org/bioconda/anansescanpy)
  [![Maintainability](https://api.codeclimate.com/v1/badges/04272eaade7b247b4af2/maintainability)](https://codeclimate.com/github/Arts-of-coding/AnanseScanpy/maintainability)




  The most straightforward way to install the most recent version of AnanseScanpy is via conda using PyPI.


  If you have not used Bioconda before, first set up the necessary channels (in this order!).
  You only have to do this once.
  ```
  $ conda config --add channels defaults
  $ conda config --add channels bioconda
  $ conda config --add channels conda-forge
  ```

  Then install AnanseScanpy with:
  ```
  $ conda install anansescanpy
  ```


  ```
  $ pip install anansescanpy
  ```


  ```
  $ git clone https://github.com/Arts-of-coding/AnanseScanpy.git
  $ cd AnanseScanpy
  $ conda env create -f requirements.yaml
  $ conda activate AnanseScanpy
  $ pip install -e .
  ```


  ```
  $ pip install jupyter
  ```




  ```
  $ python3
  ```


  ```
  $ jupyter notebook
  ```



  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7446267.svg)](https://doi.org/10.5281/zenodo.7446267)
  ```
  $ wget https://zenodo.org/record/7446267/files/rna_PBMC.h5ad -O scANANSE/rna_PBMC.h5ad
  $ wget https://zenodo.org/record/7446267/files/atac_PBMC.h5ad -O scANANSE/atac_PBMC.h5ad
  ```



  Follow the instructions its respective github page, https://github.com/vanheeringen-lab/anansnake
  Next automatically use the generated files to run GRN analysis using your single cell cluster data:


  ```{bash eval=FALSE}
  snakemake --use-conda --conda-frontend mamba \
  --configfile scANANSE/analysis/config.yaml \
  --snakefile scANANSE/anansnake/Snakefile \
  --resources mem_mb=48_000 --cores 12
  ```



  * Jos Smits and his Seurat equivalent of this package https://github.com/JGASmits/AnanseSeurat
  * Siebren Frohlich and his anansnake implementation https://github.com/vanheeringen-lab/anansnake


pkgId: 079c54abe001be1f1b6b6e6519209a615317906c4b6d6cd838c9815cafd87d2c
name: python-anaplan
arch: src
version: 1.5.1
epoch: 0
release: 1
url: https://pypi.org/project/anaplan/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaplan-1.5.1-1.src.rpm
checksum_type: sha256
summary:
  learner function have new parameters: 'show_current_activations' and learner functions 'strategy' parameter have new options: 'f1', 'precision', 'recall', 'all'. For more details read learner functions doc string.: https://github.com/HCB06/Anaplan/blob/main/Welcome_to_Anaplan/ANAPLAN_USER_MANUEL_AND_LEGAL_INFORMATION(EN).pdf.


pkgId: 0acb7327eae0dc3de6b5df06a0099c9f01a047e6c3547511646968308013d71b
name: python-anaplan-sdk
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Provides pythonic access to the Anaplan API
url: https://vinzenzklass.github.io/anaplan-sdk/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaplan-sdk-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Anaplan SDK is an independent, unofficial project providing pythonic access to
  the [Anaplan Integration API v2](https://anaplan.docs.apiary.io/). This Project aims to provide high-level abstractions
  over the API, so you can deal with python objects and simple functions rather than implementation details like HTTP
  Requests, Authentication, JSON Parsing, Compression, Chunking and so on.
  This Projects supports
  the [Bulk API](https://help.anaplan.com/use-the-bulk-apis-93218e5e-00e5-406e-8361-09ab861889a7),
  the [Transactional API](https://help.anaplan.com/use-the-transactional-apis-cc1c1e91-39fc-4272-a4b5-16bc91e9c313) and
  the [ALM API](https://help.anaplan.com/application-lifecycle-management-api-2565cfa6-e0c2-4e24-884e-d0df957184d6),
  providing both synchronous and asynchronous Clients.


pkgId: f1d21868708dbb0c9298f57dae3151c77d71c25f20ff9649f0d4be051ca31133
name: python-anaplanConnector
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Python package to manage integrations with Anaplan.
url: https://github.com/matt-budd/anaplan-connector
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaplanConnector-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This is a simple Anaplan connector intended to be used as a quick and easy way to mainly integrate with Anaplan using Python. This package does not include all API options. It uses the main calls to push data to anaplan via files, call a process, and export data.


  The method of pushing data to Anaplan is common in the data warehousing space. Instead of pushing data in a transaction api (i.e. record by record), Anaplan utilizes a bulk data API which includes pushing delimitted files to a file location, and then copying the file into an Anaplan database. This is similar to Postgres and Snowflake's `COPY INTO` command.

  <!-- ## Pushing Data Into Anaplan Overview
  Before getting to the code, the high-level steps to pushing data into Anaplan is as follows:
  1. Source the source data (e.g. ERP data) into a csv file
  2. Use the csv file to manually import the data into Anaplan. This will create a "file" reference and fileId within Anaplan.
  3. Obtain the fileId using this connector.
  4. With the file and Anaplan fileID, push the file to Anaplan.
  5. Create a process in Anaplan that includes the required actions for the data.
  6. Obtain the processId using this connector.
  7. Run the processId with this connector.

  **Notes:**
  - I intentially built the connector to only use processes and not the actions directly. It is my belief that it is best practice to use processes since it is much easier to expand the actions within Anaplan than to manage the processes within Python.





  `from anaplanConnector import Connection`


  1. Basic authentication
  ```
  anaplan = Connection(authType='basic',email='email@example.com',password='SecurePassword',workspaceId='anaplanWorkspaceID',modelId='AnaplanModelID')
  ```
  2. Certificate authentication
  ```
  anaplan = Connection(authType='certificate', privateCertPath='./AnaplanPrivateKey.pem', publicCertPath='./AnaplanPublicKey.pem', workspaceId='anaplanWorkspaceID', modelId='AnaplanModelID')
  ```

  There are two auth types: "basic" and "certificate". If basic is supplied, then the fields "email" and "password" are required. If "certificate" is supplied, then the fields "privateCertPath" and "publicCertPath" are required.



  1. Change the ids directly:

      `anaplan.workspaceId = 'NewWorkspaceId'`

      `anpalan.modelId = 'NewModelId'`
  2. Make new initialization of the connector:
  ```
  anaplanModel1 = Connection(email='email@example.com',password='SecurePassword',workspaceId='anaplanWorkspaceID',modelId='AnaplanModelID')

  anaplanModel2 = Connection(email='email@example.com',password='SecurePassword',workspaceId='anaplanWorkspaceID2',modelId='AnaplanModelID2')
  ```


  `workspaces = anaplan.getWorkspaces()`


  `models = anaplan.getModels()`


  `files = anaplan.getFiles()`


  `fileId = anaplan.getFileIdByFilename(filename)`


  `anaplan.loadFile(filepath,fileId)`

  filepath = The local location and filename of the file to load (e.g. '/home/fileToLoad.csv')

  fileId = The Anaplan file ID which can be found by running one of the above commands


  `processes = anaplan.getProcesses()`


  `processId = anaplan.getProcessIdByName(processName)`


  `anaplan.runProcess(processId)`


  `exports = anaplan.getExports()`


  `exportId = anaplan.getExportIdByName(exportName)`


  `anaplan.export(exportId, filepath)`

  exportId = is Anaplan's Export ID that can be found with the above commands

  filepath = is the location and filename of where you want to save the file (e.g. '/home/export.csv')

  encoding (optional) = is the character encoding of the export file (default is utf-8)




  ```
  from anaplanConnector import Connection

  anaplan = Connection(authType='basic',email='email@example.com',password='SecurePassword',workspaceId='anaplanWorkspaceID',modelId='AnaplanModelID')

  filepath = '/tmp/dataToLoad.csv'

  anaplan.loadFile(filepath,anaplan.getFileIdByFilename('ExampleFile.csv'))

  anaplan.runProcess(anaplan.getProcessIdByName('Import Data'))
  ```


  ```
  from anaplanConnector import Connection

  anaplan = Connection(authType='basic',email='email@example.com',password='SecurePassword',workspaceId='anaplanWorkspaceID',modelId='AnaplanModelID')

  filepath = '/tmp/LocalExportedData.csv'

  anaplan.export(anaplan.getExportIdByName('ExportedData.csv'), filepath)
  ```

  1. Script to create the public and private pem keys from the .p12 file.


pkgId: a103fc652d071974276c5755ddd7c74823aa23756067af3611cac7af9fd1d44b
name: python-anarcute
arch: src
version: 0.1.996.4
epoch: 0
release: 1
summary: My hy toolbox
url: https://github.com/user/reponame
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anarcute-0.1.996.4-1.src.rpm
checksum_type: sha256
description:
  My toolbox for dynamic programming




  from anarcute import *

  import requests, json

  sentence="Eat more of those french fries and drink cola"

  alice=requests.get("https://gist.githubusercontent.com/phillipj/4944029/raw/75ba2243dd5ec2875f629bf5d79f6c1e4b5a8b46/alice_in_wonderland.txt").text

  print(tf_idf(sentence,alice))

  >> {'eat': 168.7962962962963, 'more': 62.006802721088434, 'of': 5.9111543450064845, 'those': 303.8333333333333, 'french': 759.5833333333333, 'and': 3.4843272171253816, 'drink': 434.047619047619}



  filename="alice.json"

  vector=vectorize(alice)

  open(filename,"w+").write(json.dumps(vector))

  vector=json.load(open(filename,"r+"))

  print(tf_idf(sentence,vector))

  >>{'eat': 168.7962962962902, 'more': 62.00680272108618, 'of': 5.91115434500627, 'those': 303.8333333333223, 'french': 759.5833333333056, 'and': 3.484327217125255, 'drink': 434.0476190476033}





  print(sort_by_value(tf_idf(sentence,vector)))

  >>{'french': 759.5833333332979, 'drink': 434.04761904759886, 'those': 303.8333333333192, 'eat': 168.7962962962885, 'more': 62.006802721085556, 'of': 5.911154345006209, 'and': 3.4843272171252204}






  key="MY_GOOGLE_KEY"

  gt=GT(key)

  gt.translate("pl","en","Jeszcze Polska nie zginęła, Kiedy my żyjemy. Co nam obca przemoc wzięła, Szablą odbierzemy.")

  >> {'data': {'translations': [{'translatedText': 'Poland is not dead yet, When we live. What foreign violence has taken from us, we will take away the Saber.'}]}}

  cx="MY_CUSTOM_SEARCH_ENGINE_KEY"

  gs=GS(cx,key)

  gs.search("krakauer sausage recipe")

  >> dict with search result, up to 10 items

  gs.items("krakauer sausage recipe"")

  >> array of results, up to 100 items







  url="https://gist.githubusercontent.com/phillipj/4944029/raw/75ba2243dd5ec2875f629bf5d79f6c1e4b5a8b46/alice_in_wonderland.txt"

  alice=requests.get(url).text

  alice_reversed=mapp(lambda s: str(s[::-1]),alice.split('\n'))





  alice_reversed=mapp(lambda s: str(s[::-1]),alice.split('\n'),processes=2)



  @timeit

  def test(p=None):

      r=mapp(lambda s: math.factorial(150*len(s)),alice.split('\n'),processes=p)

      return None


  test()

  >> 'test' 2563.11 ms

  test(1)

  >> 'test' 5287.27 ms




  alice_special=filterp(lambda s: "alice" in s.lower(),alice.split('\n'))



  run(print,["A B C"])



  p=run(lambda x: request.get(x).text,url)

  some_other_stuff()

  p.join()



  r=mapp(apply,[lambda:requests.get("https://gist.githubusercontent.com/phillipj/4944029/raw/75ba2243dd5ec2875f629bf5d79f6c1e4b5a8b46/alice_in_wonderland.txt").text,lambda: math.factorial(9000)])





  a=["Some","important","array"]

  b=["Another","array"]

  in_or(a,b)

  >> True

  c=["Something", "Else"]

  in_or(a,c)

  >> False

  d="Some string"

  in_or(a,d)

  >> True


pkgId: 79b9dd21e1ee9e935ac0163a422ddbd5ea9cc1f2771ee3192186a1ff404857d4
name: python-anastasia-logging
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Anastasia Logging Standarization
url: https://pypi.org/project/anastasia-logging/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anastasia-logging-1.3.4-1.src.rpm
checksum_type: sha256
description:
  This repository holds a logging implementation wrapper for python scripts with standarized code notifications and additional features.



  1. About *logging* python library
  2. Enhancements and additional functionalities
      1. Log Output Standarization
      2. Predefined Parameters for AnastasiaLoggers from Environment Variables
      3. Code Tags Standarization
      4. Print Functionality
  3. Versioning



  This repository is based in python base log management library called [logging](https://docs.python.org/3/library/logging.html).

  Commonly, when this library is intended to be used, for a basic usage a simple logging import is recommended to be used in order to avoid additional settings in our internal scripts.

  ```
  import logging

  logging.warning("I am a very usefull warning")

  OUTPUT => WARNING:root:I am a very usefull warning
  ```

  But, for more complex repositories, is recommended to manage different loggers according to their necessities. For a customized logging behaviour, a Logger class must be declared from logging.

  ```
  import logging

  logger = logging.Logger("custom_logger")
  logger.warning("I am a very usefull warning")

  OUTPUT => I am a very usefull warning
  ```

  Have you noticed in the first import logging example that appears the word *root* in the output console? This is because when you use ```import logging``` directly, a default Logger class is instanciated with name *root* along with default configurations.

  This repository contains a class called **AnastasiaLogger**, which inherits from Logger class and standarize logging definitions and has some improvments over debugging (```.debug()```), information (```.info()```), warning (```.warning()```), error (```.error()```), critical (```.critical()```) and fatal (```.fatal()```) methods.

  ```
  from anastasia_logging import AnastasiaLogger

  logger = AnastasiaLogger()
  logger.warning("I am a very usefull warning")

  OUTPUT => 2023-05-08 10:39:17 UTC/GMT-0400 | [ANASTASIA-JOB] WARNING: I am a very usefull warning
  ```

  If a script already has a logging usage, it is possible to replace ```import logging``` with ```import anastasia_logging as logging``` and no modifications are required from the script side to work!

  ```
  import anastasia_logging as logging

  logging.warning("I am a very usefull warning")

  OUTPUT => 2023-05-08 10:39:17 UTC/GMT-0400 | [ANASTASIA-JOB] WARNING: I am a very usefull warning
  ```





  AnastasiaLogger has a common structure in order to show information, which is the following one:
  ```
  YYYY-MM-DD HR:MN:SS UTC/GMT(+-)HHMN | [TAG] LEVEL: message
  ```
  TAG is define by default as ANASTASIA-JOB (can be changed during class instantiation), and LEVEL is defined according to level method called.

  TAG is intended to differentiate responsabilities along scripts in other repositories.



  For a faster logging behaviour along an entire repository, some variables that AnastasiaLogger can recieve can be predefined as environment variables, which are:

  * ```ANASTASIA_LOG_NAME```: name identification of logger instance (default=```"anastasia-log"```)
  * ```ANASTASIA_LOG_TAG```: tag identification for job type for StreamHandlers (console) and FileHandlers (file) (default=```"ANASTASIA-JOB"```)
  * ```ANASTASIA_LOG_LEVEL```: define severity hierarchy for log generation (default=```"INFO"```)
  * ```ANASTASIA_LOG_SAVELOG```: generate ```.log``` file containing logs generated (default=```"0"``` (deactivated))
  * ```ANASTASIA_LOG_PATH```: define a custom name for log file (default=```"anastasia-log.log"```)

  If it is not the case, AnastasiaLogger will instanciate with default parameters.



  In order to have a common identification for upper level implementations, AnastasiaLogger holds a standarized code implementations according to different topics.

  The coding structure is the following one:

  | **Code** 	|         **Topic**      	|
  |:---------:|:-------------------------:|
  |     0    	|       Unindentified       |
  |    1XX   	|       Data related      	|
  |    2XX   	|   Mathematical related    |
  |    3XX   	|        AI related         |
  |    4XX   	|     Resources related 	|
  |    5XX   	| Operative System related 	|
  |    6XX   	|       API related         |
  |    7XX   	|       AWS related         |

  Methods ```debug()```, ```info()```, ```warning()```, ```error()```, ```critical()``` and ```fatal()``` can be declared with a code as parameter in order to extended log with a code description.

  ```
  import anastasia_logging as logging

  logging.warning("I am a dataset warning", 100)

  OUTPUT => 2023-05-08 11:55:27 UTC/GMT-0400 | [ANASTASIA-JOB] WARNING: <W100> I am a dataset warning
  ```

  If a code is already predefined and no message is introduced, a default message will appear according to code declared.



  For a easy visualization in console without interacting with an AnastasiaLogger, you can use ```print``` like a python built-in print call.

  ```
  import anastasia_logging as logging

  logging.print("Some prints to show")

  OUTPUT => 2023-05-08 11:55:27 UTC/GMT-0400 | [ANASTASIA-JOB] PRINT: Some prints to show
  ```





  * Fixes:

      * Fixed edge cases in ```ANASTASIA_LOG_LEVEL``` and ```ANASTASIA_LOG_PATH``` assiganation values



  * Fixes:

      * Fixed edge case of ```ANASTASIA_LOG_SAVELOG``` environment variable detection if value entered is not a digit



  * Fixes:

      * Fixed parameter assignation for ```ANASTASIA_LOG_SAVELOG``` environment variable



  * Fixes:

      * Default unindentified ```debug```, ```critical``` and ```fatal``` standard codes fixed



  * Features:

      * Functions ```critical```, ```fatal``` and ```debug``` incorporated



  * Features:

      * Function ```print``` incorporated
      * Functions ```info```, ```warning```, ```error``` and ```print``` can return the formatted message for further usage



  * Fixes:

      * Function ```basicConfig``` was skipping predefined structures with tags and log streamhandlers



  * Features:

      * Function ```basicConfig``` equivalent from logging implemented for root AnastasiaLogger



  * Features:

      * ```AnastasiaLogger``` Class abstraction
      * Standar code description definitions for ```INFO```, ```WARNING``` and ```ERROR```
      * Predefined ```AnastasiaLogger``` parameters loaded from environment variables


pkgId: dfa7faa1a4c90569eda46cf2e2909c7035b88a9daa87ccf9fd675168772b3edf
name: python-anasymod
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Tool for running mixed-signal emulations on FPGAs
url: https://github.com/sgherbst/anasymod
rpm_license: BSD 3-Clause "New" or "Revised" License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anasymod-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/sgherbst/anasymod/workflows/Regression/badge.svg)](https://github.com/sgherbst/anasymod/actions)
  [![BuildKite status](https://badge.buildkite.com/7f10348afca3b631bbbb2175919b9039101c2a5e55c3371460.svg?branch=master)](https://buildkite.com/stanford-aha/anasymod)
  [![Code Coverage](https://codecov.io/gh/sgherbst/anasymod/branch/master/graph/badge.svg)](https://codecov.io/gh/sgherbst/anasymod)
  [![License:BSD-3-Clause](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Join the chat at https://gitter.im/sgherbst/anasymod](https://badges.gitter.im/sgherbst/anasymod.svg)](https://gitter.im/sgherbst/anasymod?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  **anasymod** is a tool for running FPGA emulations of mixed-signal systems.  It supports digital blocks described with Verilog or VHDL and synthesizable analog models created using [msdsl](https://github.com/sgherbst/msdsl) and [svreal](https://github.com/sgherbst/svreal).





  ```shell
  > pip install anasymod
  ```

  If you get a permissions error when running one of the **pip** commands, you can try adding the **--user** flag to the **pip** command.  This will cause **pip** to install packages in your user directory rather than to a system-wide location.




  If you are a developer of **anasymod**, it is more convenient to clone and install the GitHub repository:

  ```shell
  > git clone https://github.com/sgherbst/anasymod.git
  > cd anasymod
  > pip install -e .
  ```



  Check to see if the **anasymod** command-line script is accessible by running:
  ```shell
  > anasymod -h
  ```

  If the **anasymod** script isn't found, then you'll have to add the directory containing it to the path.  On Windows, a typical location is **C:\\Python3\*\\Scripts**, while on Linux or macOS you might want to check **~/.local/bin** (particularly if you used the **--user** flag).



  The examples included with **anasymod** use [Icarus Verilog](http://iverilog.icarus.com) for running simulations, [Xilinx Vivado](https://www.xilinx.com/products/design-tools/vivado.html) for running synthesis and place-and-route, and [GTKWave](http://gtkwave.sourceforge.net) for viewing the simulation and emulation results.  The instructions for setting up these tools are included below for various platforms.



  Install Xilinx Vivado by going to the [downloads page](https://www.xilinx.com/support/download.html).  Scroll to the latest version of the "Full Product Installation", and download the Windows self-extracting web installer.  Launch the installer and follow the instructions.  You'll need a Xilinx account (free), and will have to select a license, although the free WebPACK license option is fine you're just planning to work with small FPGAs like the one on the Pynq-Z1 board.

  GTKwave and Icarus Verilog can be installed at the same time using the latest Icarus binary [here](http://bleyer.org/icarus/).



  Install Xilinx Vivado by going to the [downloads page](https://www.xilinx.com/support/download.html).  Scroll to the latest version of the "Full Product Installation", and download the Linux self-extracting web installer.  Then, in a terminal:

  ```shell
  > sudo ./Xilinx_Vivado_SDK_Web_*.bin
  ```

  A GUI will pop up and guide you through the rest of the installation.  Note that you'll need a Xilinx account (free), and that you can select the free WebPACK license option if you're planning to work with relatively small FPGAs like the one on the Pynq-Z1 board.

  Next, the Xilinx cable drivers must be installed ([AR #66440](https://www.xilinx.com/support/answers/66440.html)):
  ```shell
  > cd <YOUR_XILINX_INSTALL>/data/xicom/cable_drivers/lin(32|64)/install_script/install_drivers
  > sudo ./install_drivers
  ```

  Finally, some permissions cleanup is required ([AR #62240](https://www.xilinx.com/support/answers/62240.html))

  ```shell
  > cd ~/.Xilinx/Vivado
  > sudo chown -R $USER *
  > sudo chmod -R 777 *
  > sudo chgrp -R $USER *
  ```

  Installing GTKWave and Icarus Verilog is much simpler; just run the following in a terminal:
  ```shell
  > sudo apt-get install gtkwave iverilog
  ```



  The simulation part of this example should work if you install Icarus Verilog and GTKWave:

  ```shell
  > brew install icarus-verilog
  > brew install --cask gtkwave
  ```

  Unfortunately Xilinx Vivado does not run natively on macOS.  However, running Vivado on a Windows or Linux virtual machine on macOS does seem to work.



  From within the folder **unittests**, run

  ```shell
  > anasymod -i buck --models --sim --view
  ```

  This will generate a synthesizable model for a buck converter, run a simulation, and display the results.

  ![gtkwave_sim](https://user-images.githubusercontent.com/19254098/112363360-a538a980-8c92-11eb-84e2-aee73765e1c4.png)


  Here's a breakdown of what the options mean:
  * The **-i buck** option indicates that the folder ``buck`` contains the emulation files
  * **--models** means that **anasymod** should look for a file called **gen.py** and run it.  In this case the **gen.py** script uses [msdsl](https://git.io/msdsl) to generate a synthesizable model for the buck converter.
  * **--sim** means that a simulation should be run on the computer, rather than building the emulator bitstream.  This is helpful for debugging.  You can also pass the option **--simulator_name NAME** to specify which simulator should be used.  Currently supported simulators are **icarus**, **vivado**, and **xrun** (Cadence Xcelium),
  * **--view** means that the resuls should be displayed after running the simulation.  The viewer can be specified with the **--viewer_name NAME** option.  Only **gtkwave** is supported at the moment.  When a file called **view.gtkw** is in the folder with emulator sources, **anasymod** will load it to configure the GTKWave display.  You can generate your own **view.gtkw** file using ``File`` → ``Write Save File`` in GTKWave.



  Looking into the ``buck`` folder, you'll notice there are a bunch of files.  Some have special meanings for the **anasymod** tool (i.e., if you have a file with one of these names, it **anasymod** will treat it in a certain way)
  *  ``gen.py``: Generates synthesizable emulation models.  **anasymod** expects to run this as a command-line script that has arguments ``-o`` (output directory) and ``-dt`` (fixed timestep).  **anasymod** fills those arguments based on user settings when it runs **gen.py**.
  * ``prj.yaml``: YAML file containing settings for the project, like the FPGA board to use, build options, emulator control infrastructure to use, etc.  In this case, one of the key options is **dt**, which indicates that each emulator cycle corresponds to a fixed timestep of 50 ns.
  * ``simctrl.yaml``: YAML file containing signals to probe.  The signals indicated will be probed for both simulation and emulation (in the latter case, using a Xilinx Integrated Logic Analyzer instance).  This file can also specify signals to be written and read in interactive tests.
  * ``tb.sv``: Top-level file for simulation and synthesis, representing a synthesizable testbench.

  **anasymod** has other special files (e.g., ``clks.yaml` for controlling clock generation), but they are not used in this example.



  At this point, we have run a simulation of the emulator design, but haven't built a bitstream of programmed the FPGA.  This section shows how to run those tasks.

  For this test to work as-is, you'll need a [Pynq-Z1](https://store.digilentinc.com/pynq-z1-python-productivity-for-zynq-7000-arm-fpga-soc/) board.  However, if you uncomment the ``board_name`` option in ``prj.yaml``, you can specify a different board; currently supported options are ``PYNQ_Z1``, ``ARTY_A7``, ``VC707``, ``ZC702``, ``ZC706``, ``ZCU102``, and ``ZCU106``.  We are always interested to add support for new boards, so please let us know if your board isn't listed here (feel free to file a GitHub Issue).

  Go to the folder **unittests** and run the following command.  It will take about 11 minutes to build the bitstream.
  ```shell
  > anasymod -i buck --models --build
  ```

  If you are using the Pynq-Z1 board, then please make sure it is set up correctly:
  1. Jumper JP4 should be set for "JTAG"
  2. Jumper "JP5" should be set for "USB"
  Then, plug the Pynq board into your computer using a micro USB cable.  Move the Pynq board power switch to "ON".

  Run the emulation and view the results with the following command:
  ```shell
  > anasymod -i buck --emulate --view
  ```

  ![gtkwave_emu](https://user-images.githubusercontent.com/19254098/112367656-707b2100-8c97-11eb-8496-3fcb9cfb3a6b.png)

  For now, there is a separate ``*.gtkw`` file used when viewing emulation results, which is ``view_fpga.gtkw``.



  The example considered so far used a fixed timestep, but for optimal emulator performance, some systems benefit from an event-driven approach, where various blocks make timestep requests, resulting in a variable timestep emulator.

  With **anasymod**, an emulation model can make a timestep request (``dt_req``), which is passed to an auto-generated time manager.  The time manager takes the minimum of all timestep requests, and passes the result (``emu_dt``) back to models that need that information.

  This system is configured through a file called ``clks.yaml``.  For an example, see ``unittests/multi_clock``, which represents a system where two independent oscillators are running at different frequencies, and each is making its own timestep requests.

  If you look in the top-level file (``tb.sv``), you'll see that there are two oscillator instances, ``osc_0`` and ``osc_1``.  These are referenced in ``clks.yaml``, which says that **anasymod** should wire up the timestep request from each (``dt_req``) as well as the emulator timestep (``emu_dt``).  It also connects up the emulator clock (``emu_clk``) and reset signals (``emu_rst``).

  This brings us to a point about postprocessing: when you run a simulation or emulation, the raw data produced is dumped to a folder called ``raw_results``, and includes a timestamp at each emulation cycle.  To make the results easier to visualize, **anasymod** post-processes the raw data, applying timestamps to all signals.  The post-processed result is placed in a folder called ``vcd``; that waveform is what is displayed when you invoke the **--view** option.  However, for debugging timestep issues, it can be useful to examine the ``raw_results`` folder, too.



  The same ``clks.yaml`` file also handles the generation of new clock signals.  **anasymod** automatically generates an emulator clock signal, but typically there are one or more "real" clocks in the design that need to be generated as well.

  This takes some care to avoid timing issues, and the strategy taken by **anasymod** is to make sure the rising and falling edges of all generated clocks are aligned to a rising edge of the emulator clock.  For a block that wants to generate a new clock signal, it produces a clock request (``gated_clk_req``) in the preceding emulator cycle, like a clock enable signal, and **anasymod** passes the generated clock signal (``gated_clk``) back to the block.  The generated clock is properly aligned and routed through FPGA clock infrastructure to ensure good performance.

  You can see an example of this configuration by examing the ``clk_0`` and ``clk_1`` entries in ``clks.yaml`` of the ``multi_clock`` example: the oscillator models each produce a clock request, and each clock request is used to generate one clock signal.



  Rather than writing tests entirely in RTL, or controlling tests entirely from a host computer, it is often a good compromise to use firmware running on the FPGA to receive commands from the host computer and implement them at a lower level when interacting with the code in ``tb.sv``.

  For FPGAs that contain a Processing System (PS), **anasymod** automates much of this process by automatically instantiating the PS and generating firmware to interact with it.  An example can be seen in ``unittests/custom_firmware``, where user code, written in ``main.c`` invokes ``GET`` and ``SET`` commands from the auto-generated``gpio_funcs.h`` header.

  The signals to be set up for reading and writing are specified in ``simctrl.yaml``, just as they would be for VIO-based control.  However, the ``fpga_sim_ctrl`` setting in ``prj.yaml`` indicates that VIO control should not be used, and that the FPGA should instead using PS firmware to interact with the DUT.

  By default, **anasymod** will generate a ``main.c`` file, but if you want to use your own, as in this example, set ``custom_zynq_firmware`` to ``True`` in ``prj.yaml``, and then specify the location of the ``main.c`` file in ``source.yaml`` (under ``firmware_files``).



  It's often important to be able to interact with the emulator from Python while it is running, is order to steer the high-level direction of the tests.  This is supported through the ``Analysis`` object provided by the **anasymod** Python package, which provides a programmatic way to access all of the features of the command-line **anasymod** tool.

  As an example, consider the example in ``unittests/rc``, which is an RC filter whose input and output are accessible for interactive testing (as specifed in its ``simctrl.yaml`` file).

  With the **anasymod** programmatic interface, it's possible to build a bitstream, program the FPGA, and interact with the emulator with a fairly small number of lines of code:

  ```python
  from anasymod.analysis import Analysis
  ana = Analysis('path/to/rc')
  ana.set_target('fpga')
  ana.build()  # build bitstream
  ctrl = ana.launch()  # program FPGA
  ctrl.stall_emu()
  ctrl.set_param(name='v_in', value=1.0)
  ctrl.set_reset(1)
  ctrl.set_reset(0)
  for _ in range(25):
      ctrl.refresh_param('vio_0_i')
      v_out = ctrl.get_param('v_out')
      t = ctrl.get_emu_time()
      print(f't: {t}, v_out: {v_out}')
      ctrl.sleep_emu(0.1e-6)
  ```

  In real-world use, it's unlikely that you would want to rebuild the FPGA bitstream before every emulation run, but we have have included the command here just for reference.  As long as the FPGA bitstream is built, you could comment out that line, and everything should still work.

  This example illustrates how **anasymod** provides commands for interacting with emulator time (``stall_emu``, ``get_emu_time``, ``sleep``), as well as reading/writing emulator values (``set_param``, ``get_param``).  Emulator I/O works for both digital values and analog values; in the analog case, it automatically converts real numbers to the format being used by the emulator.



  To improve the quality of the software, users are encouraged to share modifications, enhancements or bug fixes with Infineon Technologies AG under Gabriel.Rutsch@infineon.com.


pkgId: 30971fcbc06a073f7b527c40a52c39f19358ba1e77616615308c9abc7e03bd85
name: python-anasyspythontools
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A suite of Python tools for use with Analysis Studio AFM-IR files.
url: https://github.com/GeorgRamer/anasys-python-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anasyspythontools-0.5.1-1.src.rpm
checksum_type: sha256
description:
  Please note that this package is currently beta. Things may break unexpectedly. Most functions writing to Analysis Studio format have been disabled so I don't see how this package could break your existing data anymore.


pkgId: 7862b10b49e3a35dc41a4da505a758b5f6543d1a06b8add0100faf462921f591
name: python-anatools
arch: src
version: 3.4.9
epoch: 0
release: 1
summary: Tools for development with the Rendered.ai Platform.
url: https://rendered.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anatools-3.4.9-1.src.rpm
checksum_type: sha256
description:
  `anatools` is an SDK for connecting to the Rendered.ai Platform.
  With `anatools` you can generate and access synthetic datasets, and much more!

  ```python
  >>> import anatools
  >>> ana = anatools.client()
  'Enter your credentials for the Rendered.ai Platform.'
  'email:' example@rendered.ai
  'password:' ***************
  >>> channels = ana.get_channels()
  >>> graphs = ana.get_staged_graphs()
  >>> datasets = ana.get_datasets()
  ```

  <br />



  1. Install conda for your operating system: https://www.anaconda.com/products/individual.
  2. Create a new conda environment and activate it.
  3. Install anatools from the Python Package Index.

  ```sh
  $ conda create -n renderedai python=3.7
  $ conda activate renderedai
  ```


  1. Install AnaTools from the Python Package Index.

  ```sh
  $ pip install anatools
  ```


  The anatools package requires python 3.6 or higher and has dependencies on the following packages:

  | Package | Description |
  |-|-|
  | docker | A python library for the Docker Engine API. |
  | numpy | A python library used for array-based processing. |
  | pillow | A fork of the Python Image Library. |
  | pyyaml | A python YAML parser and emitter. |
  | requests | A simple HTTP python library. |

  If you have any questions or comments, contact Rendered.AI at info@rendered.ai.

  <br />




  Execute the python command line, create a client and login to Rendered.ai.
  In this example we are instantiating a client with no workspace or environment variables, so it is setting our default workspace.
  To access the tool, you will need to use your email and password for https://deckard.rendered.ai.
  ```python
  >>> import anatools
  >>> ana = anatools.client()
  'Enter your credentials for the Rendered.ai Platform.'
  'email:' example@rendered.ai
  'password:' ***************
  ```


  You can generate as many API keys as you desire with custom expiration dates in order to bypass the email login. Create keys via your email login. To do this, run create_api_key and save the resulting output that is your new API Key. This will only be shown once.

  ```python
  ana.create_api_key(name='name', expires='mm-dd-yyyy', organizationId='OrgId') ​
  'apikey-12345...'
  ```

  This API Key can be used for future logins as demonstrated in the following two examples.



  ```python
  >>> import anatools
  >>> ana = anatools.client(APIKey='API KEY')
  Using provided APIKey to login
  ....
  ```


  ```python
  export RENDEREDAI_API_KEY=API_KEY
  python
  >>> import anatools
  >>> ana = anatools.client()
  Using environment RENDEREDAI_API_KEY key to login
  ....
  ```



  The Rendered.ai Platform is a synthetic dataset generation tool where graphs describe what and how synthetic datasets are generated.

  | Terms | Definitions |
  |-|-|
  | workspace | A workspace is a collection of data used for a particular use-case, for example workspaces can be used to organize data for different projects.
  | dataset | A dataset is a collection of data, for many use-cases these are images with text-based annotation files. |
  | graph | A graph is defined by nodes and links, it describes the what and the how a dataset is generated. |
  | node | A node can be described as an executable block of code, it has inputs and runs some algorithm to generate outputs. |
  | link | A link is used to transfer data from the output of one node, to the input of other nodes. |
  | channel | A channel is a collection of nodes, it is used to limit the scope of what is possible to generate in a dataset (like content from a tv channel). |


  The Rendered.ai Platform creates synthetic datasets by processing a graph, so we will need to create the client to connect to the Platform API, create a graph, then create a dataset.

  1. Login using email or API Key

  2. Create a graph file called `graph.yml` with the code below.
  We are defining a simplistic graph for this example with multiple children's toys dropped into a container.
  While `YAML` files are used in channel development and for this example, the Platform SDK and API only support `JSON`. Ensure that the `YAML` file is valid in order for the SDK to convert `YAML` to `JSON` for you. Otherwise,  provide a graph in `JSON` format.
  ```yaml
  version: 2
  nodes:

    Rubik's Cube:
      nodeClass: "Rubik's Cube"

    Mix Cube:
      nodeClass: Mix Cube

    Bubbles:
      nodeClass: Bubbles

    Yoyo:
      nodeClass: Yo-yo

    Skateboard:
      nodeClass: Skateboard

    MouldingClay:
       nodeClass: Playdough

    ColorToys:
      nodeClass: ColorVariation
      values: {Color: "<random>"}
      links:
        Generators:
          - {sourceNode: Bubbles, outputPort: Bubbles Bottle Generator}
          - {sourceNode: Yoyo, outputPort: Yoyo Generator}
          - {sourceNode: MouldingClay, outputPort: Play Dough Generator}
          - {sourceNode: Skateboard, outputPort: Skateboard Generator}

    ObjectPlacement:
      nodeClass: RandomPlacement
      values: {Number of Objects: 20}
      links:
        Object Generators:
        - {sourceNode: ColorToys, outputPort: Generator}
        - {sourceNode: "Rubik's Cube", outputPort: "Rubik's Cube Generator"}
        - {sourceNode: Mix Cube, outputPort: Mixed Cube Generator}

    Container:
      nodeClass: Container
      values: {Container Type: "Light Wooden Box"}

    Floor:
      nodeClass: Floor
      values: {Floor Type: "Granite"}

    DropObjects:
      nodeClass: DropObjectsNode
      links:
        Objects:
          - {sourceNode: ObjectPlacement, outputPort: Objects}
        Container Generator:
          - {sourceNode: Container, outputPort: Container Generator}
        Floor Generator:
          - {sourceNode: Floor, outputPort: Floor Generator}

    Render:
      nodeClass: RenderNode
      links:
        Objects of Interest:
        - {sourceNode: DropObjects, outputPort: Objects of Interest}
  ```

  3. Create a graph using the client.
  To create a new graph, we load the graph defined above into a python dictionary using the yaml python package.
  Then we create a graph using the client. This graph is being named `testgraph` and is using the `example` channel. We will first find the `channelId` matching to the `example` channel and use that in the `create_staged_graph` call.
  The client will return a `graphId` so we can reference this graph later.
  ```python
  >>> import yaml
  >>> with open('graph.yml') as graphfile:
  >>>     graph = yaml.safe_load(graphfile)
  >>> channels = ana.get_channels()
  >>> channelId = list(filter(lambda channel: channel['name'] == 'example', channels))[0]['channelId']
  >>> graphId = ana.create_staged_graph(name='testgraph', channelId=channelId, graph=graph)
  >>> print(graphId)
  '010f9362-daa8-4c10-a3e8-1e81e0f2e4f4'
  ```

  4. Create a dataset using the client.
  Using the `graphId`, we can create a new job to generate a dataset. The job takes some time to run.

  The client will return a `datasetId` that can be used for reference later. You can use this `datasetId` to check the job status and, once the job is complete, download the dataset. You have now generated Synthetic Data!

  ``` python
  >>> datasetId = ana.create_dataset(name='testdataset',graphId=graphId,interpretations='10',priority='1',seed='1',description='A simple dataset with cubes in a container.')
  >>> datasetId
  'ce66e81c-23a6-11eb-adc1-0242ac120002'
  ```


pkgId: e2d1dffb322ec1d7e58fe705b27791f914146cb73b63870607facd3678a0e11b
name: python-anaug
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: An-Augment: A Python library for diverse data augmentation.
url: https://github.com/lunovian/an-augment
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anaug-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![package-publish](https://github.com/lunovian/an-augment/actions/workflows/python-publish.yml/badge.svg)](https://github.com/lunovian/an-augment/actions/workflows/python-publish.yml)
  [![jeckyll-gh-pages](https://github.com/lunovian/an-augment/actions/workflows/jekyll-gh-pages.yml/badge.svg)](https://github.com/lunovian/an-augment/actions/workflows/jekyll-gh-pages.yml)

  **AN-Augment** (**Advanced and Novel Augmentation**) is a Python library offering advanced and innovative data augmentation techniques for diverse domains, from medical imaging to environmental data. It enhances dataset diversity, improving model robustness and performance across applications.



  **AN-Augment** provides a wide range of built-in augmentations to enhance your datasets across multiple domains:



  - **Fine-Grained Control**: Adjustable parameters for precise transformation intensity and probability.
  - **Batch Processing & Randomization**: Apply augmentations to image/data batches with flexible randomization settings.
  - **Visualization Tools**: Easily visualize original and augmented data side-by-side for quick quality checks.



  - **Medical Imaging**:
    - [ ] **Augment Metadata for Labels and Masks**: Streamline label and mask processing during augmentation.
    - [ ] **Add GAN-Based Synthetic Image Generation**: Generate synthetic medical images to enrich datasets.
    - [ ] **Random Block Masks for Occlusion Simulation**: Simulate occlusions for robustness testing.
    - [ ] **3D Elastic Transformations for Volumetric Data**: Apply elastic deformations for 3D medical volumes.
    - [ ] **Fourier Transform Filters for Frequency-Based Augmentation**: Enhance feature learning with frequency-domain transformations.
    - [ ] **Contrast-Enhanced Region Augmentation**: Improve model sensitivity to contrast-specific areas.
    - [ ] **Simulated Lesions/Anomalies Augmentation**: Add realistic lesions to improve rare anomaly detection.

  - **Mechanical Simulations**:
    - **Add Stress-Based Transformations**: Simulate structural stress conditions for robustness.
    - **Dynamic Scaling and Rotation**: Introduce scaling and rotational effects to mechanical structures.
    - **Apply Structural Noise Augmentation**: Add noise specific to mechanical patterns to enrich datasets.
    - **Load Simulation Augmentation**: Simulate load-based distortions and deformations.

  - **Environmental Data**:
    - **Simulate Cloud Occlusions**: Apply cloud-like occlusions for satellite and environmental imagery.
    - **Add Noise for Sensor Simulation**: Introduce sensor-based noise patterns for realism.
    - **Spatial Scaling and Shifting**: Apply shifts and scaling to spatial data.
    - **Enhance Terrain Patterns**: Augment terrain-based features with synthetic distortions.

  - **Water Systems**:
    - **Wave Simulation Augmentation**: Generate wave-like distortions for water bodies.
    - **Flow Distortion Augmentation**: Simulate flow patterns in water datasets.
    - **Add Scaling Factors for Dynamic Modeling**: Apply scaling for dynamic hydrodynamic modeling.
    - **Turbulence Simulation**: Introduce turbulence effects for water-based data.



  To install **AN-Augment**, use pip:

  ```bash
  pip install an-augment
  ```

  Alternatively, you can install the latest development version from the repository:

  ```bash
  git clone https://github.com/lunovian/an-augment.git
  cd an-augment
  pip install -r requirements.txt
  ```



  Here’s a quick example of how to use **AN-Augment** for medical imaging augmentations:

  ```python
  import cv2
  import matplotlib.pyplot as plt
  from an_augment.default import scale, flip, noise, random_rotation, random_crop, intensity, elastic_deformation, occlusion, blur


  image_path = "images/mri.jpg"
  image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
  if image is None:
      raise FileNotFoundError(f"The image at path '{image_path}' could not be loaded. Ensure the path is correct.")

  image = image / 255.0  # Normalize the image to [0, 1]


  params = {
      'blur': {'blur_radius': 2},
      'elastic_deformation': {'alpha': 30, 'sigma': 4},
      'flip': {'flip_horizontal': True, 'flip_vertical': False},
      'intensity': {'brightness_factor': 1.2, 'contrast_factor': 1.3},
      'noise': {'noise_type': 'gaussian', 'noise_intensity': 0.1},
      'occlusion': {'mask_shape': 'rectangle', 'mask_size_range': (0.1, 0.2)},
      'random_rotation': {'angle_range': (-15, 15)},
      'random_crop': {'crop_size': (0.8, 0.8), 'scaling_factor': 1.0},
      'scale': {'scale_factor': 0.8}
  }


  try:
      augmented_image = blur(image, **params['blur'])
      augmented_image = elastic_deformation(image, **params['elastic_deformation'])
      augmented_image = flip(augmented_image, **params['flip'])
      augmented_image = intensity(augmented_image, **params['intensity'])
      augmented_image = noise(augmented_image, **params['noise'])
      augmented_image = occlusion(augmented_image, **params['occlusion'])
      augmented_image = random_rotation(augmented_image, **params['random_rotation'])
      augmented_image = random_crop(augmented_image, **params['random_crop'])
      augmented_image = scale(augmented_image, **params['scale'])
  except Exception as e:
      raise RuntimeError(f"An error occurred while applying augmentations: {e}")


  plt.figure(figsize=(12, 6))
  plt.subplot(1, 2, 1)
  plt.title("Original Image")
  plt.imshow(image, cmap="gray")
  plt.axis("off")

  plt.subplot(1, 2, 2)
  plt.title("Augmented Image")
  plt.imshow(augmented_image, cmap="gray")
  plt.axis("off")

  plt.tight_layout()
  plt.show()

  ```

  Here is an example of the original image and the augmented result:

  | Original Image                     | Augmented Image                     |
  |------------------------------------|-------------------------------------|
  | ![Original Image](images/original_image.png)  | ![Augmented Image](images/augmented_image.png) |

  For other domains (e.g., mechanical or environmental), the process is similar—just import the relevant augmentation module (e.g., `MechanicalAugmentation`, `EnvironmentalAugmentation`, etc.).



  We welcome contributions! Fork the repository, make your changes, and submit a pull request. You can contribute new augmentation types or improve existing ones.



  **AN-Augment** is licensed under the Apache-2.0 License.


pkgId: 3bb181cbb72d4a24d1ca8ce895ab53d73dc091ad3250f3439d8255d78f29e8b3
name: python-anbima_calendar
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Helper functions to handle banking holidays in Brazil
url: https://anbima-calendar.readthedocs.io/en/latest/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anbima_calendar-0.1.1-1.src.rpm
checksum_type: sha256
description:
  ![anbima-calendar](https://github.com/rizidoro/anbima_calendar/assets/13101/4aead264-4ab0-410e-a232-200fec9e7afa)

  **Anbima Calendar** is a Python library designed to simplify handling banking holidays specific to Brazil. **ANBIMA (Associação Brasileira das Entidades dos Mercados Financeiro e de Capitais)**, the Brazilian Financial and Capital Markets Association, plays a crucial role in the development of financial markets in Brazil. This library provides a robust set of tools for determining business days, calculating due dates, and identifying holidays based on the official holiday calendar published by ANBIMA.
  The holiday data used in **Anbima Calendar** is sourced directly from ANBIMA's official website: https://www.anbima.com.br/feriados/feriados.asp. This ensures that the library stays up-to-date with the most accurate and relevant holiday information, making it an invaluable resource for financial applications, scheduling systems, and any software dealing with date calculations in the Brazilian context.
  Whether you're developing a finance-related application, a scheduling tool, or simply need to be aware of Brazilian banking holidays, Anbima Calendar offers a straightforward and efficient solution to navigate through the complexities of holiday scheduling in Brazil's financial markets.

  - Identify Business Days: Quickly determine if a specific date is a business day in Brazil.
  - Calculate Due Dates: Accurately calculate due dates taking into account weekends and holidays.
  - Discover Holidays: Retrieve information about specific Brazilian holidays.
  - Add Business Days: Add a specified number of business days to a given date.

  Install Anbima Calendar using pip:
  ```bash
  pip install anbima_calendar
  ```

  Here's a quick example to get you started with Anbima Calendar:
  ```python
  from anbima_calendar import is_business_day, add_business_days, get_holiday

  print(is_business_day('2023-04-21'))  # False, as it's Tiradentes' Day

  new_date = add_business_days(5, '2023-04-18')
  print(new_date)  # Returns the date after adding 5 business days

  holiday = get_holiday('2023-04-21')
  print(holiday)  # Tiradentes
  ```

  Determine if a given date is a business day in Brazil.
  ```python
  from anbima_calendar import is_business_day
  print(is_business_day('2023-12-25'))  # False, Christmas Day is a holiday
  ```

  Add business days to a date, automatically skipping weekends and holidays.
  ```python
  from anbima_calendar import add_business_days
  new_date = add_business_days(10, '2023-12-20')
  print(new_date)  # Date 10 business days from December 20, 2023
  ```

  Find out if a date is a holiday and get its name.
  ```python
  from anbima_calendar import get_holiday
  holiday_name = get_holiday('2023-05-01')
  print(holiday_name)  # Dia do Trabalho (Labor Day)
  ```

  Contributions to Anbima Calendar are welcome! Whether it's bug reports, feature requests, or code contributions, your input is highly valued. Please refer to our Please refer to our [contributing guidelines](CONTRIBUTING.md) for more information.

  Anbima Calendar is licensed under the MIT License. See the LICENSE file for more details.


pkgId: 36dbacec87ea4940d5fc4778f0f1373f1e83e471676876775ac95f88d1b4e51f
name: python-anc
arch: src
version: 0.3.9
epoch: 0
release: 1
summary: cli
url: https://github.com/a7n-global/infra
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anc-0.3.9-1.src.rpm
checksum_type: sha256
description:
  The ANC CLI tool is a comprehensive command line interface designed to facilitate the management of various resources within the company. Initially, it supports managing datasets and their versions, enabling users to interact seamlessly with a remote server for fetching, listing, and adding datasets.



  ```bash

  sudo pip install anc

  ```


  - **Fetch Datasets**: Retrieve specific versions of datasets from a remote server.
  - **List Versions**: View all available versions of a dataset.
  - **Add Datasets**: Upload new datasets along with their versions and descriptions to the remote server.




  ```bash

  anc ds list

  anc ds list -n <dataset name>

  ```


  ```bash



  anc ds get cifar-10-batches-py -v 1.0

  ```


  ```bash



  anc ds add /mnt/weka/xug/dvc_temp/cifar-10-batches-py -v 1.0

  ```


pkgId: e01d775930c2b1a6ff955a5d4c10ab7ecf55e1537d0c08eb5c78eed29d91c71d
name: python-anchor-droplet-chip
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: Segment organoids and measure intensities
url: https://github.com/BaroudLab/anchor-driplet-chip
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchor-droplet-chip-0.4.6-1.src.rpm
checksum_type: sha256
description:
  We are imaging the entire chip using 20x 0.7NA objective lens using automatic stitching in NIS.
  Bright-field image 2D and TRITC-3D acquired. The 3D stack is converted to 2D using maximum projection in NIS or Fiji. Both channels are then merged together and saved as a tif stack. After that this package can be applied to detect the individual droplets and count the fluorescent cells.

  As the chips are bonded to the coverslip manually, they contain a randon tilt and shift, so detecting individual droplets proved to be unreliable. The current approach consisnts of preparing a well-lebelled template bright-field image and a labelled mask and matching the experimental brightfield image to the template.
  ![Paper outline(1)](https://user-images.githubusercontent.com/11408456/178001287-513e6398-c4e0-4946-b38f-6cb98dc0ee6c.svg)


  ```bash
  pip install anchor-droplet-chip
  ```


  1. Notebook: `jupyter lab example.ipynb`
  2. Napari plugin: see the menu `Plugins / andhor-droplet-chips / ...
  3. Command line:

      `python -m adc.align --help`

      `python -m adc.count --help`


  Head to release page https://github.com/BaroudLab/anchor-droplet-chip/releases/tag/v0.0.1 and download files one by one.

  Or

  Execute the notebook example.ipynb - the data will be fetched automatically.



  Day 1:
  ```bash
  python -m adc.align day1/00ng_BF_TRITC_bin2.tif template_bin16_bf.tif labels_bin2.tif
  ```
  This command will create the stack day1/00ng_BF_TRITC_bin2-aligned.tif, which can be viewed in Fiji.
  ![Screenshot of 00ng_BF_TRITC_bin2-aligned.tif](https://user-images.githubusercontent.com/11408456/176169270-3d494fc3-a771-4bf0-859e-c9cc853ce2d9.png)

  Day 2:
  ```bash
  python -m adc.align day2/00ng_BF_TRITC_bin2_24h.tif template_bin16_bf.tif labels_bin2.tif
  ```


  ```
  python -m adc.count day1/00ng_BF_TRITC_bin2-aligned.tif day1/counts.csv
  python -m adc.count day2/00ng_BF_TRITC_bin2_24h-aligned.tif day2/counts.csv
  ```


  ```
  python adc.merge day1/counts.csv day2/counts.csv table.csv
  ```








  First you'll need to clone the repo locally and install it to have the scripts at hand.

  ```bash
  git clone https://github.com/BaroudLab/anchor-droplet-chip.git

  cd anchor-droplet-chip

  pip install .
  ```
  Make a data folder
  ```bash
  mkdir data

  ```
  Download the dataset from Zenodo https://zenodo.org/record/6940212
  ```bash
  zenodo_get 6940212 -o data
  ```
  Proceed with Snakemake pipeline to get tha table and plots. Be careful with the number of threads `-c` as a single thread can consume over 8 GBs of RAM.
  ```bash
  snakemake -c4 -d data table.csv
  ```





  Open large nd2 file by drag-n-drop and select anchor-droplet-chip as a reader.
  The reader plugin will aotimatically detect the subchannels and split them in different layers.
  The reader will also extract the pixel size from metadata and save it as Layer.metadata["pixel_size_um"]
  The data itself is opened ad dask array using nd2 python library.



  Some datasets are so big, it's hard to even to open them, let alone doing processing in them.
  `anchor-droplet-chip / Make a sub stack ` addresses this problem.
  Upon opening the plugin you'll see all  dimensions of you dataset, and the axes will become named accordingly.
  Simply choose the subset of data you need, and click "Crop it!". This will create a new layer with the subset of data.
  Note that no new files are created in the process and in the background nd2 library lazy loading chunks of data from the original nd2 file.


  Draw a line in the new shapes layer and call the widget. It will populate square ROIs along the line. Adjust the number of columns and rows. This way you can manually map the 2D wells on your chip.


  Use this widget to crop the mapped previously ROIs. The extracted crops can be saved as tifs.



  Allows to split any dataset along a selected axis and save the pieces as separate tifs (imagej format, so only TZCYX axes supported)
  * Select the axis name
  * Click Split it! and check the table with the names, shapes and paths.
  * To change the prefix, set the folder by clicking at "Choose folder"
  * Once the table looks right, click "Save tifs" and wait. The colunm "saved" will be updated along the way.
  ![image](https://user-images.githubusercontent.com/11408456/214313498-5b1f8408-1fa3-4e24-810a-b9394e936c8e.png)


pkgId: c5f512d31cad51a5852f9bc3ffab56bc15db57a197518d02b16e9fb902c4b083
name: python-anchor-txt
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: attributes in markdown
url: https://github.com/vitiral/anchor_txt
rpm_license: MIT or APACHE-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchor-txt-0.1.6-1.src.rpm
checksum_type: sha256
description:
  anchor_txt: attributes in markdown

  anchor_txt adds the ability to embed attributes in markdown files so that external
  tools can more easily link them to eachother and code, as well as perform
  other operations.

  Use ``anchor_txt.Section.from_md_path`` to load a markdown file.


  The syntax for anchor_txt attributes is simple.

  - Headers of the form `# header {#anchor}` will have the `anchor` tag extracted and available
    in `Header.anchor`
  - A header creates a Section, which can have sub `sections`.
  - Sections have attributes, which are embedded yaml either inline or in fenced
    code blocks, shown below.

  An inline attribute looks like one of these:
  ```
  `@{foo}`
  `@{bar: 2}`
  ```

  Fenced code block attributes look like below. They must include the identifier
  `yaml` (or `json`) and end with a `@`

      ```yaml @
      foo: null
      bar: 2
      ```

  Attributes blocks within a Section are combined through the same process as
  `dict.update`, except overlapping keys throw an error.


  Run `make init` to create the necessary virtualenv

  Run `make test` for basic tests or `make check` for lints and formatting.




  The source code is Licensed under either of

  * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
    http://www.apache.org/licenses/LICENSE-2.0)
  * MIT license ([LICENSE-MIT](LICENSE-MIT) or
    http://opensource.org/licenses/MIT)

  at your option.

  Unless you explicitly state otherwise, any contribution intentionally submitted
  for inclusion in the work by you, as defined in the Apache-2.0 license, shall
  be dual licensed as above, without any additional terms or conditions.


pkgId: f854a2764ec3ee4e89654a99a7e3789899f667603b6308003a715bead1fb0af9
name: python-anchorage
arch: src
version: 1.2.1.0
epoch: 0
release: 1
summary: Anchor your little piece of internet.
url: https://github.com/alopezrivera/anchorage
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchorage-1.2.1.0-1.src.rpm
checksum_type: sha256
description:
  What follows is the Anchorage user's manual.
  First it will deal with the requirements and install of the library, and then with its
  configuration, the Anchorage CLI and its Python API. A thorough documentation of each
  API method is available in the [docs](https://anchorage-docs.github.io/) site.

  A working [Docker](https://docs.docker.com/get-docker/) install is the only requirement, beyond Python and Anchorage's
  dependencies.
  **Without Docker**: Docker is used to run [ArchiveBox](https://archivebox.io/), via a provided
  [docker-compose file](https://github.com/ArchiveBox/ArchiveBox/wiki/Docker#docker-compose).
  Without Docker Anchorage will not be able to archive your collection locally, but it will still be
  able to save it online in the Internet Archive.
  Anchorage can be installed using pip as any Python package. Its dependencies will be downloaded automatically.
      pip install anchorage

  To access a browser's bookmarks file, Anchorage stores its location in its configuration file:
      ~/.anchorage/config.toml
  There's an [example `config.toml`](https://github.com/antonlopezr/anchorage/blob/master/example-config.toml)
  in this repo for reference.
  To add a new browser simply add a new top-level key, followed by its bookmark file paths. Anchorage only needs
  the path in your operating system to work.
      [<browser name>]
      linux = <path>
      macos = <path>
      windows = <path>
  Importantly:
  - Linux and MacOS paths are stored in **full**.
  - Windows paths are stored from the **`AppData`** directory.
  The default `config.toml` contains the bookmark file paths for Google Chrome, Mozilla Firefox and Microsoft Edge
  and Edge Beta for **Windows** only. To use Anchorage in **Linux or MacOS** add the bookmark file path of your
  browser of choice to your `config.toml`.

  The config file can be edited just as any other.
  New browsers will automatically be listed in the CLI.
  Importantly:
  - Set unknown bookmark file paths to "?". That way the CLI will recognize those as unknown and behave appropriately.
  ![alt text](https://github.com/antonlopezr/anchorage/blob/master/docs/demo/gifs/config.gif "Adding the location of the Google Chrome bookmarks file to ~/.anchorage/config.toml")

  The CLI will guide you through retrieving your bookmarks from your browser of choice, applying
  filters to you bookmark collection and archiving your bookmarks in the Internet Archive or locally,
  using ArchiveBox.
  To start the CLI open your shell and type
      anchorage
  You will be asked whether you're ready to proceed. On the ok it will ensure all dependencies are present.

  If a config file is found, you will be prompted to choose whether to
  keep the current config or overwrite it with the default one.

  You will be prompted to choose which browser to retrieve your bookmark collection from. The browser
  choices are sourced from `config.toml`. Refer to [section 3](#3-anchorage-configuration) for
  editing it to add a missing browser or enter the path to the bookmarks file of your browser, if it's missing
  (equal to "?").

  Filters can be applied to your bookmark collection before archiving.
  Any or all of four filters can be chosen, one specific for URLs:
  - `Local files`: remove local URLs (say, PDFs stored in your computer) from the collection.
  and three general:
  - `Match string`: remove bookmark URLs, names or bookmark directories matching a provided string or any string
  in a string list.
  - `Match substring`: remove bookmark URLs, names or bookmark directories containing a provided string or any string
  in a string list.
  - `Regex`: remove bookmark URLs, names or bookmark directories matching a provided regex formula.
  For each you will be prompted to choose to apply it to any or all of the previous.

  You will be then asked to choose whether to archive your collection online or locally.

  By default websites will not be archived if a previous image exists in The Internet Archive. This is to save time: we rest easy as a those
  sites are saved already at some point. In case you want to save a current snapshot of the colection, you will be prompted whether to override this
  and archive all sites in the collection regardless. This may take significantly longer. Based on your choice, you will be given an estimate of the
  archive time.

  To archive your collection locally you will be prompted for an archive directory.

  After a last confirmation the process will begin. A progress bar will inform you of how far the process
  is from finishing, how many bookmarks have been saved and provide a dynamic estimate of the time remaining
  before the process is finished.

  The full documentation of the Anchorage API is available in the [docs](https://anchorage-docs.github.io/) site.

  Generate the Anchorage config file with the `init` command.
      from anchorage import init
      init()

  Three methods are relevant:
  - `path(<browser>)`: obtain the path to your chosen browser's bookmarks file (in your OS) from `config.toml`.
  - `load(<path>)`: read your chosen browser's JSON or JSONLZ4 bookmarks file and return a Python dictionary.
  - `bookmarks(<dict>)`: create an instance of the `bookmarks` class.
  The `bookmarks` class creates a second bookmarks dictionary more suitable for our intent, and contains methods
  to filter and loop through the collection. Filters can be applied as seen below.
      from anchorage import path, load, bookmarks
      collection = bookmarks(load(path(<browser name>)),
                             drop_local_files= <boolean>,
                             drop_dirs=        <string or list of strings>,
                             drop_names=       <string or list of strings>,
                             drop_urls=        <string or list of strings>,
                             drop_dirs_subs=   <string or list of strings>,
                             drop_names_subs=  <string or list of strings>,
                             drop_urls_subs=   <string or list of strings>,
                             drop_dirs_regex=  <string>,
                             drop_names_regex= <string>,
                             drop_urls_regex=  <string>
                             )

  Input: `bookmarks` instance or bookmark dictionary returned by `load`.

      from anchorage import anchor_online
      anchor_online(bookmarks, overwrite=<bool>)
  The `overwrite` parameter determines whether to save snapshots of sites already present in the
  Internet Archive or not.

      from anchorage import anchor_locally
      anchor_locally(bookmarks, archive=<dir>)
  The `archive` parameter specifies the directory in which to create the local archive.
  Running the ArchiveBox default NGINX server
  can be done with the following command.
      from anchorage import server


pkgId: 4c63ba75e4fe703b10394d3d161b15dae353f8b168b3f5b2f6231358be9b397a
name: python-anchorconnector
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Anchor Connector for Podcast Data
url: https://pypi.org/project/anchorconnector/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchorconnector-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Docs](https://readthedocs.org/projects/anchor-connector/badge?version=latest)](https://anchor-connector.readthedocs.io)

  [![OpenPodcast Banner](https://raw.githubusercontent.com/openpodcast/banner/main/openpodcast-banner.png)](https://openpodcast.app/)

  This is a simple library for connecting to the unofficial Anchor API.
  It can be used to export data from your dashboard at
  https://anchor.fm/dashboard.



  - `total_plays`
  - `plays_by_age_range`
  - `plays_by_app`
  - `plays_by_device`
  - `plays_by_episode`
  - `plays_by_gender`
  - `plays_by_geo`
  - `plays_by_geo_city`
  - `episodes`

  For each episode, the following endpoints are supported:

  - `episode_plays`
  - `episode_performance`
  - `episode_aggregated_performance`
  - `episode_all_time_video_data`

  See `__main.py__` for all endpoints.



  Before you can use the library, you must extract your Anchor credentials from the dashboard;
  they are **not** exposed through your Anchor settings.

  You can use our [web-extension](https://github.com/openpodcast/web-extension) for that
  or [take a look at the code](https://github.com/openpodcast/web-extension/blob/47fd44723caf6e8a4660f244814f316cdcf19c4c/src/openpodcast.js) to see how to do it manually.



  ```
  pip install anchorconnector
  ```



  ```python
  from anchorconnector import AnchorConnector

  connector = AnchorConnector(
     base_url=BASE_URL,
     webstation_id=WEBSTATION_ID,
     anchorpw_s=ANCHOR_PW_S,
  )

  end = datetime.now()
  start = end - timedelta(days=30)

  total_plays = connector.total_plays(True)
  logger.info("Podcast Total Plays = {}", json.dumps(total_plays, indent=4))

  plays_by_age_range = connector.plays_by_age_range(start, end)
  logger.info(
     "Plays by Age Range = {}",
     json.dumps(plays_by_age_range, indent=4),
  )










  for episode in connector.episodes():
     logger.info("Episode = {}", json.dumps(episode, indent=4))

     web_episode_id = episode["webEpisodeId"]

     episode_meta = connector.episode_plays(web_episode_id)
     logger.info("Episode Metadata = {}", json.dumps(episode_meta, indent=4))

     
  ```

  See `__main.py__` for all endpoints.



  We use [Pipenv] for virtualenv and dev dependency management. With Pipenv
  installed:

  1. Install your locally checked out code in [development mode], including its
     dependencies, and all dev dependencies into a virtual environment:

  ```sh
  pipenv sync --dev
  ```

  2. Create an environment file and fill in the required values:

  ```sh
  cp .env.sample .env
  ```

  3. Run the script in the virtual environment, which will [automatically load
     your `.env`][env]:

  ```sh
  pipenv run anchorconnector
  ```

  To add a new dependency for use during the development of this library:

  ```sh
  pipenv install --dev $package
  ```

  To add a new dependency necessary for the correct operation of this library, add
  the package to the `install_requires` section of `./setup.py`, then:

  ```sh
  pipenv install
  ```

  To publish the package:

  ```sh
  python setup.py sdist bdist_wheel
  twine upload dist/*
  ```

  or

  ```sh
  make publish
  ```

  [pipenv]: https://pipenv.pypa.io/en/latest/index.html#install-pipenv-today
  [development mode]: https://setuptools.pypa.io/en/latest/userguide/development_mode.html
  [env]: https://pipenv.pypa.io/en/latest/advanced/#automatic-loading-of-env


pkgId: 9327841634661e573028a178947723e9112158479966e367f38bca97fddb643c
name: python-anchorestig
arch: src
version: 0.75.0
epoch: 0
release: 1
summary: A tool for performing static and runtime analysis using STIGs
url: https://pypi.org/project/anchorestig/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchorestig-0.75.0-1.src.rpm
checksum_type: sha256
description:
  Anchore STIG is a complete STIG solution that can be used to run STIG profile against static images, running containers in a kubernetes cluster, and virtual machines via ssh.



  Use Anchore STIG to perform STIG checks against running containers in Kubernetes environments or static Docker images from a registry or stored locally. The tool executes automated scans against specific STIG Security Guide (SSG) policies. The program will output either a JSON report with a summary of STIG check results for runtime checks or XCCDF XML and OpenSCAP XML and HTML for static checks.

  The profiles for static, runtime, and vm are as follows:

  * Ubuntu 20.04 (ubuntu-20.04)
  * Ubuntu 22.04 (ubuntu-22.04)
  * Universal Base Image 8 (ubi8) - This runs the full RHEL 8 STIG
  * Universal Base Image 9 (ubi9) - This runs the full RHEL 9 STIG
  * Postgres 9 (postgres9)
  * Apache Tommcat 9 (apache-tomcat9)
  * Crunchy PostgreSQL (crunchy-postgresql)
  * JBOSS (jboss)
  * Java Runtime Environment 7 (jre7)
  * MongoDB Enterprise (mongodb)
  * nginx (nginx)






  * `python3 >= 3.8 with pip installed`
  * `make`
  * `saf` - There is an option to install this tool after running the tool, but installing it manually is the most reliable.


  * `docker`


  * `kubectl exec` privileges
  * Pods running one of the above listed software / OS types


  * An SSH profile for the VM or the path to the key used to connect to the machine
  * The VM's endpoint




  * clone the repo
  * run `make` to install





  * Run `anchorestig runtime` from the terminal.
      * NOTE: This edition of the demo has been optimized for single-container pods by default

  * The program will run in interactive mode by executing `anchorestig runtime --interactive` from the terminal, however, you may also use the following CLI input parameters:

  ```
  CLI Input Parameters:

    -i, --image TEXT       Specify profile to use. Available options are ubuntu-20.04, ubi8, postgres9, apache-tomcat9, crunchy-postgresql, jboss, jre7, mongodb, nginx
    -p, --pod TEXT         Any running pod running an image that runs one of the specififed profile's software
    -c, --container TEXT   Container in the pod to run against
    -o, --outfile TEXT     Output file name. Only JSON output filetype is supported (include the '.json' extension with the output file name in CLI)
    -n, --namespace TEXT   Namespace the pod is located in
    -u, --usecontext TEXT  Specify the kubernetes context to use
    -b, --aws-bucket TEXT  Specify the S3 bucket to upload results to. Omit to skip upload
    -a, --account TEXT     Specify the Anchore STIG UI account to associate the S3 upload with. Omit to skip upload
    -t, --interactive      Run in interactive mode
    -s, --sync             Sync policies from Anchore
    --help                 Show this message and exit.

  ```
  Ex: `anchore-stig runtime -u current -n test -i postgres9 -p postgres9 -c default -o postgres.json`

  * NOTE: The output file will be saved to the `./outputs` directory



  Navigate to the `./outputs` directory to view the output file.



  * Run the tool using `anchorestig static IMAGE`.
      * Ex: `anchorestig static docker.io/ubi8:latest`

  ```
  CLI Input Parameters:

      -u, --username TEXT    Username for private registry
      -p, --password TEXT    Password for private registry
      -r, --url TEXT         URL for private registry
      -b, --aws-bucket TEXT  S3 upload. Specify bucket name
      -a, --account TEXT     Anchore STIG UI account. Required for S3 upload
      -s, --insecure         Allow insecure registries or registries with custom certs
      -l, --profile TEXT     Specify profile to run. Can be the name of an existing profile or the path to a custom profile
      -i, --input-file TEXT  Specify the path to a custom input file to run with a profile.
      --help                 Show this message and exit.
  ```



  Navigate to the `./stig-results` directory. The output directory containing output files will be named according to the image scanned.


  * Run the tool using `anchorestig vm -h <vm-endpoint> -u <user> -k <path-to-key> --profile <profile>`

  ```
  CLI Input Paramters:

    -u, --user TEXT        Username for SSH Host  [required]
    -p, --password TEXT    Password for SSH Host
    -k, --key TEXT         PEM Key path for SSH Host
    -h, --host TEXT        Username for SSH Host  [required]
    -l, --profile TEXT     Specify profile to run. Can be the name of an existing profile or the path to a custom profile [required]
    -i, --input-file TEXT  Specify the path to a custom input file to run with a profile.
    --help                 Show this message and exit.
  ```



  Use the `--help` flag to see more information on how to run the program:

  `anchorestig --help`



  `cinc-auditor` allows users to specify a target to run profiles against. This can be a number of things including SSH targets or a local system. The `train-k8s-container` plugin allows our STIG tool to target a kubernetes namespace, pod, and container to run cinc profiles against. When a container is set as the target, each individual control will be prepended with `kubectl exec .....` and the appropriate commands to run within the container and retireve the results to make the determination of a pass or fail against the control baseline.



  The `policies` directory contains sub-directories for the Ubuntu, UBI, and Postgres STIG profiles. Each directory has a `tar.gz` file that can be decompressed. From there, each control that runs is defined as a ruby gem file in the `controls` directory. The ID of each control (displayed in Heimdall) is pulled from the `control` section at the beginning of the ruby gem file. To change what is displayed, change the control id at the beginning of the file.



  The `UBI 8` and `Ubuntu 20.04` policies were built with the `not-applicable` rules removed. To add them back, untar the tar files in each repository, move the ruby gem files from the `not-applicable/` directory to the controls directory. Then run `cinc-auditor archive .` in the untarred directory. This will generate a new tar archive file. Replace the original archive, that you un-tarred at the beginning with the newly generated one and the newly included rules will run.

  <!-- ## Version History

  * 0.1
      * Initial Release



  This project is licensed under the Anchore License - see the LICENSE.md file for details -->


pkgId: 16dc2548b3a17ad2938d9183e531070148f4169d548111d8ecc18fc82fab220d
name: python-anchorpoint
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: Text substring selectors for anchoring annotations
url: https://github.com/mscarey/anchorpoint
rpm_license: Free To Use But Restricted
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchorpoint-0.8.2-1.src.rpm
checksum_type: sha256
description:
  A Python library for anchoring annotations with text substring selectors.
  Anchorpoint supplies TextQuoteSelector and TextPositionSelector
  classes based on the Web Annotation Data Model, which is
  a `W3C Recommendation`_. Anchorpoint includes helper methods
  for switching between selector types, and
  a `pydantic`_ schema for serialization. Anchorpoint is used
  by `Legislice`_ for referencing laws such as statutes, and
  by `AuthoritySpoke`_ for referencing judicial opinions.
  `API Documentation`_ is available on readthedocs.
  Anchorpoint relies on `python-ranges`_ to perform set operations on spans of text.
  Related Packages
  ~~~~~~~~~~~~~~~~
  In Javascript, try the `Text Quote Anchor`_ and `Text Position Anchor`_ packages.
  In Python try python-ranges_, which is the basis for much of the TextPositionSelector class's behavior.


pkgId: 6579387511fcb53a7f88f5bb6e56f928b86f1f36d31d5181a3d48d95ff4fc926
name: python-anchorpy
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: The Python Anchor client.
url: https://github.com/kevinheavey/anchorpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchorpy-0.20.1-1.src.rpm
checksum_type: sha256
description:
  [![Discord Chat](https://img.shields.io/discord/889577356681945098?color=blueviolet)](https://discord.gg/sxy4zxBckh)
  AnchorPy is the gateway to interacting with [Anchor](https://github.com/project-serum/anchor) programs in Python.
  It provides:
  - A static client generator
  - A dynamic client similar to `anchor-ts`
  - A Pytest plugin
  - A CLI with various utilities for Anchor Python development.
  Read the [Documentation](https://kevinheavey.github.io/anchorpy/).

  ```sh
  pip install anchorpy[cli, pytest]
  ```
  Or, if you're not using the CLI or Pytest plugin features of AnchorPy you can just run `pip install anchorpy`.

  If you want to contribute to AnchorPy, follow these steps to get set up:
  1. Install [poetry](https://python-poetry.org/docs/#installation)
  2. Install dev dependencies:
  ```sh
  poetry install
  ```
  3. Activate the poetry shell:
  ```sh
  poetry shell
  ```


pkgId: 0f7d076d5f69616cb4d32945d00f5ce163e04b1be76956fe4e4f774ac51ed955
name: python-anchovy
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A minimal, unopinionated file processing engine intended for static website generation.
url: https://pypi.org/project/anchovy/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anchovy-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Project Version](https://img.shields.io/pypi/v/anchovy)](https://pypi.org/project/anchovy)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/anchovy)](https://pypi.org/project/anchovy)
  [![GitHub - Project License](https://img.shields.io/github/license/pydsigner/anchovy)](https://github.com/pydsigner/anchovy)
  [![GitHub - Code Size](https://img.shields.io/github/languages/code-size/pydsigner/anchovy)](https://github.com/pydsigner/anchovy)
  [![codecov](https://codecov.io/gh/pydsigner/anchovy/graph/badge.svg?token=A8WRBWO3JG)](https://codecov.io/gh/pydsigner/anchovy)



  Anchovy is a minimal, unopinionated file-processing framework equipped with a
  complete static website generation toolkit.

  * **Minimal:** Anchovy’s core is around a thousand lines of code and has no
    mandatory dependencies. Plus, Anchovy can be used for real projects with just
    a few pip-installable extras, even if you want to preprocess CSS.

  * **Unopinionated:** Anchovy offers a set of components which can be easily
    configured to your site’s exact requirements, without tediously ripping out
    or overriding entrenched behaviors. Anchovy does not assume you are building
    a blog or that you wish to design your templates in a specific way. You can
    even build things that aren’t websites! Plus, Anchovy operates on files, so
    it’s simple to integrate tools like imagemagick, dart-sass, or less.js if you
    need them.

  * **Complete:** Anchovy comes with a dependency auditing system, allowing you
    to grab any component you want without installing anything but Anchovy and
    find out what you *will* need to run your build. Choose from a wealth of
    Steps, Anchovy’s modular file processors, for everything from rendering Jinja
    templates and minifying CSS to unpacking archives and thumbnailing images.
    Plus, add a few extra parameters or lines of configuration to get automatic
    intelligent minimum builds based on input checksums, and get a reproducible
    run artifact to boot— even if you want to fetch HTTP resources or write your
    own Steps. Iterate quickly by launching a lightweight development-grade web
    server once the build is complete.



  Anchovy has no essential prerequisites and can be installed with
  `pip install anchovy` to get just the framework and a few built-in components,
  but for typical usage `pip install anchovy[base]` is recommended. This will
  pull in support for Jinja2 templating, markdown, minification, and Anchovy’s
  CSS preprocessor. A full list of available extras may be found in the
  [pyproject.toml](https://github.com/pydsigner/anchovy/blob/master/pyproject.toml) file.

  Alternatively, Anchovy may be installed directly from source with
  `pip install git+https://github.com/pydsigner/anchovy` or the corresponding
  `pip install git+https://github.com/pydsigner/anchovy#egg=anchovy[base]`.



  Anchovy operates on config files written in Python, or even modules directly.

  * `python -m anchovy -h`
  * `anchovy -m mypackage.anchovyconf -o ../release/`
  * `python -m anchovy mysite/anchovy_site.py -- -h`



  Run `anchovy examples/code_index.py -s -p 8080`, then open a browser to
  localhost:8080 (or click the link in the console). This example offers the most
  extensive demonstration of Anchovy’s functionality as of version 1.0.



  Here’s minimal example performing about what the `staticjinja` markdown example
  offers:

  ```python
  from pathlib import Path

  from anchovy import (
      DirectCopyStep,
      InputBuildSettings,
      JinjaMarkdownStep,
      OutputDirPathCalc,
      REMatcher,
      Rule,
  )



  SETTINGS = InputBuildSettings(
      input_dir=Path('site'),
      working_dir=Path('working'),
      output_dir=Path('build'),
      custody_cache=Path('build-cache.json'),
  )
  RULES = [
      
      Rule(
          (
              REMatcher(r'(.*/)*\..*', parent_dir='input_dir')
              | REMatcher(r'(.*/)*\..*', parent_dir='working_dir')
          ),
          None
      ),
      
      Rule(
          REMatcher(r'.*\.md'),
          [OutputDirPathCalc('.html'), None],
          JinjaMarkdownStep()
      ),
      
      Rule(
          REMatcher(r'(.*/)*static/.*', parent_dir='input_dir'),
          OutputDirPathCalc(),
          DirectCopyStep()
      ),
  ]
  ```

  This example is very simple, but it’s legitimately enough to start with for a
  small website, and offers an advantage over other minimal frameworks by putting
  additional batteries within an arm’s reach. If we stored the configuration in
  `config.py` and added a raw site like this:
  ```
  site/
      static/
          styles.css
          toolbar.js
      base.jinja.html
      index.md
      about.md
      contact.md
  ```
   `python -m anchovy config.py` would produce output like this:
  ```
  output/
      static/
          styles.css
          toolbar.js
      index.html
      about.html
      contact.html
  ```

  This example can be found in runnable form as [examples/basic_site.py](https://github.com/pydsigner/anchovy/blob/master/examples/basic_site.py)
  in the source distribution. Available command line arguments can be seen by
  passing `-h`: `python -m anchovy examples/basic_site.py -- -h`. The `--` is
  required because `anchovy` itself also accepts the flag.



  Anchovy is very usable from the command line, but projects desiring to
  customize behavior, for example by running tasks before or after pipeline
  execution, may utilize `anchovy.cli.run_from_rules()`:

  ```python
  import time
  from pathlib import Path

  from anchovy.cli import run_from_rules
  from anchovy.core import Context

  from my_site.config import SETTINGS, RULES


  class MyContext(Context):
      def find_inputs(path: Path):
          
          hour_ago = time.time() - 3600
          for candidate in super().find_inputs(path):
              if candidate.stat().st_mtime > hour_ago:
                  yield candidate


  def main():
      print('Pretending to run pre-pipeline tasks...')
      run_from_rules(SETTINGS, RULES, context_cls=MyContext)
      print('Pretending to run post-pipeline tasks...')


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


pkgId: 4d09bbd0ba863881409ef55edc392a77f6eca1920e5ec207fbf246cff4bdf79e
name: python-andebox
arch: src
version: 0.63
epoch: 0
release: 1
summary: Ansible Developers Box
url: https://github.com/russoz-ansible/andebox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-andebox-0.63-1.src.rpm
checksum_type: sha256
description:
  Ansible Developer's (tool)Box, **andebox**, is a script to assist Ansible developers
  by encapsulating some boilerplate tasks. One of the core features is the ability to run
  `ansible-test` on a local copy of a collection repository without having to worry about
  setting environment variables nor having the _expected_ directory structure _above_ the
  collection directory.
  It also allows some basic stats gathering from the `tests/sanity/ignore-X.Y.txt` files.


pkgId: bba489093d84f3663245e2595f66602b57e55057220baa7e280b7017a6301c59
name: python-andeplane-ai
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: A set of AI tools for working with Cognite Data Fusion in Python.
url: https://pypi.org/project/andeplane-ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-andeplane-ai-0.5.2-1.src.rpm
checksum_type: sha256
description:
  A set of AI tools for working with CDF in Python.



  Store and query vector embeddings created from CDF. This can enable a bunch of use cases where the number of vectors aren't that big.

  Install the package

  ```
  %pip install cognite-ai
  ```

  Then you can create vectors from text (both multiple lines or a list of strings) like this

  ```

  from cognite.ai import MemoryVectorStore
  from cognite.client import CogniteClient

  client = CogniteClient()
  vector_store = MemoryVectorStore(client)

  vector_store.store_text("Hi, I am a software engineer working for Cognite.")
  vector_store.store_text("The moon is orbiting the earth, which is orbiting the sun.")
  vector_store.store_text("Coffee can be a great way to stay awake.")

  vector_store.query_text("I am tired, what can I do?")
  ```



  Chat with your data using LLMs. Built on top of [PandasAI](https://docs.pandas-ai.com/en/latest/) version 2.2.15. If you have loaded data into a Pandas dataframe, you can run

  Install the package

  ```
  %pip install cognite-ai
  ```

  Chat with your data

  ```
  from cognite.client import CogniteClient
  from cognite.ai import load_pandasai

  client = CogniteClient()
  SmartDataframe, SmartDatalake, Agent = await load_pandasai()

  workorders_df = client.raw.rows.retrieve_dataframe("tutorial_apm", "workorders", limit=-1)
  workitems_df = client.raw.rows.retrieve_dataframe("tutorial_apm", "workitems", limit=-1)
  workorder2items_df = client.raw.rows.retrieve_dataframe("tutorial_apm", "workorder2items", limit=-1)
  workorder2assets_df = client.raw.rows.retrieve_dataframe("tutorial_apm", "workorder2assets", limit=-1)
  assets_df = client.raw.rows.retrieve_dataframe("tutorial_apm", "assets", limit=-1)

  smart_lake_df = SmartDatalake([workorders_df, workitems_df, assets_df, workorder2items_df, workorder2assets_df], cognite_client=client)
  smart_lake_df.chat("Which workorders are the longest, and what work items do they have?")


  s_workorders_df = SmartDataframe(workorders_df, cognite_client=client)
  s_workorders_df.chat('Which 5 work orders are the longest?')
  ```

  Configure LLM parameters

  ```
  params = {
      "model": "gpt-35-turbo",
      "temperature": 0.5
  }

  s_workorders_df = SmartDataframe(workorders_df, cognite_client=client, params=params)
  ```



  We can also

  ```python
  from cognite.client import CogniteClient
  from cognite.ai import load_pandasai

  client = CogniteClient()
  SmartDataframe, SmartDatalake, Agent = await load_pandasai()


  sales_by_country_df = pd.DataFrame({
      "country": ["United States", "United Kingdom", "France", "Germany", "Italy", "Spain", "Canada", "Australia", "Japan", "China"],
      "revenue": [5000, 3200, 2900, 4100, 2300, 2100, 2500, 2600, 4500, 7000]
  })

  agent = Agent(sales_by_country_df, cognite_client=client)

  print(agent.chat("Which are the top 5 countries by sales?"))
  ```


pkgId: 8923f05273bb0ab7bd9589f1f23c94a3c2918c5d7d87125c8cc496801e0de764
name: python-andeplane-reveal-streamlit-component
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Streamlit wrapper for Cognite Reveal to view 3D content from Cognite Data Fsion
url: https://pypi.org/project/andeplane-reveal-streamlit-component/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-andeplane-reveal-streamlit-component-0.1.5-1.src.rpm
checksum_type: sha256
description:
  This is a Streamlit library that can be used to show 3D models inside a Streamlit app. It works especially good when used inside Streamlit in Fusion, but can also be used in standalone Streamlit apps.



  You simply install it by running
  `pip install cognite-streamlit-reveal`



  Here is an example app

  ```
  import streamlit as st
  import os
  from cognite.streamlit import reveal
  from cognite.client import CogniteClient

  st.subheader("Cognite Reveal Streamlit example")
  client = CogniteClient()
  model_id = 123
  revision_id = 234

  selected_node_id = reveal(client, model_id, revision_id)
  st.markdown("Selected node id: %d!" % int(selected_node_id))

  ```



  It's recommended to add a clean environment. You need `pip` and `node`.

  Clone repo
  `git clone https://github.com/cognitedata/hackathon-reveal-streamlit.git`

  Install Python packages
  `pip install streamlit`

  Install NPM packages and start server

  ```
  cd cognite/streamlit/reveal/frontend
  yarn
  HTTPS=true yarn start
  ```

  Then open https://localhost:3001/ to accept bad certificate.

  Open repo folder in another terminal. Install this package as development package
  `pip install -e .`

  Extract a token from Fusion, and start with

  `COGNITE_TOKEN="TOKEN" streamlit run examples/example.py`



  Make sure you have set (reveal/**init**.py:8)[reveal/__init__.py:8] to `_RELEASE = True`.

  Step 1) Build front end component with `cd reveal/frontend && yarn && yarn build`
  Step 2) Build streamlit component with `python -m build` (hint: `pip install build`)
  Step 3) Start local server `python server.py`

  Open Fusion, create a Streamlit app and add the following the installed package
  `http://localhost:8000/dist/reveal_streamlit_component-0.0.1-py3-none-any.whl`

  It will then load successfully inside Stlite.


pkgId: 43b638a9fb0374246faee0a0a512cb7cea6afbffee36c5a37dcad24dce40f035
name: python-andes
arch: src
version: 1.9.2
epoch: 0
release: 1
summary: Python software for symbolic power system modeling and numerical analysis.
url: https://github.com/curent/andes
rpm_license: GNU Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-andes-1.9.2-1.src.rpm
checksum_type: sha256
description:
  <img src="docs/source/images/sponsors/CURENT_Logo_NameOnTrans.png" alt="CURENT ERC Logo" width="300" height="auto">

  Python software for symbolic power system modeling and numerical analysis, serving as the core simulation engine for the [CURENT Largescale Testbed][LTB Repositories].

  |               | Latest                                                                                                                                        | Stable                                                                                                                                        |
  |---------------|-----------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
  | Documentation | [![Latest Documentation](https://readthedocs.org/projects/andes/badge/?version=latest)](https://andes.readthedocs.io/en/latest/?badge=latest) | [![Documentation Status](https://readthedocs.org/projects/andes/badge/?version=stable)](https://andes.readthedocs.io/en/stable/?badge=stable) |

  | Badges        |                                                                                                                                                                                                                                                     |                                                                                                                                                                                                            |
  |---------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | Downloads     | [![PyPI Version](https://img.shields.io/pypi/v/andes.svg)](https://pypi.python.org/pypi/andes)                                                                                                                                                      | [![Conda Downloads](https://anaconda.org/conda-forge/andes/badges/downloads.svg)](https://anaconda.org/conda-forge/andes)                                                                                  |
  | Try on Binder | [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/curent/andes/master)                                                                                                                                                 |                                                                                                                                                                                                            |
  | Code Quality  | [![Codacy Badge](https://api.codacy.com/project/badge/Grade/17b8e8531af343a7a4351879c0e6b5da)](https://app.codacy.com/app/curent/andes?utm_source=github.com&utm_medium=referral&utm_content=curent/andes&utm_campaign=Badge_Grade_Dashboard) | [![Codecov Coverage](https://codecov.io/gh/curent/andes/branch/master/graph/badge.svg)](https://codecov.io/gh/curent/andes)                                                                          |
  | Build Status  | [![GitHub Action Status](https://github.com/curent/andes/workflows/Python%20application/badge.svg)](https://github.com/curent/andes/actions)                                                                                                  | [![Azure Pipeline build status](https://dev.azure.com/hcui7/hcui7/_apis/build/status/curent.andes?branchName=master)](https://dev.azure.com/hcui7/hcui7/_build/latest?definitionId=1&branchName=master) |


  This software could be of interest to you if you are working on
  DAE modeling, simulation, and control for power systems.
  It has features that may be useful if you are applying
  deep (reinforcement) learning to such systems.

  ANDES is by far easier to use for developing differential-algebraic
  equation (DAE) based models for power system dynamic simulation
  than other tools such as
  [PSAT](http://faraday1.ucd.ie/psat.html),
  [Dome](http://faraday1.ucd.ie/dome.html) and
  [PST](https://www.ecse.rpi.edu/~chowj/),
  while maintaining high numerical efficiency.

  ANDES comes with a rich set of commercial-grade dynamic models
  with all details implemented, including limiters, saturation,
  and zeroing out time constants.

  ANDES produces credible simulation results. The following table
  shows that

  1. For the Northeast Power Coordinating Council (NPCC) 140-bus system
  (with GENROU, GENCLS, TGOV1 and IEEEX1),
  ANDES results match perfectly with that from TSAT.

  2. For the Western Electricity Coordinating Council (WECC) 179-bus
  system (with GENROU, IEEEG1, EXST1, ESST3A, ESDC2A, IEEEST and
  ST2CUT), ANDES results match closely with those from TSAT and PSS/E.
  Note that TSAT and PSS/E results are not identical, either.

  |                                         NPCC Case Study                                                   |                                               WECC Case Study                                           |
  | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
  | ![](https://raw.githubusercontent.com/curent/andes/master/docs/source/images/example-npcc/omega.png)   | ![](https://raw.githubusercontent.com/curent/andes/master/docs/source/images/example-wecc/omega.png) |

  ANDES provides a descriptive modeling framework in a scripting environment.
  Modeling DAE-based devices is as simple as describing the mathematical equations.
  Numerical code will be automatically generated for fast simulation.

  | Controller Model and Equation | ANDES Code |
  | ----------------------------- | ---------- |
  | Diagram:  <br> ![](https://raw.githubusercontent.com/curent/andes/master/docs/source/modeling/example-tgov1/tgov1.png)  <br>  Write into DAEs:  <br>  ![](https://raw.githubusercontent.com/curent/andes/master/docs/source/modeling/example-tgov1/tgov1_eqns.png)  | ![](https://raw.githubusercontent.com/curent/andes/master/docs/source/modeling/example-tgov1/tgov1_class.png) |

  In ANDES, what you simulate is what you document.
  ANDES automatically generates model documentation, and the docs always stay up to date.
  The screenshot below is the generated documentation for the implemented IEEEG1 model.

  ![](https://raw.githubusercontent.com/curent/andes/master/docs/source/images/misc/ieeeg1-screenshot.png)

  In addition, ANDES features

  * a rich library of transfer functions and discontinuous components (including limiters, deadbands, and
    saturation functions) available for model prototyping and system analysis.
  * industry-grade second-generation renewable models (solar PV, type 3 and type 4 wind),
    distributed PV and energy storage model.
  * routines including Newton method for power flow calculation, implicit trapezoidal method for time-domain
    simulation, and full eigenvalue analysis.
  * developed with performance in mind. While written in Python, ANDES can
    finish a 20-second transient simulation of a 2000-bus system in a few seconds on a typical desktop computer.
  * out-of-the-box PSS/E raw and dyr data support for available models. Once a model is developed, inputs from a
    dyr file can be immediately supported.

  ANDES is currently under active development.
  Use the following resources to get involved.

  + Start from the [documentation][readthedocs] for installation and tutorial.
  + Check out examples in the [examples folder][examples]
  + Read the model verification results in the [examples/verification folder][verification]
  + Try in Jupyter Notebook on [Binder][Binder]
  + Ask a question in the [GitHub Discussions][Github Discussions]
  + Report bugs or issues by submitting a [GitHub issue][GitHub issues]
  + Submit contributions using [pull requests][GitHub pull requests]
  + Read release notes highlighted [here][release notes]
  + Check out and and cite our [paper][arxiv paper]



  If you use ANDES for research or consulting, please cite the following paper in your publication that uses
  ANDES

  ```
  H. Cui, F. Li and K. Tomsovic, "Hybrid Symbolic-Numeric Framework for Power System Modeling and Analysis," in IEEE Transactions on Power Systems, vol. 36, no. 2, pp. 1373-1384, March 2021, doi: 10.1109/TPWRS.2020.3017019.
  ```


  Please let us know if you are using ANDES for research or projects.
  We kindly request you to cite our [paper][arxiv paper] if you find ANDES useful.

  ![Natinoal Science Foundation](https://raw.githubusercontent.com/CURENT/andes/master/docs/source/images/sponsors/nsf.jpg)
  ![US Department of Energy](https://raw.githubusercontent.com/CURENT/andes/master/docs/source/images/sponsors/doe.png)
  ![CURENT ERC](https://raw.githubusercontent.com/CURENT/andes/master/docs/source/images/sponsors/curent.jpg)
  ![Lawrence Livermore National Laboratory](https://raw.githubusercontent.com/CURENT/andes/master/docs/source/images/sponsors/llnl.jpg)
  ![Idaho National Laboratory](https://raw.githubusercontent.com/CURENT/andes/master/docs/source/images/sponsors/inl.jpg)


  This work was supported in part by the Engineering Research Center
  Program of the National Science Foundation and the Department of Energy
  under NSF Award Number EEC-1041877 and the CURENT Industry Partnership
  Program.

  This work was supported in part by the Advanced Grid Research and Development Program
  in the Office of Electricity at the U.S. Department of Energy.

  See [GitHub contributors][GitHub contributors] for the contributor list.



  ANDES is licensed under the [GPL v3 License](./LICENSE).

  * * *

  [GitHub releases]:       https://github.com/CURENT/andes/releases
  [GitHub issues]:         https://github.com/CURENT/andes/issues
  [Github Discussions]:    https://github.com/CURENT/andes/discussions
  [GitHub insights]:       https://github.com/CURENT/andes/pulse
  [GitHub pull requests]:  https://github.com/CURENT/andes/pulls
  [GitHub contributors]:   https://github.com/CURENT/andes/graphs/contributors
  [readthedocs]:           https://andes.readthedocs.io
  [release notes]:         https://andes.readthedocs.io/en/latest/release-notes.html
  [arxiv paper]:           https://arxiv.org/abs/2002.09455
  [tutorial]:              https://andes.readthedocs.io/en/latest/tutorial.html#interactive-usage
  [examples]:              https://github.com/CURENT/andes/tree/master/examples
  [verification]:          https://github.com/CURENT/andes/tree/master/examples/verification
  [Binder]:                https://mybinder.org/v2/gh/curent/andes/master
  [LTB Repositories]:      https://github.com/CURENT


pkgId: 09443e9133dc8651ef5b8472d3840a041604df46dd809c9788b947d186e11150
name: python-andreani-aa-tools
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: Common functions and protocols used by the Andreani Advanced Analytics team
url: https://github.com/eloychang/andreani_aa_tools
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-andreani-aa-tools-0.0.21-1.src.rpm
checksum_type: sha256
description:
  ```

  pip install andreani-aa-tools

  ```



  ```

  import aa_tools

  ```



  - Haversine

  ```

  from aa_tools import logger, haversine

  if __name__ == "__main__":

      log = logger("test.py", "main")

      result = haversine(-58.490160, -34.566116, -58.485096, -34.572123)

      log.log_console(f"Haversine distance: {result}", "INFO")

      log.close()

  ```



  * Haversine: Distancia euclidia entre dos puntos.

  * Logger: Maneja el log según los lineamientos de Andreani.

  * Datalake: Interfaz de conexión al datalake para descargar y cargar archivos csv, parquet y/o json.




  * Distancia de ruta entre dos puntos.

  * Model training

  * Conexión a Elastic Search

rpm_license:
  MIT License  Copyright (c) 2022 Eloy Chang  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: feb31bafddfbeed3b0dee3dd7b573ddb0dafb43e829cfacb4cfd191ef6b52b6a
name: python-andres-server
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Andre's Rainbow Land with cute kittens and AI
url: https://pypi.org/project/andres-server/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-andres-server-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Andre's Rainbow Land with cute kittens and AI





  The server implements a simple note storage system with:
  - Custom note:// URI scheme for accessing individual notes
  - Each note resource has a name, description and text/plain mimetype



  The server provides a single prompt:
  - summarize-notes: Creates summaries of all stored notes
    - Optional "style" argument to control detail level (brief/detailed)
    - Generates prompt combining all current notes with style preference



  The server implements one tool:
  - add-note: Adds a new note to the server
    - Takes "name" and "content" as required string arguments
    - Updates server state and notifies clients of resource changes



  [TODO: Add configuration details specific to your implementation]







  On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
  On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

  <details>
    <summary>Development/Unpublished Servers Configuration</summary>
    ```
    "mcpServers": {
      "andres_server": {
        "command": "uv",
        "args": [
          "--directory",
          "D:\Projects\_serious\andres_server",
          "run",
          "andres_server"
        ]
      }
    }
    ```
  </details>

  <details>
    <summary>Published Servers Configuration</summary>
    ```
    "mcpServers": {
      "andres_server": {
        "command": "uvx",
        "args": [
          "andres_server"
        ]
      }
    }
    ```
  </details>





  To prepare the package for distribution:

  1. Sync dependencies and update lockfile:
  ```bash
  uv sync
  ```

  2. Build package distributions:
  ```bash
  uv build
  ```

  This will create source and wheel distributions in the `dist/` directory.

  3. Publish to PyPI:
  ```bash
  uv publish
  ```

  Note: You'll need to set PyPI credentials via environment variables or command flags:
  - Token: `--token` or `UV_PUBLISH_TOKEN`
  - Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`



  Since MCP servers run over stdio, debugging can be challenging. For the best debugging
  experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


  You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

  ```bash
  npx @modelcontextprotocol/inspector uv --directory D:\\Projects\\_serious\\andres_server run andres-server
  ```


  Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.


pkgId: 91435db29d26a379dcb2b374850c80d89dde1453e0fc90d25aa8cd4e1c4ad75b
name: python-androguard
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: Androguard is a full python tool to play with Android files.
url: https://github.com/androguard/androguard
rpm_license: Apache Licence, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-androguard-4.1.2-1.src.rpm
checksum_type: sha256
description:
  ![banner](https://raw.githubusercontent.com/androguard/androguard/master/assets/web/androguardwithname.jpg)



  [![PyPI Upload](https://github.com/androguard/androguard/actions/workflows/pythonpublish.yml/badge.svg)](https://github.com/androguard/androguard/actions/workflows/pythonpublish.yml)
  ![PyPI - Version](https://img.shields.io/pypi/v/androguard)
  ![Static Badge](https://img.shields.io/badge/Documentation-InProgress-red)



  Quick installation:
  ~~~~
  pip install androguard
  ~~~~

  > [!IMPORTANT]
  > Versions >= 4.0.0 are new releases after a long time, where the project has substantial differences from the previous stable version 3.3.5 from 2019. This means that certain functionalities have been removed. If you notice an issue with your project using tha latest version, please open up an [issue](https://github.com/androguard/androguard/issues).


  **Documentation contains outdated information - In progress of updating**

  The [wiki](https://github.com/androguard/androguard/wiki) page is the most recently updated source.

  Additional documentation that contains outdated information is available at [ReadTheDocs](http://androguard.readthedocs.io/en/latest/).




  Androguard is a full python tool to play with Android files.

  * DEX, ODEX
  * APK
  * Android's binary xml
  * Android resources
  * Disassemble DEX/ODEX bytecodes
  * Basic Decompiler for DEX/ODEX files
  * Frida support for easy dynamic analysis
  * SQLite database to save the session



  Androguard + tools: Anthony Desnos (desnos at t0t0.fr).

  DAD (DAD is A Decompiler): Geoffroy Gueguen (geoffroy dot gueguen at gmail dot com)


  In alphabetical order

  * [AndroPyTool](https://github.com/alexMyG/AndroPyTool)
  * [AppKnox](http://appknox.com)
  * [Cuckoo Sandbox](https://cuckoosandbox.org)
  * [Deckard](https://github.com/hrkfdn/deckard)
  * [Droidbot](https://github.com/honeynet/droidbot)
  * [Droidstatx](https://github.com/integrity-sa/droidstatx)
  * [εxodus](https://github.com/Exodus-Privacy/exodus)
  * [F-Droid Server](https://gitlab.com/fdroid/fdroidserver)
  * [gplaycli](https://github.com/matlink/gplaycli)
  * [Koodous](https://koodous.com)
  * [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
  * [qiew](https://github.com/mtivadar/qiew)
  * [Quark-Engine](https://github.com/quark-engine/quark-engine)
  * [Viper Framework](https://github.com/viper-framework/viper)
  * ... and many more!

  You are using Androguard and are not listed here? Just create a [ticket](https://github.com/androguard/androguard/issues) or send us a [pull request](https://github.com/androguard/androguard/pulls) with your project!





  Copyright (C) 2012 - 2023, Anthony Desnos (desnos at t0t0.fr)
  All rights reserved.

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

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

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



  Copyright (C) 2012 - 2016, Geoffroy Gueguen (geoffroy dot gueguen at gmail dot com)
  All rights reserved.

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

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

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


pkgId: 2a373bb5a9c9b233a41420616ec5efaae4d0e96576eac02b98e0e32589b7e281
name: python-android-sms-gateway
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A client library for sending and managing SMS messages via the SMS Gateway for Android API
url: https://sms-gate.app
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-android-sms-gateway-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg?style=for-the-badge)](https://github.com/android-sms-gateway/client-py/blob/main/LICENSE)
  [![GitHub Issues](https://img.shields.io/github/issues/capcom6/android-sms-gateway-py.svg?style=for-the-badge)](https://github.com/android-sms-gateway/client-py/issues)
  [![GitHub Stars](https://img.shields.io/github/stars/capcom6/android-sms-gateway-py.svg?style=for-the-badge)](https://github.com/android-sms-gateway/client-py/stargazers)
  [![GitHub Forks](https://img.shields.io/github/forks/capcom6/android-sms-gateway-py.svg?style=for-the-badge)](https://github.com/android-sms-gateway/client-py/network)
  [![PyPI Version](https://img.shields.io/pypi/v/android-sms-gateway.svg?style=for-the-badge)](https://pypi.org/project/android-sms-gateway/)
  [![Python Version](https://img.shields.io/pypi/pyversions/android-sms-gateway.svg?style=for-the-badge)](https://pypi.org/project/android-sms-gateway/)
  [![Downloads](https://img.shields.io/pypi/dm/android-sms-gateway.svg?style=for-the-badge)](https://pypi.org/project/android-sms-gateway/)

  This is a Python client library for interfacing with the [SMS Gateway for Android](https://sms-gate.app) API.



  - Python >= 3.7
  - One of the following packages:
      - [requests](https://pypi.org/project/requests/)
      - [aiohttp](https://pypi.org/project/aiohttp/)
      - [httpx](https://pypi.org/project/httpx/)

  Optional:

  - [pycryptodome](https://pypi.org/project/pycryptodome/) - end-to-end encryption support



  ```bash
  pip install android_sms_gateway
  ```

  You can also install with preferred http client:

  ```bash
  pip install android_sms_gateway[requests]
  pip install android_sms_gateway[aiohttp]
  pip install android_sms_gateway[httpx]
  ```

  With encrypted messages support:

  ```bash
  pip install android_sms_gateway[encryption]
  ```



  Here's an example of using the client:

  ```python
  import asyncio
  import os

  from android_sms_gateway import client, domain, Encryptor

  login = os.getenv("ANDROID_SMS_GATEWAY_LOGIN")
  password = os.getenv("ANDROID_SMS_GATEWAY_PASSWORD")


  message = domain.Message(
      "Your message text here.",
      ["+1234567890"],
  )

  def sync_client():
      with client.APIClient(
          login,
          password,
          
      ) as c:
          state = c.send(message)
          print(state)

          state = c.get_state(state.id)
          print(state)


  async def async_client():
      async with client.AsyncAPIClient(
          login,
          password,
          
      ) as c:
          state = await c.send(message)
          print(state)

          state = await c.get_state(state.id)
          print(state)

  print("Sync client")
  sync_client()

  print("\nAsync client")
  asyncio.run(async_client())
  ```



  There are two client classes: `APIClient` and `AsyncAPIClient`. The
  `APIClient` is synchronous and the `AsyncAPIClient` is asynchronous. Both
  implement the same interface and can be used as context managers.



  There are two methods:

  - `send(message: domain.Message) -> domain.MessageState`: Send a new SMS message.
  - `get_state(_id: str) -> domain.MessageState`: Retrieve the state of a previously sent message by its ID.



  The API clients abstract away the HTTP client used to make requests. The library includes support for some popular HTTP clients and trys to discover them automatically:

  - [requests](https://pypi.org/project/requests/) - `APIClient` only
  - [aiohttp](https://pypi.org/project/aiohttp/) - `AsyncAPIClient` only
  - [httpx](https://pypi.org/project/httpx/) - `APIClient` and `AsyncAPIClient`

  Also you can implement your own HTTP client that conforms to the `http.HttpClient` or `ahttp.HttpClient` protocol.



  Contributions are welcome! Please submit a pull request or create an issue for anything you'd like to add or change.



  This library is open-sourced software licensed under the [Apache-2.0 license](LICENSE).


pkgId: 750c3c676e0fe9bdba98657ed1f23e9507c53a39f0b33d66fd9dcb00c1eb2b6f
name: python-androidautotest
arch: src
version: 0.0.2.33
epoch: 0
release: 1
summary: android test framework using adb connection and template matching in opencv
url: https://github.com/15045120/AndroidTest
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-androidautotest-0.0.2.33-1.src.rpm
checksum_type: sha256
description:
  The package is for android auto test, based on Python enviroment.

  Basic thought is using ADB (Android Debug Bridge) to send command to Android test Phone connected with the PC and match picture by match template algorithm in opencv-python.

   1.ADB ([Android Debug Bridge](https://github.com/15045120/AndroidTest/tree/master/dependency/adb))


  2.ASM ([Android Screen Monitor](https://github.com/15045120/AndroidTest/blob/master/dependency/asm.jar))

   Use to capture partial picture, and you need to install JDK in your computer before running it.

   Then adjust zoom to 50%, you can also set zoom to other size, but need to add some code in your case source file after your create your case file:
  ```python

  ASM.ZOOM_SIZE = 25
  ```

  3.Tesseract ([Tesseract-OCR](https://github.com/tesseract-ocr/tesseract))

   If you want to use the mechod 'image_to_string' in the 'androidautotest.api' which can recognize text in pictures, you need to install Tesseract and install testdata necessary like chinese 'chi_sim'.



   1.Install androidautotest
  ```bash
  pip install androidautotest
  ```
  Follow information indicate you have installed androidautotest successfully.
  ```bash
  > python -m androidautotest
  usage:
    androidautotest --installdep
    androidautotest --startasm
    androidautotest --newcase <NEWCASE> --savedir <SAVEDIR>
    androidautotest --casedir <CASEDIR> --device <DEVICE> --times <TIMES>

  A framework to run test case for android automated test

  optional arguments:
    -V, --version        Print version and exit
    -h, --help           Print this help message and exit

  install dependency:
    --installdep         install dependency of androidautotest

  start asm:
    --startasm           start Android Screen Monitor

  create case:
    --newcase <NEWCASE>  New case name to create
    --savedir <SAVEDIR>  Path to save new case

  run case:
    --casedir <CASEDIR>  Case path to run
    --device <DEVICE>    Device to switch
    --times <TIMES>      Times of case running
  ```
   2.install requirements

  ```bash
  python -m androidautotest --installdep
  ```
   3.start Android Screen Monitor(First, connect your Android Phone with PC, and open adb debug mode), then run follow command:

  ```bash
  python -m androidautotest --startasm
  ```
   4.create a new case to start your test task with Android Phone(For example: to create a new case named 'case001').

  ```bash
  python -m androidautotest --newcase case001 --savedir E:\AndroidTest\workspace
  ```

  You can find the complete AndroidTest API documentation on  [readthedocs](http://androidtest.readthedocs.io/).

  ```python

  from androidautotest.api import *


  keyevent(HOME)
  keyevent(HOME,device='HMKNW17421063974')


  while not exists(Template(r'pic\20191215121636.png')):
  	flick((400,400),DIR_LEFT,step=2)
  touch(Template(r'pic\20191215121636.png'))
  touch(Template(r'pic\20191215134814.png'))


  if exists(Template(r'pic\20191215143440.png')):
  	touch(Template(r'pic\20191215142057.png'))
  	text('15045120')
  else:
  	touch([530,142])
  	text('15045120')


  assert_exists(Template(r'pic\20191215142425.png'))

  end()
  ```
  Once you finish your code writing, you can run your case.
  1.If you connect one Android Phone with your PC, and run for once time, simple wirte as following
  ```bash
  python -m androidautotest --casedir E:\AndroidTest\workspace\case001.air --device HMKNW17421063974 --times 5
  ```
  2.If you connect more than one Android Phone with your PC, run case with Android Phone which's serial number is 'HMKNW17421063974' for 5 times, you can write as following.
  ```bash
  python -m androidautotest --casedir E:\AndroidTest\workspace\case001.air --device HMKNW17421063974 --times 5
  ```

  And there are three log files you can use to analyze your test plan after run your case.

  In case001.air\log\case001.log.XXX
  <table>
  <thead>
  <tr><th>File Name</th><th>Description</th></tr>
  </thead></tr>
  </thead>
  <tbody>
  <tr><td>log_case001_XXX.txt</td><td>all log output</td></tr>
  <tr><td>serial_log_case001_XXX.txt</td><td>adb log output </td></tr>
  <tr><td>report_case001_XXX.html</td><td>report of case run</td></tr>
  </tbody>
  </table>


pkgId: e91b924d527dfec558ac0f036dcce378080cebfcccf2fa760adbb3c43156b52f
name: python-androidpublisher
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/androidpublisher/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-androidpublisher-0.1.10-1.src.rpm
checksum_type: sha256
description:
  **Usage**:

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

  **Options**:

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

  **Commands**:

  * `upload`



  **Usage**:

  ```console
  $ androidpublisher upload [OPTIONS] PACKAGE_NAME
  ```

  **Arguments**:

  * `PACKAGE_NAME`: [required]

  **Options**:

  * `--aab-file FILE`: [default: app.aab]
  * `--track [internal|alpha|beta|production|rollout]`: [default: internal]
  * `--json-key FILE`: [default: credential.json]
  * `--help`: Show this message and exit.


pkgId: f5f7778d3f9b1dd6ce645a56c29bc7d610ba53792b82d88c8c3ce77dd6883220
name: python-anduin
arch: src
version: 8.4.38
epoch: 0
release: 1
url: https://github.com/campanulamediuml/Anduin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anduin-8.4.38-1.src.rpm
checksum_type: sha256
summary:
  a lite mysql & sqlite3 & async_redis connect engine, mapping table into k-v structure , support async work

description:
  一个轻量化的sqlite/mysql数据序列化操作引擎
  名称来自《指环王》

  <=========使用指南=========>

  参见github wiki页面

  [使用指南](https://github.com/campanulamediuml/Anduin/wiki)


pkgId: 9003a1f4b946408249e6614a9dd96750e3aef7cbe3398655d5cceec962359c59
name: python-anduindata
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: a mysql connector
url: https://github.com/campanulamediuml/Anduin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anduindata-1.3.4-1.src.rpm
checksum_type: sha256
description:
  a lite mysql connector...
  Name from the Lord of Ring

  <=========how to use=========>

  from anduin.server import Data

  cond = [
      (col1,'=',val1),
      (col2,'=',val2),
      ....]

  fields = [
      col1,
      col2
      ...]

  params = {
      key1:val1,
      key2:val2,
      ...}

  find one line of data:

      Data.find(__TableName__,conditions=cond,fields=fields)

      return a python dict like { col1:value1,col2:value2...}

  find datas

      Data.select(__TableName__,conditions=cond,fields=fields)

      return a python list like [{ col1:value1,col2:value2...}]

  update data:

      Data.update(__TableName__,conditions=cond,params=params)

      return None

  insert data:

      Data.insert(__TableName__,params=params)

      return None

  delete data:

      Data.delete(__TableName__,conditions=cond)

      return None

  using Data.query() to execute sql directly like Data.query('select * from table')


pkgId: 62fda8666b4df465249a6bb3444538204de38f5077786804d60d935713292030
name: python-ane-transformers
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Reference PyTorch implementation of Transformers for Apple Neural Engine (ANE) deployment
url: https://github.com/apple/ml-ane-transformers
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ane-transformers-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Use `ane_transformers` as a reference PyTorch implementation if you are considering deploying your Transformer models on Apple devices with an A14 or newer and M1 or newer chip to achieve up to **10 times faster** and **14 times** lower peak memory consumption compared to baseline implementations.

  `ane_transformers.reference` comprises a standalone reference implementation and `ane_transformers.huggingface` comprises optimized versions of [Hugging Face](https://huggingface.co/models) model classes such as `distilbert` to demonstrate the application of the optimization principles laid out in our research article on existing third-party implementations.

  Please check out our [research article](https://machinelearning.apple.com/research/apple-neural-engine) for a detailed explanation of the optimizations as well as interactive figures to explore latency and peak memory consumption data from our case study: [Hugging Face distilbert](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english) model deployment on various devices and operating system versions. Below figures are non-interactive snapshots from the research article for iPhone 13 with iOS16.0 installed:

  <img src="assets/iPhone13_iOS16_latency_comparison.png">

  <img src="assets/iPhone13_iOS16_memory_comparison.png">



  This tutorial is a step-by-step guide to the model deployment process from the case study in our research article. The same code is used to generate the Hugging Face distilbert performance data in the figures above.

  In order to begin the optimizations, we initialize the baseline model as follows:

  ```python
  import transformers
  model_name = "distilbert-base-uncased-finetuned-sst-2-english"
  baseline_model = transformers.AutoModelForSequenceClassification.from_pretrained(
      model_name,
      return_dict=False,
      torchscript=True,
  ).eval()
  ```

  Then we initialize the mathematically equivalent but optimized model, and we restore its parameters using that of the baseline model:

  ```python
  from ane_transformers.huggingface import distilbert as ane_distilbert
  optimized_model = ane_distilbert.DistilBertForSequenceClassification(
      baseline_model.config).eval()
  optimized_model.load_state_dict(baseline_model.state_dict())
  ```

  Next we create sample inputs for the model:

  ```python
  tokenizer = transformers.AutoTokenizer.from_pretrained(model_name)
  tokenized = tokenizer(
      ["Sample input text to trace the model"],
      return_tensors="pt",
      max_length=128,  # token sequence length
      padding="max_length",
  )
  ```

  We then trace the optimized model to obtain the expected input format (Torchscript) for the coremltools conversion tool.

  ```python
  import torch
  traced_optimized_model = torch.jit.trace(
      optimized_model,
      (tokenized["input_ids"], tokenized["attention_mask"])
  )
  ```

  Finally, we use coremltools to generate the Core ML model package file and save it.

  ```python
  import coremltools as ct
  import numpy as np
  ane_mlpackage_obj = ct.convert(
      traced_optimized_model,
      convert_to="mlprogram",
      inputs=[
          ct.TensorType(
                  f"input_{name}",
                      shape=tensor.shape,
                      dtype=np.int32,
                  ) for name, tensor in tokenized.items()
              ],
              compute_units=ct.ComputeUnit.ALL,
  )
  out_path = "HuggingFace_ane_transformers_distilbert_seqLen128_batchSize1.mlpackage"
  ane_mlpackage_obj.save(out_path)
  ```

  To verify performance, developers can now launch Xcode and simply add this model package file as a resource in their projects. After clicking on the Performance tab, the developer can generate a performance report on locally available devices, for example, on the Mac that is running Xcode or another Apple device that is connected to that Mac. The figure below shows a performance report generated for this model on an iPhone 13 Pro Max with iOS 16.0 installed.

  <img src="assets/xcode_performance_report_comparison.png">


  Based on the figure above, the latency is improved by a factor of 2.84 times for the sequence length of 128 and batch size of 1 that were chosen for the tutorial. Higher sequence lengths, such as 512, and batch sizes, such as 8, will yield up to **10 times lower latency** and **14 times lower peak memory consumption**. Please refer to Figure 2 from our [research article](https://machinelearning.apple.com/research/apple-neural-engine) for detailed and interactive performance data.

  Note that the load and compilation times increase due to the number of operations increasing in the optimized model but these are one-time costs and user experience will not be affected if the model is loaded asynchronously.

  Note that 4 of the 606 operations in the optimized model are executed on the CPU. These are the embedding lookup related operations and they are more efficient to do on the CPU for this particular model configuration.


  The unit tests measure, among other things, the ANE speed-up factor. Since the device spec for this reference implementation is M1 or newer chips for the Mac and A14 and newer chips for the iPhone and iPad, the speed-up unit tests will print a warning message if executed on devices outside of this spec. Even if the model is generated using an out of spec Mac, the model should work as expected on in-spec devices.


  - Fastest: `pip install ane_transformers`
  - Locally editable: `pip install -e .`
  - If installation fails with `ERROR: Failed building wheel for tokenizers` or `error: can't find Rust compiler`, please follow this [solution](https://github.com/huggingface/transformers/issues/2831#issuecomment-592724471)


pkgId: 92d0db3b678ae14e9f3ddfb26b98329dcd71696f2126f84aa1e100a5b527157e
name: python-anedya-dev-sdk
arch: src
version: 0.1.7
epoch: 0
release: 1
url: https://github.com/anedyaio/anedya-dev-sdk-python
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anedya-dev-sdk-0.1.7-1.src.rpm
checksum_type: sha256
summary:
  Anedya python based SDK for IoT devices. This SDK streamlines connectivity with Anedya platform. As this SDK is in Beta release, future versions may have breaking changes.

description:
  [<img alt="PyPI" src="https://img.shields.io/pypi/v/anedya-dev-sdk?style=for-the-badge">](https://pypi.org/project/anedya-dev-sdk/)&nbsp;&nbsp;[<img alt="Anedya Documentation" src="https://img.shields.io/badge/Anedya-Documentation-blue?style=for-the-badge">](https://docs.anedya.io?utm_source=github&utm_medium=link&utm_campaign=github-sdk&utm_content=python)


   <!---<div style="width:20%; margin:0 auto;margin-bottom:50px;margin-top:50px;">-->
  <p align="center">
      <img src="https://cdn.anedya.io/anedya_black_banner.png" alt="Logo">
  </p>
  <!--</div>-->



  The **Anedya SDK** is a Python package designed to provide an easy-to-use interface for [Anedya](https://anedya.io/?utm_source=github&utm_medium=link&utm_campaign=github-sdk&utm_content=python) cloud services, which enables seamless connectivity and data retrieval from IoT devices. This SDK supports both MQTT and HTTP communication methods.

  This SDK wraps the Device APIs available in the [Anedya Documentation](https://docs.anedya.io?utm_source=github&utm_medium=link&utm_campaign=github-sdk&utm_content=python)

  This is a Device SDK, i.e. it is meant to be used by an IoT device.



  To install the Anedya SDK, you can use `pip`:

  ```bash
  pip install anedya-dev-sdk
  ```


pkgId: 2394a3711d896851a86814cb0ad25ffa37d03f67564128d592fd88581c9400c6
name: python-anemoi-models
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A package to hold various functions to support training of ML models.
url: https://github.com/ecmwf/anemoi-models/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anemoi-models-0.4.0-1.src.rpm
checksum_type: sha256
description:
  **DISCLAIMER**
  This project is **BETA** and will be **Experimental** for the foreseeable future.
  Interfaces and functionality are likely to change, and the project itself may be scrapped.
  **DO NOT** use this software in any project/software that is operational.

  Miscellanous tools for training data-driven weather forecasts.



  The documentation can be found at https://anemoi-models.readthedocs.io/.



  Install via `pip` with:

  ```
  $ pip install anemoi-models
  ```



  ```
  Copyright 2024, Anemoi contributors.

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

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

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

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

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


pkgId: 126c308fd7b65f3d9f932040a7a65336ce01e0c598a5db2ed68b800cee23faa1
name: python-anemoi-transform
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/ecmwf/anemoi-transform/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anemoi-transform-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  A package to hold various data transformation functions to support training of ML models on ECMWF data.

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


pkgId: eee9b0e680789cf57788a1f9162bfa4cb474c921f1a860456c52e93d1f45b6c4
name: python-aneris-iamc
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Harmonize Integrated Assessment Model Emissions Trajectories
url: https://pypi.org/project/aneris-iamc/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aneris-iamc-0.4.2-1.src.rpm
checksum_type: sha256
description:
  **To reproduce harmonization routines from [Gidden et al.
  (2019)](https://gmd.copernicus.org/articles/12/1443/2019/), use `v0.3.2` (or
  earlier). Subsequent versions introduce backwards incompatibilities.**


pkgId: 4665e8058dfbd7b7e58babc5afc09b23eba59a916a422ff89a0569c852961dfc
name: python-anesthetic
arch: src
version: 2.9.1
epoch: 0
release: 1
summary: nested sampling post-processing
url: https://github.com/handley-lab/anesthetic
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anesthetic-2.9.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2019 Will Handley  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: db4b4544dc4c90f875e8a7ba2872d4b927ed633928b67a0f70a97648b917792c
name: python-angelcommunity
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Community Discovery algorithm
url: https://github.com/GiulioRossetti/ANGEL
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angelcommunity-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Test and Coverage (Ubuntu)](https://github.com/GiulioRossetti/ANGEL/actions/workflows/test_ubuntu.yml/badge.svg)](https://github.com/GiulioRossetti/ANGEL/actions/workflows/test_ubuntu.yml)
  [![codecov](https://codecov.io/gh/GiulioRossetti/ANGEL/branch/master/graph/badge.svg?token=3YJOEVK02B)](https://codecov.io/gh/GiulioRossetti/ANGEL)
  [![PyPI download month](https://img.shields.io/pypi/dm/angel-cd.svg?color=blue&style=plastic)](https://pypi.python.org/pypi/angel-cd/)

  Community discovery in complex networks is an interesting problem with a number of applications, especially in the knowledge extraction task in social and information networks.
  However, many large networks often lack a particular community organization at a global level.
  In these cases, traditional graph partitioning algorithms fail to let the latent knowledge embedded in modular structure emerge, because they impose a top-down global view of a network.
  We propose here a simple local-first approach to community discovery, namely **Angel**, able to unveil the modular organization of real complex networks.
  This is achieved by democratically letting each node vote for the communities it sees surrounding it in its limited view of the global system, i.e. its ego neighborhood, using a label propagation algorithm; finally, the local communities are merged into a global collection.

  Moreover, we provide also an evolution of Angel, namely **ArchAngel**, designed to extract community from evolving network topologies.

  **Note:** Angel has been integrated within [CDlib](http://cdlib.readthedocs.io) a python package dedicated to community detection algorithms, check it out!



  You can easily install the updated version of Angel (and Archangel) by using pip:

  ```bash
  pip install angel_community
  ```

  or using conda

  ```bash
  conda install -c giuliorossetti angel_community
  ```



  *Required input format(s)*

  Angel:
  .ncol edgelist (nodes represented with integer ids).

  ```
  node_id0    node_id1
  ```

  ArchAngel:
  Extended .ncol edgelist (nodes represented with integer ids).

  ```
  node_id0    node_id1	snapshot_id
  ```


  Angel is written in python and requires the following package to run:
  - python 3.x
  - python-igraph
  - networkx
  - tqdm



  ```python
  import angel as a
  an = a.Angel(filename, threshold=0.4, min_comsize=3, outfile_name="angel_communities.txt")
  an.execute()
  ```

  Where:
  * filename: edgelist filename
  * threshold: merging threshold in [0,1]
  * min_com_size: minimum size for communities
  * out_filename: desired filename for the output

  or alternatively

  ```python
  import angel as a
  an = a.Angel(graph=g, threshold=0.4, min_com_size=3, out_filename="communities.txt")
  an.execute()
  ```

  Where:
  * g: an igraph.Graph object



  ```python
  import angel as a
  aa = a.ArchAngel(filename, threshold=0.4, match_threshold=0.4, min_com_size=3, outfile_path="./")
  aa.execute()
  ```

  Where:
  * filename: edgelist filename
  * threshold: merging threshold in [0,1]
  * match_threshold: cross-time community matching threshold in [0, 1]
  * min_com_size: minimum size for communities
  * outfile_path: path for algorithm output files


pkgId: 7f5a676d099cf10018c95f03ea8802ca7440896990e49a3b70c5674bedc14fc5
name: python-angles
arch: src
version: 2.0
epoch: 0
release: 1
summary: Classes for representing angles, and positions on a unit sphere.
url: http://github.com/phn/angles
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angles-2.0-1.src.rpm
checksum_type: sha256
description:
  The Angles module defines several classes for representing angles, and positions
  on a sphere. It also has several functions for performing common operations
  on angles, such as unit conversion, normalization, creating string
  representations and others.
  The position of M100 reported by SIMBAD is "12 22 54.899 +15 49 20.57". We can
  easily parse these coordinates as follows:
      >>> from __future__ import print_function
      >>> from angles import AngularPosition
      >>> a = AngularPosition.from_hd("12 22 54.899 +15 49 20.57")
      >>> a.alpha
      3.24157813039
      >>> a.delta
      0.276152636198
      >>> print(a.alpha)
      +12HH 22MM 54.899SS
      >>> print(a.delta)
      +15DD 49MM 20.570SS
      >>> a.alpha.hms.hms
      (1, 12, 22, 54.899)
      >>> a.delta.dms.dms
      (1, 15, 49, 20.57)
      >>> a.alpha.dms.dms
      (1, 185, 43, 43.485)
      >>> a.delta.hms.hms
      (1, 1, 3, 17.371)
      >>> a.alpha.r, a.alpha.d, a.alpha.h, a.alpha.arcs
      (3.2415781303913653, 185.72874583333328, 12.381916388888886, 668623.4849999998)
      >>> a.delta.r, a.delta.d, a.delta.h, a.delta.arcs
      (0.27615263619797403, 15.822380555555556, 1.0548253703703705, 56960.57)


pkgId: cf0747b54f7b262a084722e695085966dc62b57d625fd62ff14b105bcef5b453
name: python-angmom-suite
arch: src
version: 1.20.0
epoch: 0
release: 1
summary: A package for working with phenomenological spin and angular momentum operators
url: https://gitlab.com/chilton-group/angmom_suite
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angmom-suite-1.20.0-1.src.rpm
checksum_type: sha256
description:
  `angmom_suite` is a python package for working with phenomenological spin and angular momentum operators



  Install `angmom_suite` using `pip` (if using a shared machine, add the `--user` argument after `install`)

  ```
  pip install angmom_suite
  ```



  Update the code using `pip` (if using a shared machine, add the `--user` argument after `install`)

  ```
  pip install angmom_suite --upgrade
  ```



  **Only do this if you are developing (i.e. changing) the code.**

  Clone a copy of this repository, preferably while within a directory called git

  ```
  mkdir -p git; cd git
  git clone https://gitlab.com/chilton-group/angmom_suite
  ```

  Navigate to the package directory

  ```
  cd angmom_suite/packages
  ```

  and install the package in editable mode (if using a shared machine, add the `--user` argument after `install`)

  ```
  pip install -e .
  ```

  When you're done developing (i.e. your changes have been merged to the master),
  or if you just want to use the current release version of the package, uninstall using `pip`

  ```
  pip uninstall angmom_suite
  ```

  and follow the Installation via `pip` instructions above.



  The `angmom_suite` command line interface can be invoked with

  ```
  angmom_suite -h
  ```

  which prints a list of available subprograms.

  Alternatively, the individual submodules can be imported into a python program or script as per usual.



  **Only do this if you are told to.**

  To build a copy of the `angmom_suite` `.whl` file, move to the `package` directory.

  Now run

  ```
  ./build_binaries.sh
  ```

  Then install the `.whl` file with `pip` (if using a shared machine, add the `--user` argument after `install`)

  ```
  pip install dist/*.whl
  ```



  The [documentation](https://chilton-group.gitlab.io/angmom_suite/) for this package is hosted by gitlab, and is automatically generated whenever new code is committed to the `main` branch. The automatic generation of this documentation relies on a common layout for comments and docstrings within the code, see [contributing](https://gitlab.com/chilton-group/group-wiki/-/wikis/Contributing:-General) for more information.



  Before making changes to this repository, please follow the steps outlined in the [Chilton group wiki](https://gitlab.com/chilton-group/group-wiki/-/wikis/Contributing:-General).



  If you believe you have a bug, *please check that you are using the most up to date version of the code*.

  If that does not fix the problem, please create an issue on GitLab detailing the following:
   - The commands you entered
   - The error message

  Remember to simplify the problem as much as possible in order to provide a minimum working example, e.g. an example for a small molecule rather than one with 100000 atoms.

  Then, look at the code, try and figure out what you think is wrong if possible, and include this in your issue.


pkgId: 9de4b9d7c884bb51abc5fb2a746f1b978f7e6fbdce8a8f3500ab5b607718983d
name: python-ango
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: Ango-Hub SDK
url: https://pypi.org/project/ango/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ango-1.1.6-1.src.rpm
checksum_type: sha256
description:
  For using API functionalities of Ango-Hub platform.

      from ango.sdk import SDK

      
      sdk = SDK(api_key="10541bc8-bed8-4775-8ffc-323eabfcc9ae")

      
      files = ["/home/ofk/Pictures/samples/0003.DCM", "/home/ofk/Pictures/samples/0009.DCM"]
      response = sdk.upload_files("61f8d94a79002950df12234a", files)  # With Project ID
      print(response)

      
      files = [{
                  "data": "https://i.imgur.com/OB0y6MR.jpg",
                  "externalId": "111"
              },
              {
                  "data": "https://i.imgur.com/CzXTtJV.jpg",
                  "externalId": "112"
              }]
      response = sdk.upload_files_cloud("61f8d94a79002950df12234a", files)  # With Project ID
      print(response)

  For developing custom plugins that can be integrated to Ango-Hub platform.

      from ango import plugin


      
      
      def callback(data):
          result = model(data)
          return result


      p = plugins.Plugin("<YOUR_PLUGIN_ID>", "<YOUR_API_KEY>", callback)

      plugin.run(p)


pkgId: 865b87888cf934e25a0044543a2cca68db0257c6e8444077c4a87c71a8149fc2
name: python-angola
arch: src
version: 0.17.0
epoch: 0
release: 1
summary: angola
url: https://github.com/mardix/angola
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angola-0.17.0-1.src.rpm
checksum_type: sha256
description:
  **Angola**



  - `db`
  - `xql_to_aql`
  - `parse_dict_mutations`
  - `gen_xid`
  - `Collection`
  - `CollectionItem`
  - `CollectionActiveRecordMixin`
  -


  ```
  import angola


  db = angola.db(hosts="http://host:8529", username="root", password:str)


  coll = db.select_collection('test')


  coll.insert({k:v, ...})


  coll.insert({k:v,...}, _key='awesome')


  ```





  ```
    {
      "_modified_at:$datetime": "+2hh"
    }
  ```

  Format:

  ```
  YYYY: Year
  MM: Month
  DD: Date
  HH: Hour
  mm: Min
  ss: seconds

  ISODATE: YYYY-MM-DDTHH:mm:ss

  ```




  ```
  filters = {

    "$or": [
      { // query between dates
        "_created_at:$lt": "@@CURRDATE() -2days",
        "_created_at:$gt": "@@CURRDATE() +2days"
      }
    ]
  }
  ```


pkgId: 8a33c65c5965a75171a682183be8f321f0747637ec69cfe793d4a177819eb955
name: python-angorapy
arch: src
version: 0.10.8
epoch: 0
release: 1
summary: Build Goal-driven Models of the Sensorimotor Cortex with Ease.
url: http://www.angorapy.org
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angorapy-0.10.8-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/pyversions/angorapy)
  ![](https://img.shields.io/pypi/v/angorapy)
  ![](https://img.shields.io/github/license/ccnmaastricht/angorapy)
  ![](https://img.shields.io/github/stars/ccnmaastricht/angorapy)

  <br />
  <br />

  <p align="center"><img src="docs/img/angorapy.svg" width=25% align="center" /></p>
  <h3> <p align="center"> Anthropomorphic Goal-Oriented Robotic Control for Neuroscientific Modeling </p> </h3>

  <br />

  **AngoraPy** is an open source modeling library for [goal-oriented research](https://pubmed.ncbi.nlm.nih.gov/26906502/) in **neuroscience**. It provides a simple interface to train deep neural network models of the human brain on various, customizable, sensorimotor tasks, using reinforcement learning. It thereby empowers goal-driven modeling to surpass the sensory domain and enter that of sensori_motor_ control, closing the perception-action loop.

  **AngoraPy** is designed to require no deeper understanding of reinforcement learning. It employs state-of-the-art machine learning techniques, optimized for distributed computation scaling from local workstations to high-performance computing clusters. We aim to hide as much of this under the hood of an intuitive, high-level API but preserve the option for customizing most aspects of the pipeline.

  This library is developed as part of the [Human Brain Project](https://www.humanbrainproject.eu/) at [CCN Maastricht](https://www.ccnmaastricht.com/). It is an effort to build software by neuroscientists, for neuroscientists. If you have suggestions, requests or questions, feel free to [open an issue](https://github.com/ccnmaastricht/angorapy/issues/new/choose).

  ![Manipulation Gif](docs/gifs/manipulate_best.gif)





  * [X]  Discrete Action Spaces (Categorical, MultiCategorical)
  * [X]  Continuous Action Spaces (Beta, Gaussian)
  * [X]  Discrete State Spaces
  * [X]  Continuous State Spaces



  * [X]  Recurrent Networks
  * [X]  Convolutional Networks
  * [X]  Recurrent+Convolutional Networks



  * [X]  Local Distributed Training
  * [X]  HPC Distributed Training



  * [X]  Proximal Policy Optimization
  * [X]  Asymmetric Policy/Value Networks
  * [X]  Truncated Backpropagation Through Time



  * [X]  PyPI Package
  * [X]  Docker files
  * [X]  Source code



  AngoraPy is available on PyPI. First, install requirements:

  ```bash
  sudo apt install libopenmpi-dev
  pip install --extra-index-url https://pypi.nvidia.com tensorrt-bindings==8.6.1 tensorrt-libs==8.6.1
  ```

  Then install AngoraPy from pip.

  ```bash
  pip install angorapy
  ```



  Alternatively, you can download this repository or the source code of any previous release or branch and install from source, using pip.

  ```bash
  pip install -e .
  ```

  This way, if you make changes to the source code, these will be recognized in the installation (without the need to reinstall).



  Alternatively, you can install AngoraPy and all its dependencies in a docker container using the Dockerfile provided in this repository (/docker/Dockerfile). To this end, download the repository and build the docker image from the /docker directory:

  ```bash
  sudo docker build -t angorapy:master https://github.com/ccnmaastricht/angorapy.git#master -f - < Dockerfile
  ```

  To install different versions, replace `#master` in the source by the tag/branch of the respective version you want to install.



  The scripts `train.py`, `evaluate.py` and `observe.py` provide ready-made scripts for training and evaluating an agent in any environment. With `pretrain.py`, it is possible to pretrain the visual component. `benchmark.py` provides functionality for training a batch of agents possibly using different configs for comparison of strategies.



  The `train.py` commandline interface provides a convenient entry-point for running all sorts of experiments using the builtin models and environments in angorapy. You can train an agent on any environment with optional hyperparameters. Additionally, a monitor will be automatically linked to the training of the agent. For more detail consult the <a href="monitor/README.md">README on monitoring</a>.

  Base usage of `train.py` is as follows:

  python train.py ENV --architecture MODEL
  For instance, training `LunarLanderContinuous-v2` using the `deeper` architecture is possible by running:

  python train.py LunarLanderContinuous-v2 --architecture deeper
  For more advanced options like custom hyperparameters, consult

  python train.py -h



  There are two more entry points for evaluating and observing an agent: `evaluate.py` and `observe.py`. General usage is as follows

  python evaluate.py ID
  Where ID is the agent's ID given when its created (`train.py` prints this outt, in custom scripts get it with `agent.agent_id`).



  To train agents with custom models, environments, etc. you write your own script. The following is a minimal example:

  ```python

  from angorapy import make_task
  from angorapy.models import get_model_builder
  from angorapy.agent.ppo_agent import PPOAgent

  env = make_task("LunarLanderContinuous-v2")
  model_builder = get_model_builder("simple", "ffn")
  agent = PPOAgent(model_builder, env)
  agent.drill(100, 10, 512)
  ```

  For more details, consult the [examples](examples).



  Detailed documentation of AngoraPy is provided in the READMEs of most subpackages. Additionally, we provide [examples and tutorials](examples) that get you started with writing your own scripts using AngoraPy. For further readings on specific modules, consult the following READMEs:

  - [Agent](angorapy/agent) [WIP]
  - [Environments](angorapy/tasks)
  - [Models](angorapy/models)
  - [Analysis](angorapy/analysis)
  - [Monitoring](angorapy/monitoring)

  If you are missing a documentation for a specific part of AngoraPy, feel free to open an issue and we will do our best to add it.



  PPO is an asynchronous algorithm, allowing multiple parallel workers to generate experience independently.
  We allow parallel gathering and optimization through MPI. Agents will automatically distribute their workers evenly on
  the available CPU cores, while optimization is distributed over all available GPUs. If no GPUs are available, all CPUs
  share the task of optimizing.

  Distribution is possible locally on your workstation and on HPC sites.



  To use MPI locally, you need to have a running MPI implementation, e.g. Open MPI 4 on Ubuntu.
  To execute `train.py` via MPI, run

  ```bash
  mpirun -np 12 --use-hwthread-cpus python3 train.py ...
  ```

  where, in this example, 12 is the number of locally available CPU threads and `--use-hwthread-cpus`
  makes available threads (as opposed to only cores). Usage of `train.py` is as described previously.



  *Please note that the following is optimized and tested on the specific cluster we use, but should extend to at least
  any SLURM based setup.*

  On any SLURM-based HPC cluster you may submit your job with sbatch usising the following script template:

  ```bash












  export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
  export CRAY_CUDA_MPS=1


  source ${HOME}/robovenv/bin/activate

  export DISPLAY=:0
  srun python3 -u train.py ...
  ```

  The number of parallel workers will equal the number of nodes times the number of CPUs per node
  (32 x 12 = 384 in the template above).



  If you use AngoraPy for your research, please cite us as follows

  Weidler, T., & Senden, M. (2020). AngoraPy: Anthropomorphic Goal-Oriented Robotic Control for Neuroscientific Modeling [Computer software]
  Or using bibtex

  @software{angorapy2020,
  author = {Weidler, Tonio and Senden, Mario},
  month = {3},
  title = {{AngoraPy: Anthropomorphic Goal-Oriented Robotic Control for Neuroscientific Modeling}},
  year = {2020}
  }


pkgId: 55917b2965e147aac257605b12ba8ce33aacf9b6830259037d5c7e6e870fb894
name: python-angr-management
arch: src
version: 9.2.123
epoch: 0
release: 1
summary: GUI for angr
url: https://github.com/angr/angr-management
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angr-management-9.2.123-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  This is the GUI for angr.
  Launch it and analyze some binaries!

  Some screenshots:

  [![Disassembly](screenshots/disassembly.png)](https://github.com/angr/angr-management/blob/master/screenshots/disassembly.png)
  [![Decompilation](screenshots/decompilation.png)](https://github.com/angr/angr-management/blob/master/screenshots/decompilation.png)





  The easiest way to run angr-management is by grabbing a bundled release from the releases page: https://github.com/angr/angr-management/releases

  Builds can be extracted and then run from anywhere.
  Note that builds are currently unsigned.



  To install angr-management, use pip:

  ```
  pip install angr-management
  ```

  angr-management can then be run with the command `angr-management`.



  See [angr-dev](https://github.com/angr/angr-dev) for how to set up a development environment for the angr suite.
  angr-management is included by default and checked out to `angr-management` directory.
  If you encounter dependency issues, re-running `setup.sh` or `setup.bat` from angr-dev will ensure all dependencies are installed.

  angr-management can then be run with `angr-management` or `python start.py`.

  **FLIRT signatures**: For now, please manually clone FLIRT signatures by running `git clone --recurse-submodules https://github.com/angr/angr-management`, which will clone the `flirt_signatures` submodule.




  - Load a new binary: ```Ctrl+O```
  - Load a new Docker Image ```Ctrl+Shift+O```
  - Load a Trace File ```Ctrl+Shift+T```
  - Save angr database... : ```Ctrl+S```
  - Save angr database as... : ```Ctrl+Shift+S```
  - Decompile: ```F5```
  - Documentation: ```Alt+H```

  - Next Tab: ```Ctrl+Tab```
  - Previous Tab: ```Ctrl+Shift+Tab```



  Configuration files locations vary by platform.

  - Windows: `~\AppData\Local\angr-management\config.toml`
  - macOS: `~/Library/Preferences/angr-management/config.toml`
  - Linux: `~/.config/angr-management/config.toml`



  Plugins may be installed by placing a subdirectory under `plugins`. The directory must contain an `__init__.py` like that in `TestPlugin`:
  ```
  from .test_plugin import TestPlugin
  PLUGIN_CLS_NAME = TestPlugin.__name__
  ```

  This also allows you to import a plugin class from another package entirely. The plugin itself should inherit from `BasePlugin`. Callbacks and events are a work in progress, so the API is subject to change. See `TestPlugin` for an example of a multithreaded plugin sample.



  Take a look at https://docs.angr.io/extending-angr/angr_management!


  To build a portable executable using PyInstaller, install angr management into a python envrionment with the `pyinstaller` extra.
  Do not install anything in editable mode (pip's `-e`), as PyInstaller currently [fails to bundle](https://github.com/pyinstaller/pyinstaller/issues/7524) modules installed with editable mode.
  Then, run `pyinstaller angr-management.spec`.

  If things go wrong, the best bet is to reference the nightly build pipeline and the [PyInstaller docs](https://pyinstaller.org/en/stable/).
  The CI environment that produces nightly builds is at `.github/workflows/nightly-build.yml` and `.github/workflows/nightly-build.sh`.


pkgId: 67d1d491f14dd4de1f49279055c976603a7f36256935ab61f9ee164784dad65f
name: python-angr-management
arch: src
version: 9.2.128
epoch: 0
release: 1
summary: GUI for angr
url: https://github.com/angr/angr-management
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angr-management-9.2.128-1.src.rpm
checksum_type: sha256
description:
  angr-management is a cross-platform, open-source, graphical binary analysis tool powered by the [angr](https://angr.io) binary analysis platform! See [here](https://angr-management.readthedocs.io/en/latest/) for more information.

  Some screenshots:

  [![Disassembly](screenshots/disassembly.png)](https://github.com/angr/angr-management/blob/master/screenshots/disassembly.png)
  [![Decompilation](screenshots/decompilation.png)](https://github.com/angr/angr-management/blob/master/screenshots/decompilation.png)


pkgId: 2966bf52ed95d0d98e116a6571d75a2690f799fe69300339caa240334ebdef8a
name: python-angrop
arch: src
version: 9.2.11
epoch: 0
release: 1
summary: The rop chain builder based off of angr
url: https://github.com/angr/angrop
rpm_license: BSD 2 Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angrop-9.2.11-1.src.rpm
checksum_type: sha256
description:
  angrop is a rop gadget finder and chain builder

  angrop is a tool to automatically generate rop chains.
  It is built on top of angr's symbolic execution engine, and uses constraint solving for generating chains and understanding the effects of gadgets.
  angrop should support all the architectures supported by angr, although more testing needs to be done.
  Typically, it can generate rop chains (especially long chains) faster than humans.
  It includes functions to generate chains which are commonly used in exploitation and CTF's, such as setting registers, and calling functions.

  Supported architectures:
  * x86/x64
  * ARM
  * MIPS
  It should be relatively easy to support other architectures that are supported by `angr`.
  If you'd like to use `angrop` on other architectures, please create an issue and we will look into it :)

  The ROP analysis finds rop gadgets and can automatically build rop chains.
  ```python
  >>> import angr, angrop
  >>> p = angr.Project("/bin/ls")
  >>> rop = p.analyses.ROP()
  >>> rop.find_gadgets()
  >>> chain = rop.set_regs(rax=0x1337, rbx=0x56565656)
  >>> chain.payload_str()
  b'\xb32@\x00\x00\x00\x00\x007\x13\x00\x00\x00\x00\x00\x00\xa1\x18@\x00\x00\x00\x00\x00VVVV\x00\x00\x00\x00'
  >>> chain.print_payload_code()
  chain = b""
  chain += p64(0x410b23)	# pop rax; ret
  chain += p64(0x1337)
  chain += p64(0x404dc0)	# pop rbx; ret
  chain += p64(0x56565656)
  ```

  ```python


  chain = rop.set_regs(rax=0x1337, rbx=0x56565656)

  chain = rop.move_regs(rax='rdx')


  chain = rop.write_to_mem(0x61b100, b"/bin/sh\0")

  chain = rop.func_call("read", [0, 0x804f000, 0x100])

  chain = rop.add_to_mem(0x804f124, 0x41414141)

  chain = rop.shift(0x10)

  chain = rop.retsled(0x40)

  rop.set_badbytes([0x0, 0x0a])
  chain = rop.set_regs(eax=0)

  chain = rop.write_to_mem(0x61b100, b"/home/ctf/flag\x00") + rop.func_call("open", [0x61b100,os.O_RDONLY]) + ...

  >>> chain.print_payload_code()
  chain = b""
  chain += p64(0x410b23)	# pop rax; ret
  chain += p64(0x74632f656d6f682f)
  chain += p64(0x404dc0)	# pop rbx; ret
  chain += p64(0x61b0f8)
  chain += p64(0x40ab63)	# mov qword ptr [rbx + 8], rax; add rsp, 0x10; pop rbx; ret
  ```

  Gadgets contain a lot of information:
  For example look at how the following code translates into a gadget
  ```asm
     0x403be4:	and    ebp,edi
     0x403be6:	mov    QWORD PTR [rbx+0x90],rax
     0x403bed:	xor    eax,eax
     0x403bef:	add    rsp,0x10
     0x403bf3:	pop    rbx
     0x403bf4:	ret
  ```
  ```python
  >>> print(rop.rop_gadgets[0])
  Gadget 0x403be4
  Stack change: 0x20
  Changed registers: set(['rbx', 'rax', 'rbp'])
  Popped registers: set(['rbx'])
  Register dependencies:
      rbp: [rdi, rbp]
  Memory write:
      address (64 bits) depends on: ['rbx']
      data (64 bits) depends on: ['rax']
  ```
  The dependencies describe what registers affect the final value of another register.
  In the example above, the final value of rbp depends on both rdi and rbp.
  Dependencies are analyzed for registers and for memory actions.
  All of the information is stored as properties in the gadgets, so it is easy to iterate over them and find gadgets which fit your needs.
  ```python
  >>> for g in rop.rop_gadgets:
      if "rax" in g.popped_regs and "rbx" not in g.changed_regs:
          print(g)
  Gadget 0x4032b3
  Stack change: 0x10
  Changed registers: set(['rax'])
  Popped registers: set(['rax'])
  Register dependencies:
  ```

  Allow strings to be passed as arguments to func_call(), which are then written to memory and referenced.
  Add a function for open, read, write (for ctf's)
  Allow using of angr objects such as BVV, BVS to make using symbolic values easy
  The segment analysis for finding executable addresses seems to break on non-elf binaries often, such as PE files, kernel modules.
  Allow setting constraints on the generated chain e.g. bytes that are valid.

  Make sure to import angrop before calling proj.analyses.ROP()
  Make sure to call find_gadets() before trying to make chains


pkgId: 6a2e67bf8e2b31ffc1052e1e75ab32e96c000ac06de2bb3a14cf1c2f3d8f61ff
name: python-angular-gettext-babel
arch: src
version: 0.3
epoch: 0
release: 1
summary: A plugin for babel to work with angular-gettext templates
url: https://github.com/neillc/angular-gettext-babel
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-angular-gettext-babel-0.3-1.src.rpm
checksum_type: sha256
description:
  A babel extractor for use with angular-gettext (https://angular-gettext.rocketeer.be/)
  This is a very simple extractor that does not attempt to deal with anything but
  html templates that have translate directives embedded in them.


pkgId: 5bc141e84d2bbfd328f23193ff51eb7d5911324818d7dcb33a25888a2d6da09d
name: python-ani-sync
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Sync your ani-cli progress with a remote server.
url: https://github.com/Hamziee/ani-sync
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ani-sync-0.1.1-1.src.rpm
checksum_type: sha256
description:
  - **Sync Your Progress**: Keep track of what youâ€™ve watched with ani-cli across your PC, phone or other devices (samsung smart fridge maybe?).
  - **Cloud Storage**: Syncs progress to a remote server by default (`ani-sync.hamzie.site:25507`).
  - **Arguments Compatibility**: Run `ani-sync` with the same arguments as `ani-cli` and more.


pkgId: 3d4e21debb44118c7b4c7685e45f9eb32d4621e3e69547964ff1d158994c036b
name: python-anicli_api
arch: src
version: 0.6.11
epoch: 0
release: 1
summary: Anime extractors api implementation
url: https://pypi.org/project/anicli_api/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anicli_api-0.6.11-1.src.rpm
checksum_type: sha256
description:
  Программный интерфейс набора парсеров аниме с различных источников.

  Присутствует поддержка sync и async методов с помощью `httpx` библиотеки.

  Парсеры работают на REST-API (если у источника есть доступ) или если такой интерфейс
  отсутствует, то с помощью parsel, chompjs, jmespath, regex библиотек.



  `pip install anicli-api`


  Структура проекта

  - source - наборы модулей для извлечения информации об аниме тайтлов из источников
  - player - наборы модулей для извлечения прямой ссылки на видео

  Подробнее про `source` и `player` смотрите ниже.

  ```
  anicli_api
  ├── base.py - базовый класс модуля-парсера
  ├── _http.py - предварительно сконфигурированные классы httpx.Client и httpx.AsyncClient
  ├── _logger.py - логгер
  ├── player - модули получения ссылок на видео
  │     ├── __template__.py - шаблон модуля PlayerExtractor
  │     ├── ...  ready-made модули
  │     ...
  ├── source - модули парсеров с источников
  │     ├── parsers/... автоматически сгенерированные парсеры html страниц
  │     ├── __template__.py - шаблон для экстрактора
  │     ├─ ... ready-made парсеры
  │     ...
  └── tools - прочие модули

  ```

  Схематичный принцип работы модуля из директории `source`

  префикс `a_` обозначает асинхронный метод, возвращаемые объекты идентичны

  ```mermaid
  flowchart TD
      E[Extractor] -->|"search('QUERY') | a_search('QUERY')"| S("List[Search]")
      E -->|"ongoing() | a_ongoing()"| O("List[Ongoing]")

      O -->|"get_anime() | a_get_anime()"| A[Anime]
      S -->|"get_anime() | a_get_anime()"| A

      A -->|"get_episodes() | a_get_episodes()"|Ep["List[Episode]"]
      Ep -->|"get_sources() | a_get_sources()"|So["List[Source]"]
      So -->|"get_videos() | a_get_videos()"|V["List[Video]"]

  ```


  ```python
  from anicli_api.source.animego import Extractor
  from anicli_api.tools import cli

  if __name__ == '__main__':
      cli(Extractor())
  ```

  > Этот модуль реализован для простого ручного тестирования парсеров и "имитирует" потенциальное настоящее приложение


  Пример своей реализации

  ```python
  from anicli_api.source.animego import Extractor  # can usage any source


  def _print_to_rows(items):
      print(*[f"{i}) {r}" for i, r in enumerate(items)], sep="\n")


  if __name__ == "__main__":
      ex = Extractor()
      print("PRESS CTRL + C for exit app")
      while True:
          results = ex.search(input("search query > "))
          if not results:
              print("Not founded, try again")
          continue
      _print_to_rows(results)

      anime = results[int(input("anime > "))].get_anime()
      print(anime)

      episodes = anime.get_episodes()
      _print_to_rows(episodes)
      episode = episodes[int(input("episode > "))]

      sources = episode.get_sources()
      _print_to_rows(sources)
      source = sources[int(input("source > "))]

      videos = source.get_videos()
      _print_to_rows(videos)
      video = videos[int(input("video > "))]
      print(video.type, video.quality, video.url, video.headers)
  ```

  С asyncio аналогично, но **все** методы получения объектов имеют префикс `a_`:

  ```python
  import asyncio
  from anicli_api.source.animego import Extractor # или любой другой источник

  async def main():
      ex = Extractor()
      prompt = input("search query > ")
      
      
      results = await ex.a_search(prompt)
      print(*[f"{i}) {r}" for i, r in enumerate(results)], sep="\n")

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



  Эти модули можно использовать как экстрактор прямых ссылок на видео

  > Эти модули минимально реализуют получение ссылок на видео с минимальными метаданными и заголовками для скачивания и
  > не стремятся стать заменой yt-dlp

  ```python
  import asyncio

  from anicli_api.player.sibnet import SibNet

  async def main():
      videos = await SibNet().a_parse(URL)
      print(*videos)


  if __name__ == '__main__':
      URL = 'https://video.sibnet.ru/shell.php?videoid=432356'
      print(*SibNet().parse(URL))
      
      asyncio.run(main())
  ```



  - name - имя модуля
  - type - тип источника получения данных.
    - **NO** - неофициальный (парсинг html документов и запросы недокументированным API методам)
    - **YES** - официальный (rest-api)
  - note - примечания
  - dubbers - тип озвучек.
    - many - от различных авторов.
    - subtitles - только субтитры.
    - once - один вид (случайный)
    - author - своя

  | name                           | url                        | official api | dubbers           | note                                                                                                                                             |
  |--------------------------------|----------------------------|--------------|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
  | animego                        | https://animego.org        | NO           | many              | источники kodik, animego, не работает на IP отличных от СНГ и стран прибалтики                                                                   |
  | animania DROP (dead)           | https://animania.online    | NO           | many              | источник kodik, не работает на IP отличных от СНГ и стран прибалтики                                                                             |
  | sovetromantica                 | https://sovetromantica.com | NO           | subtitles, author | не на все тайтлы есть видео, у себя хостят                                                                                                       |
  | anilibria                      | https://anilibria.tv       | YES          | author            |                                                                                                                                                  |
  | animevost                      | https://animevost.org      | YES          | author            |                                                                                                                                                  |
  | jutsu                          | https://jut.su             | NO           | once              | Запуск видео в сторонних плеерах зависим от используемого user-agent заголовка в API интерфейсе. Некоторые тайтлы заблокированы на территории РФ |
  | sameband                       | https://sameband.studio    | NO           | author            |                                                                                                                                                  |
  | animego.pro                    | https://animego.pro        | NO           | many              | Нестабильный uptime сайта (могут быть проблемы с доступом)                                                                                       |




  > Требует дополнения и дополнительные тесты

  - name - имя плеера
  - max quality - максимальное разрешение выдаваемое источником. Это может быть 0 (аудио, без видео), 144, 240, 360, 480, 720, 1080
  - note - примечания

  | name           | max quality                                                  | note                                                                                       |
  |----------------|--------------------------------------------------------------|--------------------------------------------------------------------------------------------|
  | kodik          | 720 (на старых тайтлах (ранние One Peace, Evangelion) - 480) | **работает только на IP СНГ и стран прибалтики**                                           |
  | aniboom        | 1080                                                         | **работает только на IP СНГ и стран прибалтики**. Иногда не возвращает mpd ссылку на видео |
  | sibnet         | 480                                                          |                                                                                            |
  | animejoy       | 1080                                                         | только актуальные ongoing, потом видео удаляются с серверов                                |
  | csst           | 1080                                                         |                                                                                            |
  | dzen           | 1080                                                         |                                                                                            |
  | mailru         |                                                              |                                                                                            |
  | okru           |                                                              |                                                                                            |
  | sovetromantica | 1080                                                         | не на все тайтлы присутствуют видео                                                        |
  | vkcom          | 1080 (какого качества автор зальет видео)                    | CDN сервера в РФ, в других странах загружается медленнее                                   |
  | nuum           | 1080                                                         | проект от wasd.tv                                                                          |
  | anilibria      | 1080                                                         |                                                                                            |
  | jutsu          | 1080                                                         |                                                                                            |
  | sameband       | 1080                                                         |                                                                                            |



  Настройка логгера идет через ключ `anicli-api`

  ```python
  import logging
  logger = logging.getLogger('anicli-api')
  ```





  Если по какой-то либо причине вас не устраивают настройки по умолчанию - то вы можете задать
  конфигурацию http клиентов для экстракторов. Или если необходимо подключить proxy

  ```python
  from anicli_api.source.animego import Extractor
  import httpx


  my_client = httpx.Client(headers={"user-agent": "007"}, proxies="http://127.0.0.1:8080")
  my_async_client = httpx.AsyncClient(headers={"user-agent": "007"}, proxies="http://127.0.0.1:8080")




  ex = Extractor(http_client=my_client, http_async_client=my_async_client)


  results = ex.search("lain")
  result = results[0]
  result.http = my_client
  result.http_async = my_async_client
  ...

  ```



  В player для модификации httpx клиентов (Client, AsyncioClient) необходимо передать kwargs аргументы:

  ```python
  from anicli_api.source.animego import Extractor


  sources = (
      Extractor()
      .search("lain")[0]
      .get_anime()
      .get_episodes()[0]
      .get_sources()
  )

  videos = sources[0].get_videos(transport=None,  # reset to default httpx.HTTPTransport
                                 headers={"User-Agent": "i'm crushing :("})
  ```



  Приведены поля, которые **гарантированно** возвращаются в API интерфейсе библиотеки.
  В некоторых источниках могут присутствовать дополнительные поля или атрибуты для
  использования во внутренних методах.

  - Например, в `anilibria` и `animevost` поля почти идентичны ответам API.
  В `animego.Anime` есть сырой несериализованный `raw_json` для извлечения дополнительных метаданных.

  - В некоторых источниках на полях могут присутствовать "заглушки" для поддержания консистентности API интерфейса. Например,
  в модуле `anicli_api.source.jutsu.Episode` уже можно получить прямые ссылки на видео (Video объект),
  но для поддержания полиморфизма, необходимо возвращать объект `Source` и только потом `Video`
  - Если по какой-либо причине объекты не получены (ddos защита, региональные ограничения) - то возвращает пустой список.
    (#TODO возможно, необходимо выбрасывать исключение?)


  - url: str - URL на тайтл
  - title: str - имя найденного тайтла
  - thumbnail: str - изображение


  - url: str - URL на тайтл
  - title: str - имя найденного тайтла
  - thumbnail: str - изображение


  - title: str - имя тайтла (на русском)
  - thumbnail: str - изображение
  - description: Optional[str] - описание тайтла. может вернуть пустую строку или None


  - title: str - имя эпизода (Если источник его не хранит, то будет Серия или Serie)
  - num: str - номер эпизода


  - url: str - ссылка на источник
  - title: str - даббер или имя источника



  Объект `Video`, полученный из `Source.get_video`/`Source.a_get_video`
  имеет следующую структуру:

  * type - тип видео (m3u8, mp4, mpd, audio)
  * quality - разрешение видео (0, 144, 240, 360, 480, 720, 1080)
  * url - прямая ссылка на видео
  * headers - заголовки требуемые для получения потока.
  Если возвращает пустой словарь - заголовки не нужны



  - Парсеры из директории
  [anicli_api/source/parsers](anicli_api/source/parsers) автоматически генерируются с помощью
  [ssc_gen](https://github.com/vypivshiy/selector_schema_codegen),
  настройки хранятся в [libanime_schema](https://github.com/libanime/libanime_schema)

  - Для модификаций парсеров из директории `anicli_api/source/parsers`
  используйте наследование, чтобы не потерять изменения при перегенерации библиотекой `ssc_gen`.


  - Проект разработан преимущественно на личное, некоммерческое использование с client-side
  стороны. Проекта не несет ответственности за поломки, убытки и решение
  предоставляется "Как есть" в соответствии с [MIT](LIENSE) лицензией.

  - Основная цель этого проекта — связать автоматизацию и эффективность извлечения того,
  что предоставляется пользователю в Интернете.
  Весь контент, доступный в рамках проекта, размещается на внешних неаффилированных источниках.

  - **Этот проект не включает инструменты кеширования и сохранения всех полученных данных,
  только готовые реализации парсеров и программные интерфейсы**


pkgId: 87f1b47d3b779af1c74ec260b7e48f75caf4e74bc4c0d85c2a64ade6d25ee0c1
name: python-anidbcli
arch: src
version: 1.66
epoch: 0
release: 1
summary: Simple CLI for managing your anime collection using AniDB UDP API.
url: https://github.com/adameste/anidbcli
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anidbcli-1.66-1.src.rpm
checksum_type: sha256
description:
  Anidbcli is a simple command line interface for managing your anime collection on your local computer or NAS (using only ssh).


pkgId: 595b0eaa02bf1cd0bc481e3eee3644cdd23db0b25c854a43b90158e9346fe54f
name: python-aniemore
arch: src
version: 1.2.3
epoch: 0
release: 1
url: https://pypi.org/project/aniemore/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aniemore-1.2.3-1.src.rpm
checksum_type: sha256
summary:
  Aniemore (Artem Nikita Ilya EMOtion REcognition) is a library for emotion recognition in voice and text for russian language.

description:
  ![Aniemore Logo](images/logo.png)

   **Aniemore** - это открытая библиотека искусственного интеллекта для потоковой аналитики эмоциональных оттенков речи человека.

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1_W2ngr_ShrLdTLVTBP3XF176JW1zdChl)

  [![PyPI version](https://img.shields.io/pypi/v/aniemore)](https://img.shields.io/pypi/v/aniemore)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aniemore)](https://img.shields.io/pypi/pyversions/aniemore)
  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/aniemore)](https://img.shields.io/pypi/wheel/aniemore)
  [![PyPI - License](https://img.shields.io/pypi/l/aniemore)](https://img.shields.io/pypi/l/aniemore)
  [![PyPI - Status](https://img.shields.io/pypi/status/aniemore)](https://img.shields.io/pypi/status/aniemore)
  [![Downloads](https://img.shields.io/pypi/dm/aniemore)](https://pypistats.org/packages/aniemore)
  [![CodeQL](https://github.com/aniemore/Aniemore/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/aniemore/Aniemore/actions/workflows/github-code-scanning/codeql)
  [![Bandit](https://github.com/aniemore/Aniemore/actions/workflows/bandit.yml/badge.svg)](https://github.com/aniemore/Aniemore/actions/workflows/bandit.yml)



  - Объем набора данных Russian Emotional Speech Dialogues содержит более 3000 аудиофрагментов представляющих 200 различных людей;
  - Модели способны распознавать эмоции в зашумленных аудиофайлах длительностью в 3 секунды;
  - Скорость обработки и ответа модели составляет не более 5 секунд;
  - Пословная ошибка модели WER 30%;
  - Совокупная точность модели 75%
  - Диапазон распознавания эмоций: злость, отвращение, страх, счастье, интерес, грусть, нейтрально;
  - Акустические возможности - 3 уровня.



  Aniemore - это библиотека для Python, которая позволяет добавить в ваше
  программное обеспечение возможность определять эмоциональный фон речи человека, как в голосе,
  так и в тексте. Для этого в библиотеке разработано два соответсвующих модуля - Voice и Text.

  Aniemore содержит свой собственный датасет RESD (Russian Emotional Speech Dialogues) и другие
  наборы данных разного объема, которые вы можете использовать для обучения своих моделей.

  | Датасет        | Примечание                                                                  |
  |----------------|-----------------------------------------------------------------------------|
  | RESD           | 7 эмоций, 4 часа аудиозаписей диалогов **студийное качество**               |
  | RESD_Annotated | RESD + speech-to-text аннотации                                             |
  | REPV           | 2000 голосовых сообщений (.ogg), 200 актеров, 2 нейтральные фразы, 5 эмоций |
  | REPV-S         | 140 голосовых сообщений (.ogg) "Привет, как дела?" с разными эмоциями       |

  Вы можете использовать готовые предобученные модели из библиотеки:

  | Модель                                                                                                                           | Точность |
  |----------------------------------------------------------------------------------------------------------------------------------|----------|
  | Голосовые модели                                                                                                                 |          |
  | [**wav2vec2-xlsr-53-russian-emotion-recognition**](https://huggingface.co/Aniemore/wav2vec2-xlsr-53-russian-emotion-recognition) | 73%      |
  | [**wav2vec2-emotion-russian-resd**](https://huggingface.co/Aniemore/wav2vec2-emotion-russian-resd)                               | 75%      |
  | [**wavlm-emotion-russian-resd**](https://huggingface.co/Aniemore/wavlm-emotion-russian-resd)                                     | 82%      |
  | [**hubert-emotion-russian-resd**](https://huggingface.co/Aniemore/hubert-emotion-russian-resd)                                   | 75%      |
  | [**unispeech-sat-emotion-russian-resd Copied**](https://huggingface.co/Aniemore/unispeech-sat-emotion-russian-resd)              | 72%      |
  | [**wavlm-bert-base**](https://huggingface.co/Aniemore/wavlm-bert-base-s-emotion-russian-resd)                                                           | 81%      |
  | [**wavlm-bert-fusion**](https://huggingface.co/Aniemore/wavlm-bert-fusion-s-emotion-russian-resd)                                | 83%      |
  | Текстовые модели                                                                                                                 |          |
  | [**rubert-base-emotion-russian-cedr-m7**](https://huggingface.co/Aniemore/rubert-base-emotion-russian-cedr-m7)                   | 74%      |
  | [**rubert-tiny2-russian-emotion-detection**](https://huggingface.co/Aniemore/rubert-tiny2-russian-emotion-detection)             | 85%      |
  | [**rubert-large-emotion-russian-cedr-m7**](https://huggingface.co/Aniemore/rubert-large-emotion-russian-cedr-m7)                 | 76%      |
  | [**rubert-tiny-emotion-russian-cedr-m7**](https://huggingface.co/Aniemore/rubert-tiny-emotion-russian-cedr-m7)                   | 72%      |


  ![показатели моделей.jpg](images/model_sota.jpg)



  ```shell
  pip install aniemore
  ```


  | Архитектура              | ЦПУ    | ОЗУ   | SSD   |
  |--------------------------|--------|-------|-------|
  | **Wave2Vec2**            | 2 ядра | 8 ГБ  | 40 ГБ |
  | **WaveLM**               | 2 ядра | 8 ГБ  | 40 ГБ |
  | **Hubert**               | 2 ядра | 8 ГБ  | 40 ГБ |
  | **UniSpeechSAT**         | 2 ядра | 8 ГБ  | 40 ГБ |
  | **Bert_Tiny/Bert_Tiny2** | 2 ядра | 4 ГБ  | 40 ГБ |
  | **Bert_Base**            | 2 ядра | 4 ГБ  | 40 ГБ |
  | **Bert_Large**           | 2 ядра | 8 ГБ  | 40 ГБ |
  | **WavLM Bert Base**      | 2 ядра | 16 ГБ | 40 ГБ |
  | **WavLM Bert Fusion**    | 2 ядра | 16 ГБ | 40 ГБ |
  | **Whisper Tiny**         | 2 ядра | 4 ГБ  | 40 ГБ |
  | **Whisper Base**         | 2 ядра | 4 ГБ  | 40 ГБ |
  | **Whisper Small**        | 2 ядра | 4 ГБ  | 40 ГБ |
  | **Whisper Medium**       | 2 ядра | 8 ГБ  | 40 ГБ |
  | **Whisper Large**        | 2 ядра | 16 ГБ | 40 ГБ |
  | **TextEnhancer**         | 2 ядра | 4 ГБ  | 40 ГБ |
  <hr>



  Ниже приведены простые примеры использования библиотеки. Для более детальных примеров, в том числе **загрузка cобственной модели** - смотрите сделанный для этого *Google Colab*

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1_W2ngr_ShrLdTLVTBP3XF176JW1zdChl)

  ```python
  import torch
  from aniemore.recognizers.text import TextRecognizer
  from aniemore.models import HuggingFaceModel

  model = HuggingFaceModel.Text.Bert_Tiny2
  device = 'cuda' if torch.cuda.is_available() else 'cpu'
  tr = TextRecognizer(model=model, device=device)

  tr.recognize('это работает? :(', return_single_label=True)
  ```


  ```python
  import torch
  from aniemore.recognizers.voice import VoiceRecognizer
  from aniemore.models import HuggingFaceModel

  model = HuggingFaceModel.Voice.WavLM
  device = 'cuda' if torch.cuda.is_available() else 'cpu'
  vr = VoiceRecognizer(model=model, device=device)
  vr.recognize('/content/ваш-звуковой-файл.wav', return_single_label=True)
  ```


  ```python
  import torch
  from aniemore.recognizers.multimodal import VoiceTextRecognizer
  from aniemore.utils.speech2text import SmallSpeech2Text
  from aniemore.models import HuggingFaceModel

  model = HuggingFaceModel.MultiModal.WavLMBertFusion
  s2t_model = SmallSpeech2Text()

  text = SmallSpeech2Text.recognize('/content/ваш-звуковой-файл.wav').text
  device = 'cuda' if torch.cuda.is_available() else 'cpu'

  vtr = VoiceTextRecognizer(model=model, device=device)
  vtr.recognize(('/content/ваш-звуковой-файл.wav', text), return_single_label=True)
  ```


  ```python
  import torch
  from aniemore.recognizers.multimodal import MultiModalRecognizer
  from aniemore.utils.speech2text import SmallSpeech2Text
  from aniemore.models import HuggingFaceModel

  model = HuggingFaceModel.MultiModal.WavLMBertFusion
  device = 'cuda' if torch.cuda.is_available() else 'cpu'
  mr = MultiModalRecognizer(model=model, s2t_model=SmallSpeech2Text(), device=device)
  mr.recognize('/content/ваш-звуковой-файл.wav', return_single_label=True)
  ```
  <hr>



  Все модели и датасеты, а так же примеры их использования вы можете посмотреть в нашем [HuggingFace профиле](https://huggingface.co/Aniemore)


  **Aniemore (Artem Nikita Ilya EMOtion REcognition)**

  Разработка открытой библиотеки произведена коллективом авторов на базе ООО "Социальный код".
  Результаты работы получены за счет гранта Фонда содействия развитию малых форм предприятий в научно-технической сфере (Договор №1ГУКодИИС12-D7/72697
  от 22.12.2021).


  Для цитировация воспользуйтесь пунктом `Cite this repository` в правом меню `About` этого проекта, или скопируйте информацию ниже:
  ```bibtex
  @software{Lubenets_Aniemore,
  author = {Lubenets, Ilya and Davidchuk, Nikita and Amentes, Artem},
  license = {MIT},
  title = {{Aniemore}},
  url = {https://github.com/aniemore/Aniemore}
  }
  ```


pkgId: 9fc52d3da6ae7e75c8481ead50a42c10878ec1987e2f93aefbf51b7a2e17328a
name: python-anilistwrappy
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: An API Wrapper for Official Anilist.co GraphQL API
url: https://github.com/Dank-del/anilistWrapPY
rpm_license: Unlicense License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anilistwrappy-0.0.16-1.src.rpm
checksum_type: sha256
description:
  ![downloads](https://img.shields.io/pypi/dm/anilistWrapPY) ![ver](https://img.shields.io/pypi/v/anilistWrapPY)
  anilistWrapPY is an unofficial [python](https://python.org) wrapper for [anilist](https://anilist.co) API.

  - [<img src="https://avatars.githubusercontent.com/u/18018524?s=200&v=4" width="35px" align="left"></img> anilistWrapPY](#img-anilistwrappy)
      - [Table of contents](#table-of-contents)
    - [Supported python versions](#supported-python-versions)
    - [Features](#features)
    - [Getting started](#getting-started)
    - [How to use](#how-to-use)
      - [Airing](#airing)
      - [Anime](#anime)
      - [Character](#character)
      - [Manga](#manga)
      - [Media](#media)
      - [User](#user)
    - [Support and Contributions](#support-and-contributions)
    - [Links](#links)
    - [License](#license)
  <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/798246901916499998.gif" width="350px"></img>
  <hr/>

  This library, needs python 3.7 or higher version to be installed.
  <hr/>

  * Uses official anilist API endpoints, which makes this library:
    * Easy to update
    * Guaranteed to match the docs
    * No third party endpoints
    * No need to serialize and deserialize data outside of library
  * It's in pure python, no need to install any kind of plugin or include any kind of additional files.
  * It uses GraphQL to fetch data on AniList servers. The AniList GraphQL API provides quick and powerful access to over 500k anime and manga entries, including character, staff, and live airing data.
  * Anilist Client: Using a client makes it easier to fetch every type of data you want from the servers. You only need to import client and you are ready to go!
  <hr/>

  You can easily download the library with the standard `pip install` command:
  ```bash
  pip install anilistWrapPY
  ```
  You may want to visit our pypi page [here](https://pypi.org/project/anilistwrappy/).
  <hr/>

  * <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/soulgem-homura.gif" width="15px"></img> [Airing](#Airing)
  * <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/soulgem-kyoko.gif" width="15px"></img> [Anime](#Anime)
  * <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/soulgem-madoka.gif" width="15px"></img> [Character](#Character)
  * <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/soulgem-mami.gif" width="15px"></img> [Manga](#Manga)
  * <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/soulgem-sayaka.gif" width="15px"></img> [Media](#Media)
  * <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/Yayyyyyyyyy.png" width="15px"></img> [User](#User)

  ```py
  >>> from anilistWrapPY import aniWrapPYClient
  >>> c = aniWrapPYClient()
  >>> c.Airing("The Detective Is Already Dead")
  ```

  ```py
  >>> from anilistWrapPY import aniWrapPYClient
  >>> c = aniWrapPYClient()
  >>> c.Anime("Kanojo mo kanojo")
  ```

  ```py
  >>> from anilistWrapPY import aniWrapPYClient
  >>> c = aniWrapPYClient()
  >>> c.Character("Rin tohsaka")
  ```

  ```py
  >>> from anilistWrapPY import aniWrapPYClient
  >>> c = aniWrapPYClient()
  >>> c.Manga("Classroom of the elite")
  ```

  ```py
  >>> from anilistWrapPY import aniWrapPYClient
  >>> c = aniWrapPYClient()
  >>> c.Media("Talentless Nana")
  ```

  ```py
  >>> from anilistWrapPY import aniWrapPYClient
  >>> c = aniWrapPYClient()
  >>> c.User("mimiee")
  ```
  <hr/>

  * If you think you have found a bug or have a feature request, feel free to use our [issue tracker](https://github.com/Dank-del/anilistWrapPY/issues). Before opening a new issue, please search to see if your problem has already been reported or not.  Try to be as detailed as possible in your issue reports.
  * If you need help using AniList APIs or have other questions about this library, we suggest you to join our [telegram community](https://t.me/chiruzon).  Please do not use the GitHub issue tracker for personal support requests.
  * Having a problem with library? Wanna talk with repository's owner? Contact the [Maintainer](https://t.me/dank_as_fuck)!
  * Want to have a cool multi-purpose Telegram bot in your groups? You can add [Nana[ナナ]](https://t.me/TheTalentlessBot) with full features of AniList API!
  <hr/>

  * [Official website](https://anilist.co)
  * [AniList github org](https://github.com/AniList)
  * [AniList GraphQL docs](https://github.com/AniList/ApiV2-GraphQL-Docs)
  * [Support chat](https://t.me/chiruzon)
  * [Maintainer's Telegram](https://t.me/dank_as_fuck)
  * [Nana [ナナ]](https://t.me/TheTalentlessBot)
  <hr/>

  <img src="https://raw.githubusercontent.com/aliwoto/aliwoto/main/resources/Something_that_looks_like_Diamond.png" width="25px"></img> The anilistWrapPY project is under the [Unlicense](http://unlicense.org/). You can find the license file [here](LICENSE).


pkgId: f42bf410c9aa4f762d8c814b518e7e673486d8e4bf511572d90562f37878b2f7
name: python-animatai
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Ecosystem with animats for development of Artificial General Intelligence
url: https://github.com/animatai/animatai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animatai-0.1.4-1.src.rpm
checksum_type: sha256
description:
  Reference code for:
  A General Model for Learning and Decision-Making in Artificial Animals by
  Claes Strannegård, Nils Svangård, David Lindström, Joscha Bach
  and Bas Steunebrink
  Submitted to IJCAI-17 AGA workshop, Melbourne, Australia
  This repo is work in progress and will contain a completely refactored
  version of the original code. The repo [ecosystem](https://github.com/animatai/ecosystem)
  contains the old version of the framework (which isn't maintained anymore).


pkgId: 7af6cf4e3d8962d0277c7d3f3923b546c8ed09e6121b1ee8d1334ed94dcea308
name: python-animdl
arch: src
version: 1.7.27
epoch: 0
release: 1
url: https://pypi.org/project/animdl/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animdl-1.7.27-1.src.rpm
checksum_type: sha256
summary:
  A highly efficient, fast, powerful and light-weight anime downloader and streamer for your favorite anime.


pkgId: 21c25f709c564211e32ab53c66c2410b8f532811a2ef6c52d315b1699e7fb6a8
name: python-anime-downloader
arch: src
version: 5.0.9
epoch: 0
release: 1
summary: Download your favourite anime
url: https://github.com/vn-ki/anime-downloader
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anime-downloader-5.0.9-1.src.rpm
checksum_type: sha256
description:
  Ever dreamt about watching anime for free effortlessly without all those unbearable ads? Ever dreamt of downloading your favourite anime for that long trip?
  ![kawaii](https://thumbs.gfycat.com/IgnorantYoungDowitcher-size_restricted.gif)
  Yeah. Me too! That's why this tool exists.

  - Download or stream any episode or episode range of any anime.
  - Have a locally stored anime list to track your progress and stream anime using the watch command.
  - Import your MAL anime list to the local anime list.
  - Specify the quality you want to stream or download.
  - Search and download.
  - Save yourselves from those malicious ads.
  - Download using external downloader ([aria2](https://aria2.github.io/) recommended).
  - Configurable using `config.json`. See [documentation](https://anime-downlader.readthedocs.io/en/latest/usage/config.html).

  - Windows
  - Mac OS
  - Linux
  - Android
  - iOS (requires Jailbreak and some tinkering)
    * Instructions for Mobile Operating Systems can be found in the [Installation Documentation Page](https://anime-downlader.readthedocs.io/en/latest/usage/installation.html)

  **Details about the sites can be found in [FAQ](https://github.com/vn-ki/anime-downloader/wiki/FAQ)**
  - 4Anime - requires jsbeautifier
  - AnimeBinge
  - Animedaisuki
  - Animeflix
  - Animeflv
  - Animefreak
  - AnimeKisa
  - AnimeOnline360
  - animeout
  - Animerush
  - Animesimple
  - Animevibe
  - AnimeTake
  - AniTube
  - Animixplay
  - Anistream
  - Darkanime
  - Dbanimes
  - EraiRaws
  - EgyAnime - usually m3u8 (good for streaming, not so much for downloading)
  - GenoAnime
  - GurminderBoparai (AnimeChameleon)
  - itsaturday
  - Justdubs
  - Kissanimefree
  - KissanimeX
  - Nyaa.si
  - PutLockers
  - RyuAnime
  - Shiro.is
  - SubsPlease
  - twist.moe - requires Node.js
  - tenshi.moe
  - Vidstream
  - Voiranime
  - Vostfree
  Sites that require Selenium **DO NOT** and **WILL NOT** work on mobile operating systems
  Twist.moe **DOES NOT** work and **WILL NOT** work on iOS, a specific Python module that is required for twist.moe is not supported on iOS and cannot be installed.

  [**Installation instructions***](https://anime-downlader.readthedocs.io/en/latest/usage/installation.html)
  If you have trouble installing, see extended installation instructions [here](https://anime-downlader.readthedocs.io/en/latest/usage/installation.html) or join the [discord server](https://discord.gg/Qn2nWGm) for help.
  **Note**:
  - For Cloudflare scraping either [cfscrape](https://github.com/Anorov/cloudflare-scrape) or [selenium](https://www.selenium.dev/) is used. [Cfscrape](https://github.com/Anorov/cloudflare-scrape) depends on [`node-js`](https://nodejs.org/en/) and [selenium](https://www.selenium.dev/) utilizes an automated invisible instance of a browser (chrome/firefox). So, if you want to use Cloudflare enabled sites, make sure you have [node-js](https://nodejs.org/en/) and a [webdriver](https://www.selenium.dev/selenium/docs/api/py/index.html#drivers) installed.
  - You might have to use pip3 depending on your system
  - To install this project with gui and all its dependencies, add `#egg=anime-downloader[gui]` to the pip command you are using to install it. Example: `pip install --force-reinstall -U git+https://github.com/anime-dl/anime-downloader#egg=anime_downloader[gui]`
  - To install this project with selescrape (if you are using GUI, ignore this line), do the same as above - but with `#egg=anime-downloader[selescrape]`
  - To install this project with jsbeautifier run `pip install --force-reinstall -U git+https://github.com/anime-dl/anime-downloader#egg=anime-downloader[unpacker]`

  See [docs](https://anime-downlader.readthedocs.io/en/latest/usage/dl.html).
  Anime Downloader has six (6) sub-commands, `dl`, `watch`, `gui`, `config`, `ezdl` and `test`.
  - [dl](https://anime-downlader.readthedocs.io/en/latest/usage/dl.html): `dl` can download anime.
  - ezdl: Uses metadata agents to unify providers and also auto select a result if the search argument is close to the anime title.
  - [watch](https://anime-downlader.readthedocs.io/en/latest/usage/watch.html): `watch` can manage your anime watch list. Needs [mpv](https://mpv.io).
  - [config](https://anime-downlader.readthedocs.io/en/latest/usage/config.html): can manage the configuration for anime dl.
  - test: Tests all the providers, not the most reliable command as the results may be faulty.
  - gui: opens a PyQT gui that allows for non commandline downloading and streaming.
  **To use `anime_downloader` in your package:**
  This tool can be used as a library. This means you can import it into your own applications and search for anime and do many other wonderful things.
  See [documentation](https://anime-downlader.readthedocs.io/en/latest/usage/api.html).
  **Development Instructions:**
  See [development instructions](https://anime-downlader.readthedocs.io/en/latest/advanced/custom_site.html).

  - [adl](https://github.com/RaitaroH/adl) - a command-line tool for watching anime that makes use of anime-downloader.


pkgId: aa11cd6ddebf2e5ed67f55e0445949319dbdacb2c118dc71390903bde6d03612
name: python-anime-episode-parser
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: A library to parse episode info from anime title
url: https://github.com/BGmi/anime-episode-parser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anime-episode-parser-0.0.12-1.src.rpm
checksum_type: sha256
description:
  try parse episode info from title

  ```bash
  poetry add anime_episode_parser
  ```

  ```python
  from anime_episode_parser import parse_episode

  title = '[YMDR][哥布林殺手][Goblin Slayer][2018][05][1080p][AVC][JAP][BIG5][MP4-AAC][繁中]'
  assert (5, 1) == parse_episode(title)




  title = '[从零开始的异世界生活 第二季_Re Zero S2][34-35][繁体][720P][MP4]'
  assert (34, 2) == parse_episode(title)




  title = "something can't parse"
  assert (None, None) == parse_episode(title)
  ```


pkgId: 56ad8bc7f857c3c442aa1d4fcd545fb2c83db6206e44bd1297d8b412955b8a6f
name: python-anime-quiz
arch: src
version: 1.0
epoch: 0
release: 1
summary: Anime Themes Quiz for people with taste.
url: https://quiz.moe
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anime-quiz-1.0-1.src.rpm
checksum_type: sha256
description:
  **Official instance: [quiz.moe](https://quiz.moe)**

  Have you ever had an anime quiz with your friends,
  used a YouTube video for that and thought:

  > Man, this guy has a shit taste!

  Look no further!

  Anime Quiz pulls the anime you and your friends watched from
  your [MyAnimeList](https://myanimelist.net) profiles and randomly
  generates a quiz --- it first chooses one of the participants,
  then pulls their MAL list, gets links to themes hosted at
  [animethemes.moe](https://animethemes.moe), plays it and gives you
  10 seconds (configurable) to guess! Then the whole video is
  uncovered for you to enjoy and the person who guessed can
  shout at the gamemaster to add their points to the built-in
  scoreboard.



  * MAL lists pulled and cached for 7 days at the server
  * animethemes.moe queried and cached for 30 days
  * choice of MAL lists
  * choice of theme types (OP/ED)
  * choice of time to guess
  * all hosted online



  If you just want to play, go to [quiz.moe](https://quiz.moe).

  If you want to develop or self-host, the recommended way is to
  install [Docker](https://docker.com) with Docker Compose and run:
  ```shell
  docker network create server
  docker-compose up -d
  docker-compose exec anime_quiz python manage.py collectstatic
  ```

  That's it. Anime Quiz will be run at http://localhost:8009.
  To rebuild, run `docker-compose build` beforehand.



  PRs are welcome! The code is licensed under GNU Affero Public Licence 3.


pkgId: a417b62f6cabc3cd3918449743baeb17731f5808b144637fd4c332fefc28eaaf
name: python-anime4k-python
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Python wrapper of Anime4K GLSL shaders achieved with FFmpeg and libplacebo
url: https://pypi.org/project/anime4k-python/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anime4k-python-1.1.3-1.src.rpm
checksum_type: sha256
description:
  Python wrapper of Anime4K GLSL shaders achieved with FFmpeg and libplacebo.



  ```
  from anime4k_python import Anime4K

  anime4k = Anime4K(backend="mpv", mode="A")
  anime4k.process_video(
      "input.mp4",
      "output.mp4",
      1280,
      720,
      scale=2,
  )
  ```


pkgId: d6c68b8dbb594c7d82afe38cc4c4307a463aeff3c5985da7c9cba03e64b7ce84
name: python-animec
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: A module to get data about anime characters, news, info, lyrics and more.
url: https://github.com/DriftAsimov/animec
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animec-0.4.2-1.src.rpm
checksum_type: sha256
description:
  <p align = "center"><img width="248" height="248" src="https://i.imgur.com/IyUybvv.png"></p>

  <p align = "center"><a href="https://github.com/DriftAsimov/animec/stargazers"><img src = "https://img.shields.io/github/stars/driftasimov/animec?colorA=1e1e28&colorB=c9cbff&style=for-the-badge&logo=starship%20style=for-the-badge"></a>
  <a href = "https://discord.gg/x3qAZV3" target = "_blank"><img src="https://img.shields.io/discord/907385605422448742?style=for-the-badge&logo=discord&color=DDB6F2&logoColor=D9E0EE&labelColor=302D41"></a></p>



  A module to get data about anime characters, news, info, lyrics and more.
  The module scrapes [myanimelist](https://myanimelist.net/) to parse requested data.

  If you wish to see a feature, please raise an [issue](https://github.com/DriftAsimov/animec). We will surely work on it.
  You can also join our [Discord](https://discord.gg/x3qAZV3) to get regular updates about the module.

  See the Docs for a complete documentation: https://animec.readthedocs.io/en/latest/.



  To install the module:
  ```python
  pip install animec
  ```

  To import the module:
  ```python
  import animec

  from animec import *
  ```





  ```python
  result = Charsearch("okabe rintarou")

  print(result.title, result.url, result.image_url, sep="\n")

  '''
  Output: (As retrieved from myanimelist), check the documentation for a list of all supported attributes
  Rintarou Okabe (岡部 倫太郎)
  https://myanimelist.net/character/35252/Rintarou_Okabe
  https://cdn.myanimelist.net/images/characters/6/122643.jpg
  '''
  ```



  ```python
  news = Aninews()   #default value is 3, check the documentation for a list of all supported attributes

  print(news.titles)  #returns news titles
  print(news.descripion)   #returns news description

  ```



  ```python
  anime = Anime("dr stone")

  print(anime.url)
  print(anime.name)
  print(anime.description)    #check the documentation for a list of all supported attributes
  print(anime.recommend())  #returns a list of anime recommendations
  ```



  ```python
  lyrics = Anilyrics("Ashiato")
  print(lyrics.romaji())
  ```


  * [Documentation](https://animec.readthedocs.io/en/latest/)
  * [GitHub](https://github.com/DriftAsimov)
  * [MyAnimeList](https://myanimelist.net/)
  * [Animesonglyrics](https://www.animesonglyrics.com/)
  * [Kaomoji](http://kaomoji.ru/en/)
  * [Discord](https://discord.gg/x3qAZV3)


pkgId: 059ae6709673d023670c50c38e0087a3bb24784e2c665e7d294eab9a4663019c
name: python-animegifs
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Get random anime gifs by category.
url: https://github.com/MarcoSa-2000/animegifs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animegifs-1.2.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">

      <a href="https://pypi.org/project/animegifs/">

      <img src="https://img.shields.io/pypi/dm/animegifs?logo=PyPI&style=for-the-badge" alt="PyPi Downloads"/></a>

      <a href="https://discord.gg/TKZJ4GJj2z">

      <img src="https://img.shields.io/discord/856005478789677096?logo=Discord&style=for-the-badge" alt="Discord Server"/></a>

      <a href="https://pypi.org/project/animegifs/">

      <img alt="GitHub release (latest by date)" src="https://img.shields.io/github/v/release/MarcoSa-2000/animegifs?style=for-the-badge"></a>

      <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/animegifs?logo=Python&logoColor=%23FFFF00&style=for-the-badge">

      <img alt="GitHub watchers" src="https://img.shields.io/github/watchers/MarcoSa-2000/animegifs?style=social">

  </p>



  API wrapper for animegifs. Get random anime gifs by category. Use Python (intended (for now) for Discord).



  WIP - updated in time to time. Versions below v0.5.3 aren't expected to work flawlessly or at all.

  Version below v1.0 will not have the gifs library updated anymore and the gifs may return 404 as they were hosted on Discord.

  For troubleshoots, known errors and categories list, check below.



  `pip install animegifs`





  ```py



  from animegifs import animegifs



  gifs = animegifs.Animegifs()



  gif = gifs.get_gif(category) #gifs.get_gif('hug') and return the url of the gif.

  mal = gifs.get_mal(gif) #get url of the gif's anime myanimelist page.

  title = gifs.get_animetitle(gif) #get the title of the gif's anime.

  malid = gifs.get_malId(gif) #get the ID of the gif's anime myanimelist page.

  categories = gifs.get_categories() #get a list of available ctegories.

  ```



  ```py



  from animegifs import animegifs



  gifs = animegifs.Animegifs()



  user_input = input() #let user send any input and search if that input matches a category.





  try:

      gif = gifs.get_gif(user_input) #return the url of the gif if the category exists.

  except animegifs.errors.CategoryError:

      print("not a valid gif category.")

  ```







  **A**

  * Attack



  **B**

  * Bite, Bloodsuck, Blush, Bonk, Brofist



  **C**

  * Cry, Cuddle



  **D**

  * Dance, Disgust



  **E**

  * Exploding



  **F**

  * Facedesk, Facepalm, Flick, Flirt



  **H**

  * Handhold, Happy, Harass, Highfive, Hug



  **I**

  * Icecream, Insult



  **K**

  * Kill, Kiss



  **L**

  * Lick, Love



  **M**

  * Marry



  **N**

  * Nod, Nosebleed, Note, Nuzzle



  **P**

  * Pat, Peck, Poke, Popcorn, Pout, Punch, Punish



  **R**

  * Run



  **S**

  * Sad, Scared, Shoot, Shrug, Sip, Slap, Smack, Smirk, Sorry, Spank, Stare



  **T**

  * Tease, Threat, Tickle, Tired



  **W**

  * Wave



  **Y**

  * Yawn



  **Special Category List**



  * Random, Steal-magic







  You can test out the API (and lib functionality) on my bot's website here: https://enkidu-app.github.io/animegifs







  If you also want to contribute to the gifs collection, you can submit a gif at: https://forms.gle/wxWmRuy5VCdDCZWp8







  If you encounter an error, please raise an issue on the issue page: https://github.com/MarcoSa-2000/animegifs/issues.

  Alternatively, you can join my Discord server (https://discord.com/invite/TKZJ4GJj2z) to request new categories, functions, provide feedback, or report any errors.

  I do also have a multi-function Discord bot. Feel free to check out the web dashboard here: https://enkidu-app.github.io.







  This repository doesn't include any copyrighted material.

  If you happen to come across any copyrighted content within this repository (but hosted elsewhere) that you own or represent, email me at **grest0grest@gmail.com**.

  Please provide specific details about the copyrighted material and where it can be found.

  Once I confirm your claim, I'll take immediate action to remove the identified material.


pkgId: 1628121359922b4c03fcc5b7ee4b9490b6d97be71259dff91928f125284e5922
name: python-animegirlapi
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: An API that can output anime girls, and is 100% manually verified
url: https://pypi.org/project/animegirlapi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animegirlapi-1.6.0-1.src.rpm
checksum_type: sha256
description:
  AnimeGirlAPI is a Python package designed for easy interaction with the CatGirlNexus API. It provides functionalities to fetch image details, download images, and access various tags and ratings.



  To install AnimeGirlAPI, use `Poetry`. Ensure you have `Poetry` installed, then run:

  ```bash
  poetry install
  ```







  Retrieves information about a specific image from the API.

  **Parameters:**
  - `url` (str): The URL of the image.

  **Returns:**
  - A dictionary with:
    - `tags`: A dictionary of image tags (excluding "rating").
    - `rating`: The image's rating.

  **Example:**
  ```python
  info = get_info("https://example.com/image1.jpg")
  ```



  Gets a dictionary of all available tags with their descriptions.

  **Returns:**
  - A dictionary where:
    - Keys are tag names.
    - Values are descriptions of the tags.

  **Example:**
  ```python
  tags = get_all_tags()
  ```



  Downloads an image from the specified URL and saves it to the given path.

  **Parameters:**
  - `url` (str): The URL of the image.
  - `output` (str, optional): The file path where the image will be saved. If not specified, the image is saved with its filename in the current directory.

  **Returns:**
  - A dictionary with:
    - `path`: The path where the image was saved.

  **Example:**
  ```python
  download_image("https://example.com/image1.jpg", "images/image1.jpg")
  ```



  Fetches and returns a dictionary of all images from the API.

  **Returns:**
  - A dictionary with all image URLs and their associated data.

  **Example:**
  ```python
  images = get_all_images()
  ```



  Gets a list of all possible ratings.

  **Returns:**
  - A list of ratings, such as "suggestive", "nsfw", etc.

  **Example:**
  ```python
  ratings = get_all_ratings()
  ```



  Fetches a random image that matches the given tags and/or ratings.

  **Parameters:**
  - `number` (int): Number of images to fetch (up to 100).
  - `tag` (str, tuple, list, optional): Tags to filter images by.
  - `rating` (str, tuple, list, optional): Ratings to filter images by.
  - `ignore` (bool, optional): Whether to ignore warnings if not enough images are found.
  - `randomize` (bool, optional): Whether to shuffle images before selection.

  **Returns:**
  - A list of image URLs matching the specified criteria.

  **Example:**
  ```python
  random_images = get_random_image(number=5, tag=["catgirl"], rating="safe", randomize=True)
  ```



  - Python 3.6 or higher
  - `requests` library



  To run tests, use:

  ```bash
  poetry run pytest
  ```



  This project is licensed under the MIT License.



  Allexx <allexx129@gmail.com>


pkgId: 236be96cf4efd2e92cc8ed031d1b484ba76b72901fc14f70c98b8fe6d103284e
name: python-animeworld
arch: src
version: 1.6.4
epoch: 0
release: 1
summary: AnimeWorld UNOFFICIAL API
url: https://mainkronos.github.io/AnimeWorld-API/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animeworld-1.6.4-1.src.rpm
checksum_type: sha256
description:
  [![AnimeWorld](https://github.com/MainKronos/AnimeWorld-API/blob/master/docs/static/img/AnimeWorld-API.png)](https://mainkronos.github.io/AnimeWorld-API/)


  [![Version](https://img.shields.io/pypi/v/animeworld)](https://github.com/MainKronos/AnimeWorld-API/releases/latest)
  ![Activity](https://img.shields.io/github/commit-activity/w/MainKronos/AnimeWorld-API)
  [![Publish to PyPI](https://github.com/MainKronos/AnimeWorld-API/workflows/Publish%20to%20PyPI/badge.svg)](https://pypi.org/project/animeworld/)
  [![Deploy MkDocs](https://github.com/MainKronos/AnimeWorld-API/actions/workflows/deploy-mkdocs.yml/badge.svg)](https://github.com/MainKronos/AnimeWorld-API/actions/workflows/deploy-mkdocs.yml)

  ![PyPI - Downloads](https://img.shields.io/pypi/dm/animeworld)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/animeworld)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/animeworld)

  AnimeWorld-API is an unofficial library for [AnimeWorld](https://www.animeworld.so/) (Italian anime site).


  Questa libreria richiede [Python 3.7](https://www.python.org/) o superiore.

  È Possibile installarare la libreria tramite pip:
  ```shell script
  pip install animeworld
  ```


  Per ricercare un anime per nome nel sito di animeWolrd è possibile usare la funzione find().
  ```python
  import animeworld as aw

  res = aw.find("No game no life")
  print(res)
  ```
  La funzione estituirà un dizionario contentente per chiave il nome dell'anime e per valore il link della pagina di animeworld.
  ```python
  {'name': 'No Game no Life', 'link': 'https://www.animeworld.so/play/no-game-no-life.IJUH1', ...}
  ```
  È Possibile anche scaricare gli episodi di un anime.
  ```python
  import animeworld as aw

  anime = aw.Anime(link="https://www.animeworld.so/play/danmachi-3.Ydt8-")
  for episodio in anime.getEpisodes():
      print("Episodio Numero: ", episodio.number)

      if(episodio.download()):
          print("scaricato")
      else:
          print("errore")

      if x.number == '1': break
  ```
  ```
  Episodio Numero: 1
  scaricato
  ```



  La documentazione completa è disponibile qui: [Documentazione](https://mainkronos.github.io/AnimeWorld-API/)

  Per una panoramica di tutte le nozioni di base, vai alla sezione [QuickStart](https://mainkronos.github.io/AnimeWorld-API/usage/quickstart)

  Per argomenti più avanzati, vedere la sezione [Advanced Usage](https://mainkronos.github.io/AnimeWorld-API/usage/advanced)

  La sezione [API Reference](https://mainkronos.github.io/AnimeWorld-API/api-reference/developer-interface) fornisce un riferimento API completo.

  Se vuoi contribuire al progetto, vai alla sezione [Contributing](https://mainkronos.github.io/AnimeWorld-API/community/contributing)



  [![Star History Chart](https://api.star-history.com/svg?repos=MainKronos/AnimeWorld-API&type=Date)](https://star-history.com/#MainKronos/AnimeWorld-API&Date)


pkgId: 2248030d273c291f493d5c45640ea4900ddae199c51ecc8ee94065317dc90412
name: python-animl
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Tools for classifying camera trap images
url: https://github.com/conservationtechlab/animl-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-animl-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Training workflows are still under development. Please submit Issues as you come upon them.
  1. Assuming a file manifest of training data with species labels, first split the data into training, validation and test splits.
     This function splits each label proportionally by the given percentages, by default 0.7 training, 0.2 validation, 0.1 Test.
  ```python
  from animl import split
  train, val, test, stats = train_val_test(manifest, out_dir='path/to/save/data/', label_col="species",
                     percentage=(0.7, 0.2, 0.1), seed=None)
  ```
  2. Set up training configuration file. Specify the paths to the data splits from the previous step. Example .yaml file:
  ```
  seed: 28  # random number generator seed (long integer value)
  device: cuda:0  # set to local gpu device
  num_workers: 8  # number of cores

  num_classes: 53 #might need to be adjusted based on the classes file
  training_set: "/path/to/save/train_data.csv"
  validate_set: "/path/to/save/validate_data.csv"
  test_set: "/path/to/save/test_data.csv"
  class_file: "/home/usr/machinelearning/Models/Animl-Test/test_classes.txt"

  architecture: "efficientnet_v2_m"
  image_size: [299, 299]
  num_epochs: 100
  batch_size: 16
  learning_rate: 0.003
  weight_decay: 0.001

  overwrite: False
  experiment_folder: '/home/usr/machinelearning/Models/Animl-Test/'
  ```
  class_file refers to a flle that contains index,label pairs. For example:<br>
  test_class.txt
  ```
  id,Code,Species,Common
  1,cat, Felis catus, domestic cat
  2,dog, Canis familiaris, domestic dog
  ```
  3. (Optional) Update train.py to include MLOPS connection.
  4. Using the config file, begin training
  ```bash
  python -m animl.train --config /path/to/config.yaml
  ```
  Every 10 epochs, the model will be checkpointed to the 'experiment_folder' parameter in the config file, and will contain performance metrics for selection.
  5. Testing of a model checkpoint can be done with the "test.py" module.  Add an 'active_model' parameter to the config file that contains the path of the checkpoint to test.
     This will produce a confusion matrix of the test dataset as well as a csv containing predicted and ground truth labels for each image.
  ```bash
  python -m animl.test --config /path/to/config.yaml
  ```

  The Conservation Technology Lab has several models available for use.
  * Southwest United States [v3](https://sandiegozoo.box.com/s/p4ws6v5qnoi87otsie0ckmie0izxzqwo)
  * [Amazon](https://sandiegozoo.box.com/s/dfc3ozdslku1ekahvz635kjloaaeopfl)
  * [Savannah](https://sandiegozoo.box.com/s/ai6yu45jgvc0to41xzd26moqh8amb4vw)
  * [Andes](https://sandiegozoo.box.com/s/kvg89qh5xcg1m9hqbbvftw1zd05uwm07)
  * [MegaDetector](https://github.com/agentmorris/MegaDetector/releases/download/v5.0/md_v5a.0.0.pt)


