# packages

pkgId: a45bf95327f709ecb83502304c1831a367cd475dba49a4a37b07b9c0409e50f0
name: python-CreaTeBME
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Python Package for interfacing the bluetooth IMU module for CreaTe M8 BME.
url: https://github.com/CreaTe-M8-BME/CreaTeBME
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CreaTeBME-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/CreaTe-M8-BME/CreaTeBME/actions/workflows/build_publish.yml/badge.svg)](https://github.com/CreaTe-M8-BME/CreaTeBME/actions/workflows/build_publish.yml)
  [![PyPI](https://img.shields.io/pypi/v/CreaTeBME)](https://pypi.org/project/CreaTeBME/)

  Python Package for interfacing the bluetooth IMU module for CreaTe M8 BME.


  To install the latest stable version simply run this in your terminal.
  If you are using PyCharm then you can open the terminal on the bottom left of the screen.
  ```shell
  pip install CreaTeBME
  ```


  A simple example to connect to a sensor and read and print the data indefinitely.
  The package automatically connects to the device, so you do not have to connect to it manually.
  ```python
  from CreaTeBME import SensorManager


  manager = SensorManager(['0BE6'])


  manager.start()

  while True:
      measurements = manager.get_measurements()
      for sensor, data in measurements.items():
          if len(data) > 0:
              print(sensor, data)


  manager.stop()
  ```




  This package uses [Bleak](https://github.com/hbldh/bleak) for the bluetooth communication.
  Bleak uses asyncio, thus this package has to use this too.
  To ease usage, a wrapper has been made for people not experienced with asyncio.
  This wrapper also automates the connection of the sensors over bluetooth.

  To connect to the sensors, simply initialize a `SensorManager` object with the sensor names.
  ```python
  from CreaTeBME import SensorManager

  manager = SensorManager(['A1B2', 'C3D4'])
  ```
  Then start reading data from the sensors by calling the `start` method of the `SensorManager`.
  ```python
  manager.start()
  ```

  To get the IMU measurements the `get_measurements()' method can be used.
  This returns the measurements received since the last time this method was called.
  ```python
  measurements = manager.get_measurements()
  ```

  The data returned by this method is a dictionary containing a list for each sensor with the received measurements.
  A single measurement is a list of 6 floats.
  The measurements are structured like this
  - **[0:2]** = x,y,z of accelerometer in (g).
  - **[3:5]** = x,y,z of gyroscope in (deg/s).

  Finally, make sure to also call the `stop` method when exiting your program.
  ```python
  manager.stop()
  ```


  ⚠️**Understanding of** asyncio **required**⚠️

  Another way of connecting IMU sensors is to manually create `ImuSensor` objects.
  This can be done by specifying the BLE device that should be connected as a sensor.
  ```python
  from CreaTeBME import ImuSensor

  sensor = ImuSensor(device)
  ```

  The device has to be a Bleak _BLEDevice_ object that can be acquired using the `discover` method of `BleakScanner`.
  ```python
  from bleak import BleakScanner
  from CreaTeBME import ImuSensor

  async def connect():
      devices = await BleakScanner.discover(return_adv=True)
      sensor = ImuSensor(devices[0])
  ```



  For the API reference look [here](https://github.com/CreaTe-M8-BME/CreaTeBME/blob/main/docs/README.md)


pkgId: 1926d633377a65514a8fc046304b270d985c18a1d6353c0a1067cc432fb7d352
name: python-CrewWatch
arch: src
version: 0.0.1
epoch: 0
release: 1
url: https://github.com/Mayank-iitp/CrewWatch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrewWatch-0.0.1-1.src.rpm
checksum_type: sha256
summary:
  A Python library for AI monitoring that tracks resource usage, performance metrics, and operational health in real-time, designed for ease of integration and extensibility.


pkgId: f43519957cfa3b153dabf504d93b426d4d355afcfb02edccb5bd51aec7043d39
name: python-CriminAI
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: CriminAI est un logiciel de génération de portraits robots par IA
url: https://pypi.org/project/CriminAI/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CriminAI-1.0.6-1.src.rpm
checksum_type: sha256
description:
      CriminAI est un logiciel destiné à générer un portrait robot afin de simplifier la tâche de reconnaissance en cas d'aggression.
      Le fonctionnement du logiciel repose sur la génération d'images par le logiciel au travers d'un algorithme d'intelligence artificielle, l'autoencodeur variationnel.
      Le principe est que la victime puisse faire une sélection des portraits les plus ressemblants à partir d'images générées par IA de manière successive dans le but de s'approcher le plus possible du visage de l'aggresseur. La méthode de génération d'images à partir de la sélection de l'utilisateur est proche d'un algorithme génétique : on applique un bruit sur les différentes caractéristiques de l'image afin de générer de nouvelles images qui sont plus proches de l'ancienne.




      Génération automatique de portraits robots basée sur des algorithmes d'IA.
      Interface utilisateur conviviale pour permettre à l'utilisateur de sélectionner les portraits les plus ressemblants.
      Méthode de génération d'images inspirée d'un algorithme génétique pour affiner la ressemblance avec l'agresseur.




      Installation : Voir le fichier INSTALLATION.md sur la page GitHub suivante : github.com/matzouari/CriminAI
      Configuration : Assurez-vous d'avoir les dépendances nécessaires installées (voir le tutoriel de déploiement contenant la liste des dépendances).
      Lancement : Exécutez le fichier principal criminai.py pour démarrer l'application.
      Utilisation : Suivez les instructions à l'écran pour sélectionner les portraits les plus ressemblants et affiner la génération.




      Ce logiciel est en cours de développement et peut contenir des bugs.
      Pour signaler un bug ou demander une fonctionnalité, veuillez ouvrir une issue sur GitHub.




      La documentation pour ce projet Python est disponible à l'URL suivante : matzouari.github.io/CriminAI



      Lisa Perez (@perezlisa)
      Clémence Sutter (@clemencesutter)
      Zhihan Zhong (@zhihan222)
      Matis Zouari (@matzouari)

rpm_license:
  MIT License Copyright (c) 2024 ZOUARI Matis, PEREZ Lisa, SUTTER Clemence, ZHONG Zhihan 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: 0565103fb44abbd87136a7aca2a03b157179ef1cb8cacd692d347e6bd49117e7
name: python-CrossMap
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: CrossMap -- Lift over genomics coordinates between assemblies.
url: https://pypi.org/project/CrossMap/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrossMap-0.7.3-1.src.rpm
checksum_type: sha256
rpm_license:
  CrossMap is a program to lift over genome coordinates between different assembly versions. Copyright (C) 2024  Liguo Wang  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 3 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, see <https://www.gnu.org/licenses/>.


pkgId: 303f2a583c577d75537e47613c5845ea425c25a12e9b9dda79ab7f838e02a152
name: python-CrossRename
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Harmonize file names for Linux and Windows.
description: Harmonize file names for Linux and Windows.
url: https://github.com/Jemeni11/CrossRename
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrossRename-1.1.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Emmanuel C. Jemeni  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: 492c3532917cdb3d9bcfee8309ec278002c90974389d0da1ad3a03818b9f0d5e
name: python-CroustiiLog
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A customizable logging package
url: https://pypi.org/project/CroustiiLog/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CroustiiLog-0.1.1-1.src.rpm
checksum_type: sha256
description:
  **CroustiiLog** is a customizable logging package for Python that allows you to log messages with timestamps and different log levels such as `INFO`, `DEBUG`, `ERROR`, and `SUCCESS`. It also supports custom formatting and colorization for a more aesthetic and practical logging experience.



  - Colored logging output with customizable colors.
  - Customizable log format (e.g., with or without timestamps).
  - Multiple log levels: `INFO`, `DEBUG`, `ERROR`, `SUCCESS`, `FATAL`.
  - Support for key-value logging.
  - Tree-style vertical logging for structured data.




  You can install **CroustiiLog** via pip:

  ```bash
  pip install CroustiiLog



  from croustiilog import CustomLog


  log = CustomLog()


  log.info("This is an info log.")
  log.debug("This is a debug log.")
  log.error("This is an error log.")
  log.success("This is a success log.")
  log.fatal("This is a fatal log.")


  log.log("Retrieved", code="6969")


  from colorama import Fore

  log = CustomLog(color_map={
      "INFO": Fore.BLUE,
      "DEBUG": Fore.YELLOW,
      "ERROR": Fore.RED,
      "SUCCESS": Fore.GREEN,
      "FATAL": Fore.MAGENTA
  })

  log.info("This is a blue info log.")
  log.error("This is a red error log.")

  log = CustomLog(log_format="{timestamp} LEVEL > message")

  log.info("This is a custom formatted info log.")


pkgId: ab6f25d55586f9322040330a3e1520aab8af1b317ea222ca5a591cd941f766fd
name: python-CrowdClient
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: CrowdClient is a Python library for interacting with CrowdStrike Falcon's REST API.
url: https://github.com/tyler-tee/CrowdClient
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrowdClient-0.3.6-1.src.rpm
checksum_type: sha256
description:
  CrowdClient is a Python library for interacting with CrowdStrike Falcon's REST API.


  ```python
  pip install crowdclient
  ```




  ```python
  from CrowdClient.crowdclient import CrowdClient


  falcon_client = CrowdClient(<client_id>, <client_secret>)


  falcon_client.authenticate()



  detections = falcon_client.get_detections()


  host_count = falcon_client.indicator_host_count('8.8.8.8', 'ipv4')
  ```

  ```python
  from CrowdClient.crowdclient import RTRClient


  rtr_client = RTRClient(<client_id>, <client_secret>, verify_cert=False)
  rtr_client.authenticate()


  batch_id = rtr_client.batch_init(['hostid1', 'hostid2', 'hostid3'])


  rtr_client.batch_admin_cmd(batch_id, command='ls', command_string='ls C:\Users\', optional_hosts=['hostid3'])


  script_ids = rtr_client.get_scripts()


  script_details = rtr_client.script_details(script_ids)
  ```



  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 3c9c82b368d13d26b81668107506f565396ec2ed33b653fc51b76d1576d4cd12
name: python-CrunchyrollAPI
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: Crunchyroll API Python interface
url: https://github.com/jbsky/crunchyroll-api
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CrunchyrollAPI-0.1.14-1.src.rpm
checksum_type: sha256
description:
  Git repo : https://github.com/jbsky/crunchyroll-api

  All information is https://github.com/hyugogirubato/API-Crunchyroll-Beta/wiki

  **WARNING: You MUST be a PREMIUM member to use this module!**
  ***


  To give you an idea, it's possible to control this module with arguments.
  ```
  python3 src/CrunchyrollAPI/crunchyrollapi.py -h
  ```
  Identifiers are only mandatory for the 1st order, after which they are stored as JSON files.
  ```
  python3 src/CrunchyrollAPI/crunchyrollapi.py -u USENAME -p PASSWORD --subtitle SUBTITLE --subtitle-fallback SUBTITLE_FALLBACK
  ```


  * Everything is automatically tested by pytest.

  - [x] Login with your account
  - [x] Return list of seasons tag (format list str)
  - [x] Return list of seasons tag (format list item)
  - [x] Return list of categories (format list str)
  - [x] Return list of categories (format list item)
  - [x] Return episode for one season
  - [x] Search for series by string
  - [x] Search for episode by string
  - [x] Return episodes by season id
  - [x] Return seasons by series id


  ***

rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU Affero General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  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 state 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 Affero General Public License as published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.  You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <http://www.gnu.org/licenses/>.


pkgId: bb17f0e53f92839b0ce1bd62d5f9964b2b4c2c353fe9964fc18484fe027bcc39
name: python-CryptoApi2
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/tercjak/CryptoAPI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CryptoApi2-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  CryptoAPI is a powerful Python library designed to simplify interaction with various cryptocurrency APIs. (Binance REST and WebSockets)

description:
  __CryptoAPI__ is a powerful Python library designed to simplify interaction with various cryptocurrency APIs.

   It offers a user-friendly typed interface to .
  1) fetch real-time market data
  2) historical data
  3) execute trades.

  **Key Features:**

  -   ****Real-time Data****: Access to real-time market data, including prices, volumes, and order books.
  -   ****Historical Data****: Retrieve historical price and trading data.
  -   ****WebSockets****: Establish persistent connections for live updates and event-driven programming.
  -   ****REST API****: Interact with RESTful APIs for flexible data retrieval with **typed responses and parameters**.
  -   ****Asynchronous Support****: Efficiently handle multiple API requests concurrently.
  -   ****Error Handling****: Robust error handling and informative error messages.
  -****Typed API**  -Responeses of requests are returned as pydantic types

  ** EXAMPLE app.py **
      import numpy as np
      from binance_client.BinanceAuth import BinanceAuth
      from binance_client.BinanceFuturesClient import BinanceFuturesClient
      from binance_client.BinanceTrader import BinanceTrader


      api_key=os.environ['BINANCE_API_KEY'] # you can store your credintials in environment variables
      api_secret=os.environ['BINANCE_API_SECRET']

      auth_data=BinanceAuth(api_key,api_secret) #pass your binance credintials

      symbols = ["BTCUSDT", "ADAUSDT"] # choose symbols
      trader=BinanceTrader(auth_data,symbols,is_paper_trading=True) # create BinanceTrader so you have access to trading functionality



      def run_test_cases(trader: BinanceTrader):

          def log_hedge(row:TicketRow): #function which reacts to price changes
              print(row)
              prices_dict=row.prices
              keys=trader.symbols
              betas=[1,-1]


              order_dict=row.prices.copy()

              sum=0.0

              for i in range(0,len(keys) -1) :
                  key=keys[i]
                  price=np.log(prices_dict[key])* abs(betas[i])
                  order_dict[key]=price
                  sum+=price


              for i in range(0,len(keys) -1) :
                  v=order_dict[key]
                  v/=sum
                  v= v if betas[i]>1 else -v
                  order_dict[key]=v


              print("order_dict")
              print(order_dict)
              return trader.modify_order(order_dict)

          def getBetas()->tuple[float,float]:{
              1,-1
          }

          trader.setSingleOnNextUpdate(log_hedge)

          trader.run()

  You have just written a simple function that reacts to prices, of course you can refine it, e.g. calculate beta coefficients from regression and add additional explaination variables eg.inflation .
  After entering the quantity in `modify_order`, the difference from the current orders is converted into market orders.



  1) fetch real-time market data execute trades (binance,REST)
  2) websocket support , hedging positions


pkgId: e128ecda077eca99a608336cdb7f57974939b33253da632ba06085bbd8d3bda3
name: python-CryptoFuzz
arch: src
version: 16.9.3
epoch: 0
release: 1
url: https://github.com/Pymmdrza/cryptoFuzz
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CryptoFuzz-16.9.3-1.src.rpm
checksum_type: sha256
summary:
  Generated and Converted Keys with any Type Foundation from Private Key [WIF Hexed Mnemonic and Binary Bytes seed] in Python

description:
  [![](https://img.shields.io/badge/%20Update%20at-2024.09.28-009848?style=plastic)]()
  [![](https://img.shields.io/badge/More%20Detail-0049AB?style=plastic)](https://cryptofuzz.readthedocs.io/en/latest/ton/ 'cryptoFuzz - Ton')
  Add New Class For Generate and Convert TON Address.
  - `cryptofuzz.Ton`
  - `cryptofuzz.Ton.privatekey_to_address`
  - `cryptofuzz.Ton.mnemonic_to_address`
  - `cryptofuzz.Ton.decimal_to_address`
  - `cryptofuzz.Ton.publickey_to_address`


pkgId: 39c4b04210efe0d10479afe390fad14340aad23b5b0522dafd236ec210194777
name: python-Crystally
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Python module to model and analyze crystal structures
url: https://git.rwth-aachen.de/john.arnold/Crystally.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Crystally-0.6.1-1.src.rpm
checksum_type: sha256
description:
  **crystally** is a python library designed to analyze and manipulate crystal structures. It is intended to be easy to learn and
  understand. Have a look at the documentation to get started and an idea of the capabilities of the module.

  Documentation: https://crystally.readthedocs.io/en/latest/

  Examples:
  ```python
  import crystally as cr


  ceria = cr.examples.ceria()


  ceria.distance(ceria[0], ceria[1])


  ceria.get_in_radius(ceria[0], 3.0)


  ceria[0].position = [0.0, 0.1, 0.0]
  ```


pkgId: 7943e4ab1e9270800294cc0d7f018a510df172770c00f312f443661166178d08
name: python-CsPy-Uploading
arch: src
version: 1.0.11
epoch: 0
release: 1
summary: Package useful for THG staff to aid data pipeline implementation
url: https://github.com/JamesRobinson-THG/CsPy_Uploading/archive/1.0.11.tar.gz
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CsPy-Uploading-1.0.11-1.src.rpm
checksum_type: sha256
description:
  This is a simple example package. You can use
  [Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.


pkgId: 5a792f2986fed3f72d6635812c9c296951bbc5af3249713699d1f7a75bb6def8
name: python-CueParser
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Simple cue file parser.
url: https://github.com/artur-shaik/CueParser
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CueParser-1.3.2-1.src.rpm
checksum_type: sha256
description:
  Simple cue file parser and generator written in python.
  Parser outputs cue file content in plain text. Generator can create cue file from timed tracklist.


pkgId: 8a77100976f86cf4547e9224460d0b934d2d4c37a3b9a1eea63676fd73444975
name: python-CurrencyConverter
arch: src
version: 0.17.31
epoch: 0
release: 1
summary: A currency converter using the European Central Bank data.
url: https://github.com/alexprengere/currencyconverter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CurrencyConverter-0.17.31-1.src.rpm
checksum_type: sha256
description:
  The default source is the `European Central Bank <https://www.ecb.europa.eu>`_. This is the ECB historical rates for 42 currencies against the Euro since 1999.
  It can be downloaded here: `eurofxref-hist.zip <https://www.ecb.europa.eu/stats/eurofxref/eurofxref-hist.zip>`_.
  The converter can use different sources as long as the format is the same.
  Note that the currency converter does not query the API in real time, to avoid the overhead of the HTTP request. It uses embedded data in the library, which might not be up to date.
  If you need the latest data, please refer to the *data* section.


pkgId: 1e6889eb13e3de237927ac2eabb1fdc28803bc8f5e27ccaecdb84ae56fbf82f7
name: python-CurseForgeAPy
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: A wrapper for the Eternal (CurseForge) API
url: https://pypi.org/project/CurseForgeAPy/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CurseForgeAPy-1.1.5-1.src.rpm
checksum_type: sha256
description:
  [![GitHub issues](https://img.shields.io/github/issues/James2854/CurseForgeAPy?style=for-the-badge)](https://github.com/James2854/CurseForgeAPy/issues)
  [![GitHub stars](https://img.shields.io/github/stars/James2854/CurseForgeAPy?style=for-the-badge)](https://github.com/James2854/CurseForgeAPy/stargazers)
  [![GitHub license](https://img.shields.io/github/license/James2854/CurseForgeAPy?style=for-the-badge)](https://github.com/James2854/CurseForgeAPy)

  CurseForgeAPy is a Python package that provides a wrapper for the CurseForge API / Eternal API. With CurseForgeAPy, you can easily access and interact with the API in your Python scripts and applications. Currently, the entire API has been wrapped and each data structure has been reconstructed into seperate classes, which can be found within SchemaClasses.py.



  To install CurseForgeAPy, simply use pip:
  ```bash
  pip install CurseForgeAPy
  ```



  To use CurseForgeAPy, you will need to obtain an API key from CurseForge. You can do this by creating an account on CurseForge and requesting an API key from [the developer portal](https://console.curseforge.com/#/api-keys).

  Once you have obtained an API key, you can use CurseForgeAPy as follows:

  ```python
  from CurseForgeAPy import CurseForgeAPI


  client = CurseForgeAPI('YOUR_API_KEY')


  response = client.getGames() # -> returns a GetGamesResponse

  print(response)
  ```



  For full documentation of the CurseForge API, please see the official CurseForge API documentation at https://docs.curseforge.com/. Docstrings are also available for some functions, however complete docstring creation for all functions is ongoing.



  Here are some examples of how you can use CurseForgeAPy to access and interact with the CurseForge API:



  ``` Python

  games = cf.getGames()


  game = cf.getGame(432)


  versions = cf.getVersions(432)


  versionTypes = cf.getVersionTypes(432)


  categories = cf.getCategories(432)
  ```


  ``` Python
  import CurseForgeAPy.SchemaClasses as schemas


  searchResults = cf.searchMods(432)


  mod = cf.getMod(729219)


  mods = cf.getMods([729219])


  featuredModsSearch = schemas.GetFeaturedModsRequestBody(432, [], 73242)


  featuredMods = cf.GetFeaturedMods(featuredModsSearch)


  modDescription = cf.getModDescription(729219)


  modFile = cf.getModFile(729219, 4159320)


  modFiles = cf.getModFiles(729219)
  ```


  ``` Python

  files = cf.getFiles(schemas.GetModFilesRequestBody([4159320]))


  changelog = cf.getModFileChangelog(729219, 4159320)


  modFileDownloadUrl = cf.getModFIleDownloadUrl(729219, 4159320)
  ```


  ``` Python

  fingerprintsMatches = cf.getFingerprintsMatches(schemas.GetFingerprintMatchesRequestBody([2352728825]))


  fuzzyMatches = cf.getFingerprintsFuzzyMatches(schemas.GetFuzzyMatchesRequestBody(432, [schemas.FolderFingerprint("test", [2352728825])]))

  ```

  ``` Python

  minecraftVersions = cf.getMinecraftVersions()


  minecraftVersion = cf.getSpecificMinecraftVersion("1.16.5")


  minecraftModloaders = cf.getMinecraftModloaders()


  minecraftModloader = cf.getSpecificMinecraftModloader("forge-1.16.5-36.1.0")
  ```


  ``` Python



  from CurseForgeAPy import Utils
  from CurseForgeAPy import SchemaClasses as schemas


  cf = CFAPI('YOUR-API-KEY')


  Utils.downloadFileFromURL(cf, "file-url", "file-path")


  Utils.downloadFileFromID(cf, 111111, "file-path")


  Utils.downloadFileFromModID(cf, 111111, "file-path")


  Utils.downloadFileFromModIDAndFileID(cf, 111111, 222222, "file-path")



  Utils.downloadFileFromModIDVersion(cf, 111111, "1.16.5", "file-path", schemas.ReleaseType.Release)
  ```



  If you have any issues or questions while using CurseForgeAPy, please feel free to open an issue on the GitHub repository or contact us through our support channels.



  We welcome contributions to CurseForgeAPy! Please feel free to open a pull requests or issue if you would like a new feature.


pkgId: 9e7feb0ece383d7fc6d9a69eeb9166696756b61f7ad3d7b1a6d764ec331de854
name: python-Custmr-segmentation
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A customer segmentation package for preprocessing data
url: https://pypi.org/project/Custmr-segmentation/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Custmr-segmentation-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This data analysis package provides comprehensive tools for preprocessing, feature engineering, clustering, and feature selection/reduction of data. It streamlines and automates common data analysis tasks, making it easier to prepare datasets for further analysis and machine learning. The package includes functionalities for validating data structure, handling missing values, removing outliers, scaling data, and much more.



  - **Data Preprocessing**
    - **Data Structure Validation:** Ensures that the dataset meets expected structural requirements.
    - **Null Value Removal:** Identifies and removes or imputes missing values.
    - **Outlier Removal:** Detects and removes outliers from the dataset.
    - **Data Scaling:** Standardizes or normalizes data for consistent analysis.

  - **Feature Engineering**
    - **RFM (Recency, Frequency, Monetary) Calculation:** Computes RFM metrics for customer segmentation and analysis.
    - **Velocity Calculation:** Measures the rate of change in data over time.
    - **Growth Calculation:** Computes the growth metrics across data points.

  - **Feature Selection and Reduction**
    - **Information Gain Calculation:** Evaluates the importance of features in predicting target variables.
    - **WOE (Weight of Evidence) and IV (Information Value) Calculation:** Assesses the predictive power of categorical features.
    - **PCA (Principal Component Analysis):** Reduces dimensionality of data and allows for inverse transformation to original space.

  - **Advanced Clustering**
    - **Best Clustering Method Selection:** Provides various clustering algorithms (e.g., KMeans, DBSCAN, EM, MeanShift, Agglomerative) and selects the most suitable one based on data characteristics.




  To use this package, you need to have the following installed:

  - Python 3.7 or higher
  - The following Python libraries:
    - `pandas`
    - `numpy`
    - `scikit-learn`
    - `scipy`
    - `matplotlib`
    - `seaborn`
    - `statsmodels`

  You can install these dependencies using:

  ```bash
  pip install -r requirements.txt
  ```
  To import the package,you can use the following format:
  ```bash
  from customer_segmentation_clustering.main import main
  ```


pkgId: cb15339a81551f9cd8504c084e6f793d4c4c215859067d6e8ddc718971bfd9f8
name: python-CustomDiagramIcons
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/CustomDiagramIcons/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CustomDiagramIcons-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  This is intended to be used in a project that uses the diagrams (diagrams as code) python package as an extention of the icons.

description:
  This is intended to be used in a project that uses the diagrams (diagrams as code) python package as an extention of the icons.

  To import the latest build of this library into your project use `pip install CustomDiagramIcons`


pkgId: c3c3c72d52ba9b9d8de5b757277cad58fd8e711fb874d703bfc26f1321031f0a
name: python-CuttApi
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/devrajdevs/CuttApi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CuttApi-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  One of the best ways of shortening URLs using Cuttly URL shortener just by entering your API key and seeing the rest that is done automatically by the Module

description:
  One of the best URL shortener modules for Python of all time!

  CuttApi is one of the best ways of shortening URLs using Cuttly URL shortener just by entering your API key and seeing the rest that is done automatically by the Module



  Installing requirements to establish the Module:

  ```
  requests
  urllib3
  pyperclip
  ```

  **Use pip to Install the above Modules**



  The only thing users need to do is:

  ```python
  from CuttApi import Cuttshort
  import stdiomask
  api_key = stdiomask.getpass("Enter your Cuttly api key: ")
  short = Cuttshort(api_key)
  ```

  * If you enter the correct API key, then you proceed.
  * But if you enter a wrong one, you proceed only after entering the correct one.
  * As you proceed, the same thing happens with Links and Alias (if you wanna give), but that's good since the process doesn't start over from the start of entering the API key.



  Cuttshort class is supported by one more class which is a URL corrector as well as checker!

  ```python
  from CuttApi import yurl
  a = yurl("google.com").link
  print(a)
  ```

  This returns `https://www.google.com/` And that happens whether you put:
  * google.com
  * http://google.com
  * https://google.com
  * google.com/
  * http://google.com/
  * https://google.com/
  * www.google.com
  * http://www.google.com
  * https://www.google.com
  * www.google.com/
  * http://www.google.com/
  * https://www.google.com/



  CuttApi developer respects your privacy! The data you enter does not go over the net except to CuttLy for creations and updates. The data you enter is safely stored on your device, so that you can work on links and find them easily!

  Please keep the following points in mind:
  * Don't delete the file to make sure you have the best experience!
  * The file is stored with the name as your API key, so any manual updates by the user to this file can cause the user not being able to use the latest feature!
  * Multiple API keys can be used on the same device!



  Feedbacks are vital for any software! You say, we make, you try @ https://cutt.ly/CuttApifeedback



  MIT

  Copyright (c) 2024 Devraj Therani

  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: 88697f641ea6b6827f5da7a9615ce7d5a6803897b5c371995cf159b8bff37272
name: python-CxAdmin
arch: src
version: 1.0.77
epoch: 0
release: 1
summary: Python SDK for interacting with the CxEngage API
url: https://github.com/ntflix/cxadmin
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CxAdmin-1.0.77-1.src.rpm
checksum_type: sha256
description:
  ![](readme/logo.jpg)



  CxAdmin is a Python API client for the CxEngage API. It is a work in progress and is not yet complete.

  All objects are designed to mirror their CxEngage counterparts. For example, a CxList object has the exact same properties as a list on the CxEngage platform.
  Together with the way this program is designed, this means you can fetch items from CxEngage, manipulate them locally, and then upload them back to CxEngage, without having to worry about the API.

  This API is designed to be easily expandable. If you would like to add functionality, please feel free to submit a pull request.


  - [] Any object to CSV
  - [X] Any object to JSON


  * [Set up API client](#set-up-api-client)
  * [Get Everything](#get-everything)
  * [Queues](#queues)
  * [Lists](#lists)
  * [Users](#users)
  * [Groups](#groups)
  * [Business Hours](#hours)
  * [Environment](#environment)
  * [Flows](#flows)
  * [Statistics](#statistics)



  ```py
  import CxAdmin

  cx = CxAdmin.Cx(
      baseURL="your_base_url", # https://eu-west-1-prod-api.cxengage.net for EU, https://api.cxengage.net for US
      apiKey="your_api_key",
      apiSecret="your_api_secret",
      tenantID="your_tenant_id",
  )
  ```

  or

  ```py
  import CxAdmin

  cx = CxAdmin.Cx.fromConfigFile("config.json")
  ```

  > Example config.json

  ```json
  {
      "baseURL": "https://eu-west-1-prod-api.cxengage.net",
      "apiKey": "73668f12-4da1-9991-p182-83ufb38193pa",
      "apiSecret": "biglongjumblystringoflettersandnumbershere",
      "tenantID": "893jwa23-85k2-895k-1562-93pot7367185"
  }
  ```





  ```py
  from CxAdmin import Cx
  import json

  cx: Cx
  dev = True
  if dev:
      cx = Cx.fromConfigFile("config.dev.json")
  else:
      cx = Cx.fromConfigFile("config.prod.json")

  for item in cx.items:
      print(item)
      out = item.get()
      name = str(item)[13:]
      name = name[: name.index(".")]
      file = open(f"output/{name}.json", "w")
      output = json.dumps(out)
      file.write(output)
  ```

  This will fetch all items from CxEngage and save them to `output/` as JSON files.




  ```py
  cx.queues.getQueues()
  ```
  or
  ```py
  cx.queues.get() # same as getQueues()
  ```


  ```py
  cx.queues.getActiveQueues()
  ```




  ```py
  cx.lists.get()
  ```


  ```py
  cx.lists.getList(listId)
  ```


  ```py
  cx.lists.getListCSV(listId)
  ```


  ```py
  myList = cx.lists.getList(listId) # get a list
  csv: list[str] = myList.toCSV() # convert to CSV, returns a list of strings
  ```





  ```py
  cx.users.getAllUsers()
  ```
  or
  ```py
  cx.users.get() # same as getAllUsers()
  ```





  ```py
  cx.groups.getGroups()
  ```
  or
  ```py
  cx.groups.get() # same as getGroups()
  ```




  ```py
  hours = cx.hours.get()
  ```


  ```py
  for hour in hours:
      print(f"{hour.name} - {hour.getBusinessHours()})
  ```




  ```py
  cx.environment.getTenant()
  ```
  or
  ```py
  cx.environment.get() # same as getTenant()
  ```



  ```py
  cx.environment.getRegions()
  ```





  ```py
  cx.flows.getFlows()
  ```
  or
  ```py
  cx.flows.get() # same as getFlows()
  ```



  ```py
  cx.statistics.getInteractions(between: (datetime, datetime))
  ```


pkgId: bb850e320a59dd73dccef4ae1ef4353c6d728fdeb92751ebc286c48140e22505
name: python-CyberBook
arch: src
version: 0.0.27
epoch: 0
release: 1
summary: Cyber spellbook for developers.
url: https://pypi.org/project/CyberBook/
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CyberBook-0.0.27-1.src.rpm
checksum_type: sha256
description:
  This is a collection of functions / tools that are used frequently enough to store them some place.
  Feel free to check out the docs at [CyberBookDocs](https://clutchreboot.github.io/CyberBookDocs/).


pkgId: 828a758b5dddde09feb506baf7b4be473bdc4178a0465ca082fbaaf3f7cb956f
name: python-CyberOsint
arch: src
version: 0.4
epoch: 0
release: 1
summary: A tool for OSINT
url: https://github.com/TheCyberStalker/CyberOsint
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CyberOsint-0.4-1.src.rpm
checksum_type: sha256
description:
  CyberOsint is a tool for OSINT (Open Source Intelligence).



  You can install the package via pip:

  ```sh
  pip install CyberOsint
  ```



  To use the tool, simply run:

  ```sh
  cyberosint
  ```


pkgId: 343e0f70190cfe4c13dfaa386ab827564a8ffcf344a530b18dd976b1ed1cd8e0
name: python-Cyclic-diagram-RunningTrainsPlot
arch: src
version: 2024.0.0
epoch: 0
release: 1
summary: An open-source library for visualizing transportation data
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cyclic-diagram-RunningTrainsPlot-2024.0.0-1.src.rpm
checksum_type: sha256
description:
  Given this background and current research and development status, we believe that it is necessary to develop an open-source library for visualizing data in rail transit organization, covering the vast majority of operational data visualization functions in the field of rail transit organization. This will further address the growing volume of transportation data and information, improve transportation research efficiency, and meet standardization requirements This open-source library will not only provide data based drawing functions for rail transit researchers, but also provide more comprehensive and convenient scheduling and planning visualization support for railway industry practitioners based on the needs and application scenarios of the rail transit transportation sector, promoting the digital transformation and innovative development of the rail transit fieldYou can use
  [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.


pkgId: be5b7c830afe5600161682715f497b78fde2070424785bdd857d8a3cf91626e8
name: python-Cython
arch: src
version: 3.0.11
epoch: 0
release: 1
summary: The Cython compiler for writing C extensions in the Python language.
url: https://cython.org/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Cython-3.0.11-1.src.rpm
checksum_type: sha256
description:
  The Cython language makes writing C extensions for the Python language as
  easy as Python itself.  Cython is a source code translator based on Pyrex_,
  but supports more cutting edge functionality and optimizations.

  The Cython language is a superset of the Python language (almost all Python
  code is also valid Cython code), but Cython additionally supports optional
  static typing to natively call C functions, operate with C++ classes and
  declare fast C types on variables and class attributes.  This allows the
  compiler to generate very efficient C code from Cython code.

  This makes Cython the ideal language for writing glue code for external
  C/C++ libraries, and for fast C modules that speed up the execution of
  Python code.

  Note that for one-time builds, e.g. for CI/testing, on platforms that are not
  covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
  that we provide is not used, it is substantially faster than a full source build
  to install an uncompiled (slower) version of Cython with::

      pip install Cython --install-option="--no-cython-compile"

  .. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/


pkgId: 3068b85add36021ddd6b22f8838b7f53fa9f0d0e6302acbca4809bc9eaee7891
name: python-CytoTable
arch: src
version: 0.0.12
epoch: 0
release: 1
url: https://github.com/cytomining/CytoTable
rpm_license: BSD-3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CytoTable-0.0.12-1.src.rpm
checksum_type: sha256
summary:
  Transform CellProfiler and DeepProfiler data for processing image-based profiling readouts with Pycytominer and other Cytomining tools.

description:
  <img height="200" src="https://raw.githubusercontent.com/cytomining/cytotable/main/logo/with-text-for-light-bg.png?raw=true">



  ![dataflow](https://raw.githubusercontent.com/cytomining/cytotable/main/docs/source/_static/dataflow.svg?raw=true)
  _Diagram showing data flow relative to this project._



  CytoTable enables single-cell morphology data analysis by cleaning and transforming CellProfiler (`.csv` or `.sqlite`), cytominer-database (`.sqlite`), and DeepProfiler (`.npz`), and other sources such as IN Carta data output data at scale.
  CytoTable creates parquet files for both independent analysis and for input into [Pycytominer](https://github.com/cytomining/pycytominer).
  The Parquet files will have a unified and documented data model, including referenceable schema where appropriate (for validation within Pycytominer or other projects).

  The name for the project is inspired from:

  - __Cyto__: "1. (biology) cell." ([Wiktionary: Cyto-](https://en.wiktionary.org/wiki/cyto-))
  - __Table__:
    - "1. Furniture with a top surface to accommodate a variety of uses."
    - "3.1. A matrix or grid of data arranged in rows and columns." <br> ([Wiktionary: Table](https://en.wiktionary.org/wiki/table))



  Install CytoTable from [PyPI](https://pypi.org/) or from source:

  ```shell

  pip install cytotable


  pip install git+https://github.com/cytomining/CytoTable.git
  ```



  We test CytoTable using `ubuntu-latest` and `macos-latest` [GitHub Actions runner images](https://github.com/actions/runner-images#available-images).

  Please see [contributing.md](docs/source/contributing.md) for more details on contributions, development, and testing.



  - [pycytominer](https://github.com/cytomining/pycytominer)
  - [cytominer-database](https://github.com/cytomining/cytominer-database)
  - [DeepProfiler](https://github.com/cytomining/DeepProfiler)
  - [CellProfiler](https://github.com/CellProfiler/CellProfiler)
  - [cytominer-eval](https://github.com/cytomining/cytominer-eval)


pkgId: cc87325b13335d952acec8c536774008284a66d30bad2ddeac6c384b66f2f918
name: python-CytofDR
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: CyTOF Dimension Reduction Framework
url: https://github.com/kevin931/CytofDR
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-CytofDR-0.3.1-1.src.rpm
checksum_type: sha256
description:
  > A framework of dimension reduction and its evaluation for both CyTOF and general-purpose usages.

  ![Logo](/assets/logo.png)

  | Branch | Release | CI/CD | Documentation | Code Coverage |
  | --- | --- | --- | --- | --- |
  | dev | ![Badge1](https://img.shields.io/badge/Version-0.3.1-success) |![Tests](https://github.com/kevin931/CytofDR/actions/workflows/ci.yml/badge.svg?branch=dev) | [![Documentation Status](https://readthedocs.org/projects/cytofdr/badge/?version=latest)](https://cytofdr.readthedocs.io/en/latest/?badge=latest) | [![codecov](https://codecov.io/gh/kevin931/CytofDR/branch/dev/graph/badge.svg?token=K9AJQLYU8N)](https://codecov.io/gh/kevin931/CytofDR) |




  CytofDR is a framework of dimension reduction (DR) and its evaluation for both Cytometry by Time-of-Flight (CyTOF) and general-purpose usages. It allows you to
  conveniently run many different DRs at one place and then evaluate them to pick your embedding using our extensive evaluation framework! We aim to provide you with a reliable, extensible, and convenient interface for all your DR needs for both data analyses and future research!



  - For **detailed benchmarks and methodology explanations**, please check out [our paper](https://doi.org/10.1038/s41467-023-37478-w) in *Nature Communications*!
  - For an online version of **interactive results**, please checkout [CytofDR Playground](https://dbai.biohpc.swmed.edu/cytof-dr-playground/).
  - For **documentation**, please visit our free and detailed [documentation page](https://cytofdr.readthedocs.io/en/stable/index.html).



  You can install our CytofDR package, which is currentl on ``PyPI``:

  ```shell
  pip install CytofDR
  ```

  Python (>=3.7) is **required**. This pacackage is architecture agnostic: it should run where PyPI or conda is available. All dependencies should be automatically installed. For a list of optional dependencies, please visit our documentation page's detailed [Installation Guide](https://cytofdr.readthedocs.io/en/latest/installation.html).

  Intallation should take less than a few minutes for most computers with reasonable network connections.



  I personally recommend using ``conda`` to install everything since it's so easy to work with virtual environments. If you need help on how to get ``conda`` installed in the first place, take a look [here](https://docs.anaconda.com/anaconda/install/).

  To install the package with ``conda``:

  ```shell
  conda install -c kevin931 cytofdr -c conda-forge -c bioconda
  ```
  The core dependencies should automatically install!



  Our dependencies are broken down core dependencies and optional dependencies. Below is a list of core dependencies:

  - scikit-learn
  - numpy
  - scipy
  - umap-learn
  - openTSNE
  - phate
  - annoy
  - matplotlib
  - seaborn

  The most current compatible versions will work with ``CytofDR``, except for ``numpy``. New versions of ``numpy`` can cause issues with ``conda``. If you wish to use ``PyCytoData``, you need to install ``numpy`` version 1.20 or 1.21.

  We also have some optional dependencies which are much trickier to install and manage. Refer to our [Installation Guide](https://cytofdr.readthedocs.io/en/latest/installation.html) for more details.



  ``CytofDR`` is a member of the **PyCytoData Alliance Plus**, meaning that we're compatible with the ``PyCytoData`` package. The ``PyCytoData`` package is used mainly for loading datasets and managing every step of the CyTOF workflow. By creating and maintaining this ecosystem, we hope to create a robust workflow as a one-stop solution for CyTOF practioners using Python. To install ``PyCytoData``, you can simply use the following command:

  ```shell
  pip install PyCytoData
  ```

  To view how you can perform DR using ``PyCYtoData``, [this tutorial](https://pycytodata.readthedocs.io/en/latest/tutorial/dr.html) walks through every step.



  ``CytofDR`` makes it easy to run many DR methods while also evaluating them for your CyTOF samples. We have a greatly simplified pipeline for your needs. To get started, follow this example:

  ```python
  >>> import numpy as np
  >>> from CytofDR import dr

  >>> expression = np.loadtxt(fname="PATH_To_file", dtype=float, skiprows=1, delimiter=",")

  >>> results = dr.run_dr_methods(expression, methods=["umap", "pca"])
  Running PCA
  Running UMAP
  >>> results.evaluate(category = ["global", "local", "downstream"])
  Evaluating global...
  Evaluating local...
  Evaluating downstream...
  >>> results.rank_dr_methods()
  {'PCA': 1.0, 'UMAP': 2.0}

  >>> results.save_all_reductions(save_dir="PATH_to_DIR", delimiter=",")
  >>> results.save_evaluations(path="PATH_to_FILE")
  ```
  We strive to make our pipeline as simple as possible with natural langauge-like method names. Depending on your dataset size, the above example's runtime may vary. PCA is extremely fast, whereas can take upwards of 10 minutes if the dataset is much larger than 100,000 cells. For the `evaluate` command, the downstream command's silhouette score and clustering step can take some time, but for a small dataset, it can accomplish evaluation within a few minutes.

  For large dataset, we recommend using efficient DR methods and providing your own clustering algorithm if possible.



  We have included an example dataset generated by ``cytomulate`` in the `/example` folder. The data is an artificial data with 1000 cells to mimic real CyTOF data. To use the dataset, you can subsitute `PATH_to_file` with the path to the example dataset `exprs.txt`, which is in the expression matrix format.



  You can use ``PyCytoData`` to load your dataset:

  ```python
  >>> from CytofDR import dr
  >>> from PyCytoData import FileIO

  >>> dataset = FileIO.load_expression("PATH_To_file", col_names = True)

  >>> results = dr.run_dr_methods(dataset.expression_matrix, methods=["umap", "pca"])
  Running PCA
  Running UMAP
  ```
  Or with a benchmark dataset:

  ```python
  >>> from CytofDR import dr
  >>> from PyCytoData import DataLoader

  >>> dataset = DataLoader.load_dataset(dataset = "levine13")

  >>> results = dr.run_dr_methods(dataset.expression_matrix, methods=["umap", "pca"])
  Running PCA
  Running UMAP
  ```

  All subsequent workflows remain the same.



  Of course, there are many more customizations and ways you can use ``CytofDR``. So, for detailed tutorials and other guides, we suggest that you vists our [Official Documentation](https://cytofdr.readthedocs.io/en/latest/index.html).

  There you will find ways to install our package and get started! Also, we offer tutorials on customizations, working with DR methods, and finally our detailed evaluation framework. We hope that you can find what you need over there!



  This is a minor maintenance update of v0.3.x with updated references and documentation.



  - Updated referneces and citation information in all relavent documentaion pages
  - Removed a warning on SAUCIE's installation documentation



  - Update-to-date documentation and references



  - (Since v0.2.0) The `comparison_classes` parameter of the `EvaluationMetrics.embedding_concordance` method will no longer accept `str` input.



  If you run into issues or have questions, feel free to open an issue [here](https://github.com/kevin931/CytofDR/issues). I'd love to help you out! We also welcome any contributions, but you may want to also look our [contribution guide](https://cytofdr.readthedocs.io/en/latest/change/contribution.html). Even if you just have an idea, that'll be great!



  Our preprint "Comparative Analysis of Dimension Reductions Methods for Cytometry by Time-of-Flight Data" is on bioRxiv and can be accessed [right here](https://doi.org/10.1038/s41467-023-37478-w). If you use our package in your research or deployment, a citation of our paper is highly appreciated:

  ```
  @article{wang2023comparative,
    title={Comparative analysis of dimension reduction methods for cytometry by time-of-flight data},
    author={Wang, Kaiwen and Yang, Yuqiu and Wu, Fangjiang and Song, Bing and Wang, Xinlei and Wang, Tao},
    journal={Nature Communications},
    volume={14},
    number={1},
    pages={1--18},
    year={2023},
    publisher={Nature Publishing Group}
  }
  ```

  For a list of references of the methods, metrics, etc. used in the package, please visit our [References](https://cytofdr.readthedocs.io/en/latest/references.html) and bibliography of our paper.


pkgId: 482503966350cd7d1e010e6b18eb8260a9207ed2ff7b4328afbfccadfa94587b
name: python-D47crunch
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Standardization and analytical error propagation of Δ47 and Δ48 clumped-isotope measurements
url: https://pypi.org/project/D47crunch/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-D47crunch-2.4.1-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4314550.svg)](https://doi.org/10.5281/zenodo.4314550)
  [![PyPI Version](https://img.shields.io/pypi/v/D47crunch.svg)](https://pypi.python.org/pypi/D47crunch)

  Python library for processing and standardizing carbonate clumped-isotope analyses, from low-level data out of a dual-inlet mass spectrometer to final, “absolute” Δ<sub>47</sub>, Δ<sub>48</sub> and  Δ<sub>49</sub> values with fully propagated analytical error estimates.

  This also provides a command-line interface making it possible to process a multi-session Δ<sub>47</sub> (and potentially Δ<sub>48</sub>, Δ<sub>49</sub>) dataset by simply calling `D47crunch rawdata.csv`. See the [CLI documentation](https://mdaeron.github.io/D47crunch/#3-command-line-interface-cli) for more options.



  For the full API and a short tutorial, see [https://mdaeron.github.io/D47crunch].

  [https://mdaeron.github.io/D47crunch]: https://mdaeron.github.io/D47crunch



  This should do the trick:

  ```bash
  pip install D47crunch
  ```

  Alternatively:

  1. download the [dev branch] or the [latest release] and unzip it
  2. rename the resulting directory to `D47crunch`
  3. chose one of one of the following options:
  	+ move the `D47crunch` directory to somewhere in your Python path
  	+ move the `D47crunch` directory to your desired working directory
  	+ move the `D47crunch` directory to any other location (e.g., `/foo/bar`) and include the following code snippet in your scripts:

  ```py
  import sys
  sys.path.append('/foo/bar')
  ```
  Having done any of the above you should now be able to `import D47crunch`, with the following requirements: [Python 3], [numpy], [matplotlib], [scipy], [lmfit], and [typer].

  [Python 3]: https://www.python.org
  [numpy]: https://numpy.org
  [lmfit]: https://lmfit.github.io
  [matplotlib]: https://matplotlib.org
  [scipy]: https://www.scipy.org
  [typer]: https://typer.tiangolo.com
  [dev branch]: https://github.com/mdaeron/D47crunch/archive/dev.zip
  [latest release]: https://github.com/mdaeron/D47crunch/releases/latest



  All questions and suggestions are welcome and should be directed at [Mathieu Daëron](mailto:daeron@lsce.ipsl.fr?subject=[D47crunch]).


pkgId: bd86427c2268afeba5930431013e81275c3e48fe9dfb5ece9518101a8e0dea07
name: python-D4CMPP
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Molecular property prediction based on Graph Convolution Network published by Deep4Chem
url: https://github.com/phillip1998/D4C_MPP
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-D4CMPP-1.0.3-1.src.rpm
checksum_type: sha256
description:
  ```sh
  $ pip install D4CMPP
  ```
  It is recommended to install dgl and torch first with the appropriate versions for your system.


pkgId: a4ac0b1da05eb7607b3fb1e064df32dd4b57436abc3b5560bb7d8290eb1e95a5
name: python-DA4RDM-RecSys-ContentBased
arch: src
version: 1.0.10
epoch: 0
release: 1
url: https://pypi.org/project/DA4RDM-RecSys-ContentBased/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DA4RDM-RecSys-ContentBased-1.0.10-1.src.rpm
checksum_type: sha256
summary:
  A package that recommends similar data collections based on unstructured and explicitly provided meta information of files.

description:
  The **DA4RDM_RecSyS_ContentBased** is a python based package that recommends similar data collections based on unstructured and explicitly provided meta information of files.



  The package is built using Python as a programming language and utilizes python packages such as tensorflow, keras, nlpaug and few others. The complete list of dependencies could be referred to in the requirements.txt file. The package can be installed using the pip command provided below:

  **pip install DA4RDM-RecSys-ContentBased**


  The package has two important modules **preprocessor** and **distance_similarity_calculator**.
  The preprocessor module has methods that perform the task of data cleaning, outlier detection, PCA analysis and text preprocessing and outputs a processed dataframe that could be used for similarity evaluation.
  The distance_similarity_calculator has methods that compute the distance using KMeans with choice of distance measures and finally outputs recommendation based on the distance values.
  Once imported the component methods can be invoked and used.
  The modules can be imported using the below commands:

  ```python
  from DA4RDM_RecSys_ContentBased import preprocessor
  from DA4RDM_RecSys_ContentBased import distance_similarity_calculator
  ```



  1. **loadAndPreprocess_function**<br />
  To perform the task of preprocessing the method **loadAndPreprocess_function** within the module **preprocessor** can be used.
  This method invokes other necessary methods and finally outputs a processed dataframe. The function body is as shown below:

  ```python
  def loadAndPreprocess_function(filepath: str, features=[], seperator='|', n_componentsAfterPCA=1, encoder='mobilebert_multi_cased', minmaxScaleFlage=True, removeColumnsWithOneValueFlag=False, debug=False):
      """Loads and preprocesses a csv-file

      :param filepath: filepath to the csv file with '|' as the seperator
      :param features: array of features to consider
      :param seperator: the seperator used when loading the csv-file
      :param n_componentsAfterPCA: sets the number of component for PCA
      :param encoder: set the language model: 'mobilebert_multi_cased' or 'bert_multi_cased'
      :param minmaxScaleFlage: minmax scaling resource vector
      :param removeColumnsWithOneValueFlag: remove columns with only one value between all resources and files
      :param debug: debug mode
      :return: a preprocessed pandas.Dataframe
      """
  ```
  2. **result_function**<br />
  To get the final recommendation the method **result_function** within the module **distance_similarity_calculator** can be used.This function accepts the preprocessed dataframe along with other important parameters (Please refer to function body below for all parameters) and outputs recommendation based on the distance values:

  ```python
  def result_function(df, key:str, distanceMethod='euclidean', sortAscending=True, nearestNeighbourFlag=True, outputFormatJson=False, DEBUG_MODE=False):
      """Calculating a distance between the key-resource and the resources in the dataframe

      :param df: preprocessed dataframe
      :param key: compare resources to this key
      :param distanceMethod: 'euclidean' or 'cosine' distance
      :param sortAscending: True = sort output ascending; False = descending
      :param nearestNeighbourFlag: sets the flag for the nearest neighbour
      :param DEBUG_MODE: debug mode
      :param outputFormatJson: Trigger Json format
      :return: relative distance between key and furthest resource
      """

  ```


  Below is an example execution of the **loadAndPreprocess_function** with features selection and debug mode set to False. The output dataframe df is the preprocessed dataframe.

  ```python
  df = preprocessor.loadAndPreprocess_function(filepath="tomography.csv", features=['http://purl.org/coscine/terms/sfb1394#acquiredIons', 'http://purl.org/coscine/terms/sfb1394#annularMillingParameters', 'http://purl.org/coscine/terms/sfb1394#baseTemperature', 'http://purl.org/coscine/terms/sfb1394#laserPulseEnergy', 'http://purl.org/coscine/terms/sfb1394#lowVoltageCleaning', 'http://purl.org/coscine/terms/sfb1394#pulseFrequency','http://purl.org/coscine/terms/sfb1394#runTime','http://purl.org/coscine/terms/sfb1394#specimenApexRadius'],debug=False)
  ```

  Below is an example execution of the **result_function** with output format set to json:

  ```python
  jsonOutPut = distance_similarity_calculator.result_function(df, '1EC47F72-DF63-4D95-94E7-EB70C6BA09DB', distanceMethod='euclidean', outputFormatJson=True, DEBUG_MODE=False)
  ```


  All the above executions computes the relative distance between the neighbours and the reference resourceid and outputs an ordered recommendation based on the distance. Finally, based on the parameter outputFormatJson, the results are generated as a json file.

  If json is the selected format the function outputs a json for the distance values as shown below:

  ```python
  {"distance":{"1EC47F72-DF63-4D95-94E7-EB70C6BA09DB":0.0,"302231B4-C161-4392-8895-8111FB7ED1F2":0.1323549579,"322EA9BA-AF4E-4C3A-BE02-0FC76C6673FE":0.3456503446,"6FC1403F-5957-4C45-8048-87D19C7C5832":0.3462583399,"4EFD8371-FD03-477F-BF39-861381FF080C":0.3463898247,"9C30C57E-7308-4DE9-BC38-49796C58929E":0.3472023012,"F8BE75F7-356E-4EB1-83AF-E6C174971D78":0.3489339426,"FAF13DF1-1747-4237-90F3-9451F4F8FEF7":0.3643016356,"24CE68AD-38BA-46DC-ACDB-9D1B93063490":0.4380531763,"632AD746-6A29-471F-861E-00663EA4B5CF":0.4494196308,"1FAA54D3-122B-41FD-ACE3-2B698FC1326F":0.9921902678,"9AA7E05B-A018-4B53-8A63-993C912DA553":0.995833426,"E6822DB5-116C-4875-8D2E-E84B4A2A9794":0.996137678,"65B41144-C3B9-4E96-9FA2-49B2071AF086":0.9977728607,"F9477D28-6D4E-4799-8D34-14383899E157":1.0}}
  ```


pkgId: 7ec091d49f668c4716c43f076d56ea28344d98e47224e71459f2a9c01e23ed5b
name: python-DA4RDM-RecSys-UserBased
arch: src
version: 1.0.11
epoch: 0
release: 1
url: https://pypi.org/project/DA4RDM-RecSys-UserBased/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DA4RDM-RecSys-UserBased-1.0.11-1.src.rpm
checksum_type: sha256
summary:
  A package that recommends similar data collections based on the analysis of user-resource interaction patterns.

description:
  The **DA4RDM_RecSys_UserBased** is a python based package that recommends data collections based on matching users' behavior analysis and an explorative analysis of user-resource interactions.



  The package is built using Python as a programming language and utilizes python packages such as sklearn, json etc. The complete list of dependencies could be referred to in the **requirements.txt** file. Please make sure the necessary packages are installed before execution. The package can be installed using the pip command provided below.

  **pip install DA4RDM-RecSys-UserBased**



  The package has one important module **get_recommendation**. This modules invokes the necessary functions from other modules that perform the tasks of data extraction, outlier detection, decay analysis and knn implementation to output recommendation. The module can be imported using the below command:

  ```python
  from DA4RDM_RecSys_UserBased import get_recommendation
  ```


  The package can be used to generate resource recommendations based on the input reference user id. To do so the function **get_recommendations** within the module **get_recommendation** can be called and the respective user id should be passed along with other function parameters. In addition to that two optional arguments can also be passed namely the number of recommended resources that is expected as function output and the outlier method to use. The number of neighbours being used in the KNN Nearest neighbour algorithm by the recommender system is set to the value 3 based on preliminary analysis. The function body along with default parameter values is as shown below:

  ```python
  def get_recommendations(datapath, dataset_resources, ref_user, num_recommendation=3, outlier_detection_method="percentile"):
       """Outputs knn distance based recommendation

      :param datapath: filepath to the csv file, a string is expected
      :param dataset_resources: filepath to the resource file
      :param ref_user: the user for which resources are to be recommended
      :param num_recommendation: number of recommendations desired (further filtered on zero ratings)
      :param outlier_detection_method: choices available - percentile(default), zscore , iqr
      :return: a json file with resource recommendation
      """

  ```


  1. Below is an execution of the function with all parameters provided

  ```python
  from DA4RDM_RecSys_UserBased import get_recommendation
  get_recommendation.get_recommendations("14-08-2022.csv", "tomography.csv", "e2b383da-36d8-4825-8c6a-642af20f0412", 3, "percentile")
  ```

  2. Below is an execution of the function with only required parameters provided

  ```python
  from DA4RDM_RecSys_UserBased import get_recommendation
  get_recommendation.get_recommendations("14-08-2022.csv", "tomography.csv", "0f0b39a0-2b60-446e-8eb4-89cc164c7bc3")
  ```


  All the above computation outputs a json file that contains the dictionary of the recommended resources as shown below:

  ```python
  {"Recommendations": {"Ref_User_ID": "0f0b39a0-2b60-446e-8eb4-89cc164c7bc3", "Recommendation": [["fd7b5eff-de1b-4149-8eb2-c09349dc180a", 0.25779062933941843], ["ebbc5007-7cb6-44cf-8631-d23eaa675e6f", 0.02271623947631261], ["c9ad0d65-545a-4081-9eb7-bcca97b9fa9d", 0.02268728733672115]]}}
  ```


pkgId: bf6c0ea352d3c2c8d76bea491512e2668abae8e795317d694df71991b9cb5e0c
name: python-DAJIN2
arch: src
version: 0.5.5.1
epoch: 0
release: 1
summary: One-step genotyping tools for targeted long-read sequencing
url: https://github.com/akikuno/DAJIN2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DAJIN2-0.5.5.1-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-MIT-9cf.svg)](https://choosealicense.com/licenses/mit/)
  [![Test](https://img.shields.io/github/actions/workflow/status/akikuno/dajin2/pytest.yml?branch=main&label=Test&color=brightgreen)](https://github.com/akikuno/dajin2/actions)
  [![Python](https://img.shields.io/pypi/pyversions/DAJIN2.svg?label=Python&color=blue)](https://pypi.org/project/DAJIN2/)
  [![PyPI](https://img.shields.io/pypi/v/DAJIN2.svg?label=PyPI&color=orange)](https://pypi.org/project/DAJIN2/)
  [![Bioconda](https://img.shields.io/conda/v/bioconda/dajin2?label=Bioconda&color=orange)](https://anaconda.org/bioconda/dajin2)
  [![DOI](https://zenodo.org/badge/387721337.svg)](https://zenodo.org/badge/latestdoi/387721337)


  <p align="center">
  <img src="https://user-images.githubusercontent.com/15861316/261833016-7f356960-88cf-4574-87e2-36162b174340.png" width="90%">
  </p>

  [日本語はこちら](https://github.com/akikuno/DAJIN2/blob/main/docs/README_JP.md)

  DAJIN2 is a genotyping tool for genome-edited samples, utilizing nanopore sequencer target sequencing.

  The name DAJIN is derived from the phrase 一網**打尽** (Ichimou **DAJIN** or Yīwǎng **Dǎjìn**), symbolizing the concept of capturing everything in one sweep.



  + **Comprehensive Mutation Detection**: Equipped with the capability to detect genome editing events over a wide range, it can identify a broad spectrum of mutations, from small changes to large structural variations.
    + DAJIN2 is also possible to detect complex mutations characteristic of genome editing, such as "insertions occurring in regions where deletions have occurred."
  + **Intuitive Visualization**: The outcomes of genome editing are visualized intuitively, allowing for the rapid and easy identification and analysis of mutations.
  + **Multi-Sample Compatibility**: Enabling parallel processing of multiple samples. This facilitates efficient progression of large-scale experiments and comparative studies.






  - Python >= 3.8
  - Unix-like environment (Linux, macOS, WSL2, etc.)



  ```bash
  conda create -n env-dajin2 -c conda-forge -c bioconda python=3.10 DAJIN2 -y
  conda activate env-dajin2
  ```



  ```bash
  pip install DAJIN2
  ```

  > [!CAUTION]
  > If you encounter any issues during the installation, please refer to the [Troubleshooting Guide](https://github.com/akikuno/DAJIN2/blob/main/docs/TROUBLESHOOTING.md)








  In DAJIN2, a **control that has not undergone genome editing** is necessary to detect genome-editing-specific mutations. Specify a directory containing the FASTQ/FASTA (both gzip compressed and uncompressed) or BAM files of the genome editing sample and control.


  After basecalling with Guppy, the following file structure will be output:

  ```text
  fastq_pass
  ├── barcode01
  │   ├── fastq_runid_b347657c88dced2d15bf90ee6a1112a3ae91c1af_0_0.fastq.gz
  │   ├── fastq_runid_b347657c88dced2d15bf90ee6a1112a3ae91c1af_10_0.fastq.gz
  │   └── fastq_runid_b347657c88dced2d15bf90ee6a1112a3ae91c1af_11_0.fastq.gz
  └── barcode02
      ├── fastq_runid_b347657c88dced2d15bf90ee6a1112a3ae91c1af_0_0.fastq.gz
      ├── fastq_runid_b347657c88dced2d15bf90ee6a1112a3ae91c1af_10_0.fastq.gz
      └── fastq_runid_b347657c88dced2d15bf90ee6a1112a3ae91c1af_11_0.fastq.gz
  ```

  Assuming barcode01 is the control and barcode02 is the sample, the respective directories are specified as follows:

  + Control: `fastq_pass/barcode01`
  + Sample: `fastq_pass/barcode02`




  For basecalling with Dorado ([`dorado demux`](https://github.com/nanoporetech/dorado?tab=readme-ov-file#barcode-classification)), the following file structure will be output:

  ```text
  dorado_demultiplex
  ├── EXP-PBC096_barcode01.bam
  └── EXP-PBC096_barcode02.bam
  ```

  > [!IMPORTANT]
  > Store each BAM file in a separate directory. The directory names can be set arbitrarily.

  ```text
  dorado_demultiplex
  ├── barcode01
  │   └── EXP-PBC096_barcode01.bam
  └── barcode02
      └── EXP-PBC096_barcode02.bam
  ```

  Similarly, store the FASTA files outputted after sequence error correction with [`dorado correct`](https://github.com/nanoporetech/dorado) in separate directories.

  ```text
  dorado_correct
  ├── barcode01
  │   └── EXP-PBC096_barcode01.fasta
  └── barcode02
      └── EXP-PBC096_barcode02.fasta
  ```

  Assuming barcode01 is the control and barcode02 is the sample, the respective directories are specified as follows:

  + Control: `dorado_demultiplex/barcode01` / `dorado_correct/barcode01`
  + Sample: `dorado_demultiplex/barcode02` / `dorado_correct/barcode02`



  The FASTA file should contain descriptions of the alleles anticipated as a result of genome editing.

  > [!IMPORTANT]
  > **A header name >control and its sequence are mandatory.**

  If there are anticipated alleles (e.g., knock-ins or knock-outs), include their sequences in the FASTA file too. These anticipated alleles can be named arbitrarily.

  Below is an example of a FASTA file:

  ```text
  >control
  ACGTACGTACGTACGT
  >knock-in
  ACGTACGTCCCCACGTACGT
  >knock-out
  ACGTACGT
  ```

  Here, `>control` represents the sequence of the control allele, while `>knock-in` and `>knock-out` represent the sequences of the anticipated knock-in and knock-out alleles, respectively.




  DAJIN2 allows for the analysis of single samples (one sample vs one control).

  ```bash
  DAJIN2 <-s|--sample> <-c|--control> <-a|--allele> <-n|--name> \
    [-g|--genome] [-t|--threads] [-h|--help] [-v|--version]

  Options:
  -s, --sample              Specify the path to the directory containing sample FASTQ/FASTA/BAM files.
  -c, --control             Specify the path to the directory containing control FASTQ/FASTA/BAM files.
  -a, --allele              Specify the path to the FASTA file.
  -n, --name (Optional)     Set the output directory name. Default: 'Results'.
  -g, --genome (Optional)   Specify the reference UCSC genome ID (e.g., hg38, mm39). Default: '' (empty string).
  -t, --threads (Optional)  Set the number of threads. Default: 1.
  -h, --help                Display this help message and exit.
  -v, --version             Display the version number and exit.
  ```



  ```bash

  curl -LJO https://github.com/akikuno/DAJIN2/raw/main/examples/example_single.tar.gz
  tar -xf example_single.tar.gz


  DAJIN2 \
      --control example_single/control \
      --sample example_single/sample \
      --allele example_single/stx2_deletion.fa \
      --name stx2_deletion \
      --genome mm39 \
      --threads 4
  ```

  <!-- ```bash

  wget https://github.com/akikuno/DAJIN2/raw/main/examples/example-single.tar.gz
  tar -xf example-single.tar.gz


  DAJIN2 \
      --name stx2-deletion \
      --sample example-single/sample.fq.gz \
      --control example-single/control.fq.gz \
      --allele example-single/design.fa \
      --genome mm39 \
      --threads 10













  ```
   -->



  By using the `batch` subcommand, you can process multiple files simultaneously.
  For this purpose, a CSV or Excel file consolidating the sample information is required.

  > [!NOTE]
  > For guidance on how to compile sample information, please refer to [this document](https://docs.google.com/presentation/d/e/2PACX-1vSMEmXJPG2TNjfT66XZJRzqJd82aAqO5gJrdEzyhn15YBBr_Li-j5puOgVChYf3jA/embed?start=false&loop=false&delayms=3000).


  ```bash
  DAJIN2 batch <-f|--file> [-t|--threads] [-h]

  options:
    -f, --file                Specify the path to the CSV or Excel file.
    -t, --threads (Optional)  Set the number of threads. Default: 1.
    -h, --help                Display this help message and exit.
  ```



  ```bash

  curl -LJO https://github.com/akikuno/DAJIN2/raw/main/examples/example_batch.tar.gz
  tar -xf example_batch.tar.gz


  DAJIN2 batch --file example_batch/batch.csv --threads 4
  ```




  Upon completion of DAJIN2 processing, a directory named **DAJIN_Results** is generated.
  Inside the **DAJIN_Results** directory, the following files can be found:

  ```
  DAJIN_Results/tyr-substitution
  ├── BAM
  │   ├── tyr_c230gt_01
  │   ├── tyr_c230gt_10
  │   ├── tyr_c230gt_50
  │   └── tyr_control
  ├── FASTA
  │   ├── tyr_c230gt_01
  │   ├── tyr_c230gt_10
  │   └── tyr_c230gt_50
  ├── HTML
  │   ├── tyr_c230gt_01
  │   ├── tyr_c230gt_10
  │   └── tyr_c230gt_50
  ├── MUTATION_INFO
  │   ├── tyr_c230gt_01.csv
  │   ├── tyr_c230gt_10.csv
  │   └── tyr_c230gt_50.csv
  ├── read_plot.html
  ├── read_plot.pdf
  └── read_summary.xlsx
  ```



  The BAM directory contains the BAM files of reads classified per allele.

  > [!NOTE]
  > Specifying a reference genome using the `genome` option will align the reads to that genome.
  > Without `genome` options, the reads will align to the control allele within the input FASTA file.



  The FASTA directory stores the FASTA files of each allele.
  The HTML directory contains HTML files for each allele, where mutation sites are color-highlighted.
  For example, Tyr point mutation is highlighted in **green**.

  <img src="https://user-images.githubusercontent.com/15861316/274518501-2ca3f442-1b86-4635-be3d-fd37575c4ca2.png" width="75%" />



  The MUTATION_INFO directory saves tables depicting mutation sites for each allele.
  An example of a *Tyr* point mutation is described by its position on the chromosome and the type of mutation.

  <img src="https://user-images.githubusercontent.com/15861316/274519342-a613490d-5dbb-4a27-a2cf-bca0686b30f0.png" width="75%">



  read_summary.xlsx describes the number of reads and presence proportion for each allele.
  Both read_plot.html and read_plot.pdf illustrate the proportions of each allele.
  The chart's **Allele type** indicates the type of allele, and **Percent of reads** shows the proportion of reads for each allele.

  The **Allele type** includes:
  - **Intact**: Alleles that perfectly match the input FASTA allele.
  - **Indels**: Substitutions, deletions, insertions, or inversions within 50 bases.
  - **SV**: Substitutions, deletions, insertions, or inversions beyond 50 bases.

  <img src="https://user-images.githubusercontent.com/15861316/274521067-4d217251-4c62-4dc9-9c05-7f5377dd3025.png" width="75%">

  > [!WARNING]
  > In PCR amplicon sequencing, the % of reads might not match the actual allele proportions due to amplification bias.
  > Especially when large deletions are present, the deletion alleles might be significantly amplified, potentially not reflecting the actual allele proportions.



  > [!NOTE]
  > For frequently asked questions, please refer to [this page](https://github.com/akikuno/DAJIN2/blob/main/docs/FAQ.md).


  For more questions, bug reports, or other forms of feedback, we'd love to hear from you!
  Please use [GitHub Issues](https://github.com/akikuno/DAJIN2/issues/new/choose) for all reporting purposes.

  Please refer to [CONTRIBUTING](https://github.com/akikuno/DAJIN2/blob/main/docs/CONTRIBUTING.md) for how to contribute and how to verify your contributions.





  Please note that this project is released with a [Contributor Code of Conduct](https://github.com/akikuno/DAJIN2/blob/main/docs/CODE_OF_CONDUCT.md).
  By participating in this project you agree to abide by its terms.




  For more information, please refer to the following publication:

  [Kuno A, et al. (2022) DAJIN enables multiplex genotyping to simultaneously validate intended and unintended target genome editing outcomes. *PLoS Biology* 20(1): e3001507.](https://doi.org/10.1371/journal.pbio.3001507)


pkgId: 139c5ed442a0fab73b0e19bac5595a8c422984e02b0af26d34bf1a6598e85fd9
name: python-DANE
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Utils for working with the Distributed Annotation and Enrichment system
url: https://github.com/CLARIAH/DANE
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DANE-0.4.3-1.src.rpm
checksum_type: sha256
description:
  The Distributed Annotation 'n' Enrichment (DANE) system handles compute task assignment and file storage for the automatic annotation of content.

  This repository contains contains the building blocks for with DANE, such as creating custom analysis workers or submitting new task.



  This package can be installed through pip:

      pip install dane



  DANE components are configured through the dane.config module, which is described here: https://dane.readthedocs.io/en/latest/intro.html#configuration
  It is however noteable that, because all DANE components are expected to rely on it, some of the DANE-server, ElasticSearch and RabbitMQ configuration
  are included in the default config. As such it is recommended that you create a `$HOME/.dane/config.yml` or `$DANE_HOME/config.yml` which contain machine-wide settings for how to connect to these services, which involves specifying the following settings:

  ```
  DANE:
      API_URL: 'http://localhost:5500/DANE/'
      MANAGE_URL: 'http://localhost:5500/manage/'
  RABBITMQ:
      HOST: 'localhost'
      PORT: 5672
      EXCHANGE: 'DANE-exchange'
      RESPONSE_QUEUE: 'DANE-response-queue'
      USER: 'guest'
      PASSWORD: 'guest'
  ELASTICSEARCH:
      HOST: ['localhost']
      PORT: 9200
      USER: 'elastic'
      PASSWORD: 'changeme'
      SCHEME: 'http'
      INDEX: 'your_dane_index'
  ```

  The values given here are the default values.



  Examples of how to use DANE can be found in the `examples/` directory.



  We moved from `setup.py` & `requirements.txt` to a single `pyproject.toml`. For local builds and publishing we use [poetry](https://python-poetry.org/).

  For local installation:

  ```bash
  poetry install
  poetry shell
  ```

  After installation the following unit test should succeed:

  ```bash
  python -m test.test_dane
  ```

  To build a wheel + source package (will end up in `dist` directory):

  ```bash
  poetry build
  ```

  The wheel can be conveniently tested in e.g. your own DANE worker by installing it e.g. using `pip`:

  ```bash
  pip install path_to_dane_wheel_file
  ```

  or with poetry

  ```bash
  poetry add path_to_dane_wheel_file
  ```



  Since version 0.3.1 DANE must be imported in lowercase letters:

  ```python
  import dane
  ```

  Before version 0.3.1 you should import using uppercase letters:

  ```python
  import DANE
  ```


pkgId: 4cad6fe76cf268a6d903ea0c1107103f2385e0b907923ac3599be50059b0bc3e
name: python-DAStk
arch: src
version: 1.0.1.post1
epoch: 0
release: 1
summary: Differential ATAC-seq toolkit
url: https://github.com/Dowell-Lab/DAStk
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DAStk-1.0.1.post1-1.src.rpm
checksum_type: sha256
description:
  The Differential
  `ATAC-seq <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4374986/>`__
  Toolkit (DAStk) is a set of command-line tools to aid analyzing
  differential ATAC-seq data. By leveraging changes in accessible
  chromatin, we can detect significant changes in transcription factor
  (TF) activity. This is a simple but powerful tool for cellular
  perturbation analysis. In fact, the applications of DAStk are not
  necessarily limited to ATAC-seq, but can extend to comparing any pair of
  bedGraphs containing regions of interest, e.g. transcription regulatory
  elements (TRE) from nascent transcription assays like PRO-seq, or others
  like ChIP-seq peaks.
  You will need the following inputs:
  -  A pair of files listing peaks of ATAC-seq signal in two biological
     conditions (e.g. DMSO and drug-treated) in any BedGraph-compatible
     format (tab-delimited)
  -  A set of files listing the putative binding sites across the
     reference genome of choice, one file per transcription factor motif,
     also in any BedGraph-like format. These are normally generated from
     position weight matrices (PWMs) available at TF model databases like
     `HOCOMOCO <http://hocomoco11.autosome.ru>`__. These files are
     expected to have a ``.bed``, ``.BedGraph`` or ``.txt`` extension.
  **IMPORTANT: All files mentioned above (ATAC-seq peaks and computed
  motif sites) MUST be sorted by the same criteria. Different
  bioinformatics tools use different lexical sorting criteria (e.g. chr10
  after chr1, or chr2 after chr1) so please ensure the sorting criteria is
  uniform.**
  Install
  ~~~~~~~
  You can install DAStk using ``pip``:
     $ pip install DAStk
  … or:
     $ pip install --upgrade DAStk
  This is the simplest option, and it will also create the executable
  commands ``process_atac`` and ``differential_md_score``. Alternatively,
  you can clone this repository by running:
     $ git clone https://github.com/Dowell-Lab/DAStk.git
  Required Python libraries (automatically taken care of if installed thru ``pip``):
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  -  numpy
  -  argparse
  -  matplotlib
  -  scipy
  -  adjustText
  -  pandas
  -  multiprocessing
  -  pybedtools
  -  futures
  -  scikit-learn
  -  itertools
  -  networkx
  -  upsetplot
  These scripts feature comprehensive help when called with the ``--help``
  argument. Every argument provides a short and long form (i.e. ``-t`` or
  ``--threads``). There are normally two steps in a typical workflow:
  1. Process the ATAC-seq peak files (process_atac) to calculate the
     `MD-score
     statistic <https://genome.cshlp.org/content/28/3/334.short>`__ for
     each motif provided.
  2. Detect the most statistically significant changes in MD-score
     (differential_md_score) between both biological conditions (taking
     into the account the peaks involved), and generate MA and barcode
     plots.
  TL;DR;
  ~~~~~~
  Process each ATAC-seq peak bedGraph file, the genome abbreviations are
  “hg38”, “mm10”, etc:
     $ process_atac -e PEAKS_FILENAME_1 -m MOTIF_SITES_DIRECTORY -g GENOME_ABBREVIATION -o OUTPUT_DIRECTORY
     $ process_atac -e PEAKS_FILENAME_2 -m MOTIF_SITES_DIRECTORY -g GENOME_ABBREVIATION -o OUTPUT_DIRECTORY
  Perform differential analysis on the calculated motif displacement
  scores, highlighting the significant motifs at your p-value threshold of
  choice:
     $ differential_md_score -1 MD_OUTPUT_FOR_FILENAME_1 -2 MD_OUTPUT_FOR_FILENAME_2 -p 0.0000001 -m "DMSO" -n "Drug treatment" -b -o OUTPUT_DIRECTORY
  Perform downstream analysis to discover what is common among those
  significant TFs:
     $ tf_result_explanations -p 0.0000001 -d DIFFERENTIAL_MD_SCORE_OUTPUT_FILENAME -o EXPLANATION_FILENAME
  Questions?
     $ process_atac --help
     $ differential_md_score --help
  Data Processing and Plotting
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  There are three plotting functions to assess the results from
  ``process_atac`` and ``differential_md_score``:
  -  ma_plot
  -  barcode_plot
  -  tf_intersect
  The first two allow you to generate custom MA and Barcode plots using
  the stats file produced using the differential_md_score module. While
  the MA and Barcode plots will be generated by default when running the
  differential_md_score module, it may be useful to adjust the labels,
  adjust the p-value threshold, compare motifs with non-significant
  p-values etc. The default plots will generate labels based on your file
  basenames (everything before the \_md_score.txt extension if you kept
  the default file names from ``process_atac``). However, to keep plots
  scaled appropriately, this label is limited to 19 characters. If it is
  longer, it will be truncated.
  The third plotting module, ``tf_intersect`` can be used to generate a
  venn diagram (3 or fewer conditions) or an upset plot using multiple
  result files as inputs to compare common motifs between conditions. For
  example, using the -e/–enriched argument and by providing multiple
  \*_md_score.txt files files from ``process_atac``, all motifs with an MD
  score >0.2 will be intersected. Additionally, if more than three input
  stats files are specified, three catplots will be generated alongside
  the upset plot by taking the mean value of all of the stats files for
  total genome-wide motif hits, motif hits within 3kb of the region file,
  and the MD score.
  **IMPORTANT** Either raw MD score outputs from ``process_atac`` or
  differential MD scores from ``differential_md_score`` may be used,
  however it is not recommended to mix file input types. There are also
  some plotting functions unique to each (e.g. intersecting significant
  motifs is only relevant to the ``differential_md_score`` outputs.
  Furthermore, -e/–enriched and -d/–depleted have different relative
  values between the two output types. Using the ``process_atac`` results,
  the raw MD score will be used and defaults are relative to a background
  singal of 0.1. Using the ``differential_md_score`` stats output, the
  enriched/depleted is based on the *differential* MD score (i.e. the
  difference in MD scores between the two conditions) and therefore the
  thresholds are specified by a different argument.
  A stats file of the intersection data will also be generated in the
  format needed to generate the upset plot (see
  https://pypi.org/project/pyupset/0.1.1.post4/). There is a limit of 12
  input files for plotting. However, if more than 12 files are specified,
  a stats file output will still be generated specifying motif
  intersections.
  The following will provide a full list of arguments and usage
  instructions instructions for each of these plotting tools:
     $ ma_plot --help
     $ barcode_plot --help
     $ tf_intersect --help
  While these plots will be generated by default when running the
  differential_md_score module, it may be useful to adjust the labels,
  adjust the p-value threshold, compare motifs with non-significant
  p-values etc. The default plots will generate labels based on your file
  basenames (everything before the \_md_score.txt extension if you kept
  the default file names from process_atac). However, to keep plots scaled
  appropriately, this label is limited to 19 characters. If it is longer,
  it will be truncated.
  Inquiring about TF-TF relations
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  In release v1.0.0 a new functionality has been included, if using assays
  on human tissue and the TF motifs from HOCOMOCO:
     $ tf_result_explanations --help
  This build now includes a graph that combines all human proteins in
  `Uniprot <https://www.uniprot.org/>`__, with their respective
  annotations, and all human `Reactome <https://reactome.org/>`__ data on
  biological pathways, biochemical reactions, and complex formation. This
  allows the user to query for existing knowledge about what aspects of
  the significantly changing TFs are shared among two or more of them.
  They may participate in the same pathway or biological process, be
  members of the same complex, have shared cofactors, directly interact
  with each other, etc.
  You can optionally provide a list of “uninteresting” intersections by
  listing the ontology concept URIs in a file (see `our
  example <./DAStk/uninteresting_relations.txt>`__ list, for things in
  common between TFs that are too obvious), so that they are omitted from
  the output. You can also specify additional entities to include in the
  search, besides the TFs showing a change of activity beyond the provided
  cutoff, also in a different file listing ontology URIs. The `list of
  labels for each concept
  used <./DAStk/public_knowledge/all_labels.tsv>`__ shows the possible
  URIs that could be included as an additional search endpoint. For
  example, if we end up with 5 different TFs that are significantly
  changing between conditions and we also want to search how they all
  relate to zinc, we can provide a file with the URI
  `<http://purl.obolibrary.org/obo/CHEBI_29105> <http://purl.obolibrary.org/obo/CHEBI_29105>`__.
  This tool produces a report that looks like the excerpt below:
     Transcription factors displaying a significant difference in activity:
     CEBPB, CEBPD, CEBPE, ELK1, HLF, NFIA, NFIB, NFIX, NFYB, NRF1, TP53, ZNF180, ZNF341, ZNF396, ZNF432, ZNF441, ZNF519, ZNF529, ZNF540, ZNF93
     Here's what we know about these TFs presenting significant activity changes (p=1.00E-03):
     Direct interactions between each of these TFs:
     NFYB interacts with TP53
     TP53 interacts with CEBPB
     Other ways these TFs are related:
     CEBPB, CEBPE, ELK1, HLF, NFIA, NFIB, NFIX, NFYB, NRF1, TP53, ZNF180, ZNF341, ZNF396, ZNF441, ZNF519, ZNF529, ZNF540, and ZNF93: located in nucleus
     ZNF180, ZNF341, ZNF396, ZNF432, ZNF441, ZNF519, ZNF529, ZNF540, and ZNF93: has component Zinc finger, C2H2 type
     ZNF180, ZNF341, ZNF396, ZNF432, ZNF441, ZNF519, ZNF529, and ZNF540: has function metal ion binding
     ZNF180, ZNF432, ZNF441, ZNF519, ZNF529, ZNF540, and ZNF93: has component KRAB box
     CEBPB, CEBPD, CEBPE, NFYB, TP53, and ZNF396: has function protein heterodimerization activity
     ZNF180, ZNF432, ZNF441, ZNF519, ZNF529, and ZNF540: molecularly interacts with KRAB-ZNF / KAP Complex [nucleoplasm]
     CEBPB, CEBPD, CEBPE, and HLF: has component Basic region leucine zipper
     [...]
     CEBPB and CEBPD: interacts with ATF4
     CEBPB and CEBPD: interacts with CEBPA
     CEBPB and CEBPD: participates in positive regulation of osteoblast differentiation
     CEBPB and CEBPE: participates in cellular response to lipopolysaccharide
     CEBPB and CEBPE: participates in defense response to bacterium
  Usage examples
  ~~~~~~~~~~~~~~
  Unpack the motif files (see below for how to create your own, instead):
     $ mkdir /path/to/grch38_motifs
     $ tar xvfz motifs/HOCOMOCO_v11_p1e-6_grch38.tar.gz --directory /path/to/grch38_motifs
  Calculate the MD-scores for the first biological condition:
     $ process_atac --threads 8 --atac-peaks /path/to/DMSO/ATAC/peaks/file \
       --genome hg38 \
       --motif-path /path/to/directory/containing/motif/files \
       --output /path/to/output/directory
  The above command generates a file called ``BASENAME_md_scores.txt``.
  It’s generally a good idea to use the cell type (or sample number) and a
  brief condition description (e.g. ``k562_DMSO`` or
  ``SRR1234123_Metronidazole``) in the file name provided.
  We would then generate the same file, for the other biological condition
  we are comparing against:
     $ process_atac --threads 8 --atac-peaks /path/to/treatment/ATAC/peaks/file \
       --genome hg38 \
       --motif-path /path/to/directory/containing/motif/files \
       --output /path/to/output/directory
  The above generates a file called ``BASENAME_md_scores.txt``. Finally:
     $ differential_md_score --assay-1 DMSO --assay-2 Treatment --p-value 0.0000001 --barcodes --output /path/to/output/directory
  The above generates a tab-delimited file with all differential MD scores
  for each motif and their p-values (sorted by p-value), an MA plot that
  labels the most significant TF activity changes, at a p-value cutoff of
  1e-7. Note that better plot-friendly condition names (say, “DMSO” and
  “Treatment”) can be provided using the ``--label-1`` and ``--label-2``
  arguments. The plots look like the example below:
     Sample MA plot
  The ``-b`` flag also generates a “barcode plot” of each of these
  statistically significat motif differences that depicts how close the
  ATAC-seq peaks were to the (putative TF-binding) motif sites, within a
  1500 base-pair radius of the motif center:
     Sample barcode plot
  If you can take advantage of multiprocessing, you can calculate
  MD-scores for both conditions simultaneously, assigning several threads
  to each, then generate the plots once both ``*_md_scores.txt`` files are
  ready.
  The columns for the tab-separated output file from
  ``differential_md_score`` are:
     Motif name , p-value , # total motif hits, # nearby peaks in condition 1 , # nearby peaks in condition 2 , MD-score in condition 1 , MD-score in condition 2, differential MD-score
  To query what we know about these highlighted TFs displaying a
  significant difference in activity, we can use:
     $ tf_result_explanations -p 0.0000001 \
       -d /path/to/output/directory/your_condition1_vs_condition2_differential_md_score.txt \
       -o /path/to/report_file.txt


pkgId: bef635d2c8ed7b40725d37f9f96f4ad043cbd7fafd3da8339a009aa46007cc82
name: python-Dalood
arch: src
version: 2024.7
epoch: 0
release: 1
summary: Extensible on-demand file loading with cache management.
url: https://gitlab.inria.fr/jrye/dalood
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Dalood-2024.7-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2022, Inria  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: d9a6f5655a5e55202e438b42a214da35a74b338e0bbfcbaf6cb85090949ed7b3
name: python-Dandelion
arch: src
version: 0.17.26
epoch: 0
release: 1
summary: A light weight deep learning framework
url: https://github.com/david-leon/Dandelion
rpm_license: Mozilla Public License v2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Dandelion-0.17.26-1.src.rpm
checksum_type: sha256
description:
  module            | all neual network module definitions
  functional        | operations on tensor with no parameter to be learned
  initialization    | initialization methods for neural network modules
  activation        | definition of all activation functions
  objective         | definition of all loss objectives
  update            | definition of all optimizers
  util              | utility functions
  model             | model implementations out-of-the-box
  ext               | extensions

  The design of Dandelion heavily draws on [Lasagne](https://github.com/Lasagne/Lasagne) and [Pytorch](http://pytorch.org/), both my favorate DL libraries.
  Special thanks to **Radomir Dopieralski**, who transferred the `dandelion` project name on pypi to us. Now you can install the package by simply `pip install dandelion`.


pkgId: f99a3e3e2e4e7df14067968f64a85660c937ee12afd285fb12dc4450447bcfaa
name: python-Dans-Diffraction
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: Generate diffracted intensities from crystals
url: https://github.com/DanPorter/Dans_Diffraction
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Dans-Diffraction-3.2.1-1.src.rpm
checksum_type: sha256
description:
     Copyright 2024 Diamond Light Source Ltd.
     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.
  Files in this package covered by this licence:
  * classes_crystal.py
  * classes_scattering.py
  * classes_plotting.py
  * classes_properties.py
  * classes_multicrystal.py
  * classes_orientation.py
  * classes_orbitals.py
  * functions_general.py
  * functions_plotting.py
  * functions_scattering.py
  * functions_crystallography.py
  * tkgui/*.py
  Other files are either covered by their own licence or not licenced for other use.
  | Dr Daniel G Porter | [dan.porter@diamond.ac.uk](mailto:dan.porter@diamond.ac.uk) |
  | ---- | ---- |
  | [www.diamond.ac.uk](www.diamond.ac.uk) | Diamond Light Source, Chilton, Didcot, Oxon, OX11 0DE, U.K. |

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


pkgId: d3128a544471b611f3696e63a4d6e91250368abe4c01fcfa16b80a052db5c278
name: python-DarkFream
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Простой веб-фреймворк для создания веб-приложений
url: https://github.com/vsp210/DarkFreamMega
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DarkFream-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Мой собственный фреймворк DarkFream.





  DarkFream - это фреймворк который позволяет создавать крайне простые веб-приложения



  + **Создание моделей** - Создание моделей для базы данных крайне схожая с фреймворком Django но имеет меньший функционал например:
  - **CharField**
  - **TextField**
  - **IntegerField**

  + **Работа с шаблонами** - Работа с шаблонами похожая с Django или Flask например:
  - **render** (рендерит шаблон)
  - **redirect** (изменяет ваш url)



  - для работы требуется выполнить команду:
  ```pip install DarkFream```




  - DarkFreamMega/app.py:
  ~~~python
  from DarkFream.app import *
  from DarkFream.auth import Auth
  from DarkFream.orm import *
  from .models import Post


  app = DarkHandler.initialize()
  auth = Auth(app)
  app.admin.register_model(Post)

  @app.route('/', methods=['GET'])
  def list_posts(data=None):
      posts = Post.select()
      return app.render('posts/list.html', {'posts': posts})

  @app.route('/posts/create', methods=['GET', 'POST'])
  @auth.login_required('/login')
  def create_post(data=None):
      if data['method'] == 'POST':
          title = data['data'].get('title', [''])[0]
          content = data['data'].get('content', [''])[0]
          session = auth.get_current_user(data)

          if session:
              author = session.user
              new_post = Post(title=title, content=content, author=author)
              new_post.save()
              return app.redirect('/')

      return app.render('posts/create.html')

  @app.route('/posts/<id>', methods=['GET'])
  def view_post(data=None, id=None):
      post = Post.get_by_id(id)
      return app.render('posts/view.html', {'post': post})

  @app.route('/edit/<id>', methods=['GET', 'POST'])
  def edit_post(data=None, id=None):
      post = Post.get_by_id(id)

      if data['method'] == 'POST':
          post.title = data['data'].get('title', [''])[0]
          post.content = data['data'].get('content', [''])[0]
          post.save()
          return app.redirect('/posts')

      return app.render('posts/edit.html', {'post': post})

  @app.route('/delete/<id>', methods=['POST'])
  def delete_post(data=None, id=None):
      post = Post.get_by_id(id)
      post.delete_instance()
      return app.redirect('/posts')

  @app.route('/login', methods=['GET', 'POST'])
  def login(data=None):
      if data['method'] == 'POST':
          user = auth.login(data)
          if user is not None:
              return user
      return app.render('posts/login.html')

  if __name__ == '__main__':
      migrate([Post])
      app.run()
  ~~~

  - DarkFreamMega/templates/models.py:
  ~~~python
  from DarkFream.orm import *

  class Post(DarkModel):
      title = CharField()
      content = TextField()
      author = ForeignKeyField(User, backref='posts')

      def __str__(self):
          return self.title
  ~~~

  - DarkFreamMega/templates/login.html:
  ~~~html
  {% extends "base.html" %}

  {% block content %}
  <div class="row justify-content-center">
      <div class="col-md-6">
          <div class="card mt-5">
              <div class="card-header">
                  <h3 class="text-center">Login</h3>
              </div>
              <div class="card-body">
                  {% if error_message %}
                      <div class="alert alert-danger" role="alert">
                          {{ error_message }}
                      </div>
                  {% endif %}
                  <form method="POST">
                      <div class="mb-3">
                          <label for="username" class="form-label">Username</label>
                          <input type="text" class="form-control" id="username" name="username" required>
                      </div>
                      <div class="mb-3">
                          <label for="password" class="form-label">Password</label>
                          <input type="password" class="form-control" id="password" name="password" required>
                      </div>
                      <div class="d-grid">
                          <button type="submit" class="btn btn-primary">Login</button>
                      </div>
                  </form>
              </div>
          </div>
      </div>
  </div>
  {% endblock %}
  ~~~

  - DarkFreamMega/templates/edit.html:
  ~~~html
  {% extends "base.html" %}
  {% block title %}Edit Post{% endblock %}

  {% block content %}
  <h1>Edit Post</h1>
  <form method="POST">
      <div>
          <label for="title">Title</label>
          <input type="text" name="title" value="{{ post.title }}" required>
      </div>
      <div>
          <label for="content">Content</label>
          <textarea name="content" required>{{ post.content }}</textarea>
      </div>
      <button type="submit">Save</button>
  </form>
  <a href="/">Back to list</a>
  {% endblock %}
  ~~~

  - DarkFreamMega/templates/list.html:
  ~~~html
  {% extends "base.html" %}
  {% block title %}Posts{% endblock %}

  {% block content %}
  <h1>Posts</h1>
  <a href="/create" class="btn btn-primary">Create New Post</a>
  <table class="table">
      <thead>
          <tr>
              <th>Title</th>
              <th>Actions</th>
          </tr>
      </thead>
      <tbody>
          {% for post in posts %}
          <tr>
              <td><a href="/posts/{{ post.id }}" class="post-link">{{ post.title }}</a></td>
              <td>
                  <a href="/edit/{{ post.id }}" class="btn btn-warning">Edit</a>
                  <form action="/delete/{{ post.id }}" method="POST" style="display:inline;">
                      <button type="submit" class="btn btn-danger">Delete</button>
                  </form>
              </td>
          </tr>
          {% endfor %}
      </tbody>
  </table>
  {% endblock %}
  ~~~

  - DarkFreamMega/templates/view.html:
  ~~~html
  {% extends "base.html" %}
  {% block title %}{{ post.title }}{% endblock %}

  {% block content %}
  <h1>{{ post.title }}</h1>
  <p>{{ post.content }}</p>
  <a href="/">Back to list</a>
  <a href="/edit/{{ post.id }}">Edit</a>
  <form action="/delete/{{ post.id }}" method="POST" style="display:inline;">
      <button type="submit">Delete</button>
  </form>
  {% endblock %}
  ~~~

  - DarkFreamMega/templates/base.html:
  ~~~html
  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>{% block title %}Posts{% endblock %}</title>
      <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
      <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
      <style>
          .navbar {
              margin-bottom: 20px;
          }
          .content {
              padding: 20px;
          }
      </style>
  </head>
  <body>
      <nav class="navbar navbar-expand-lg navbar-light bg-light">
          <div class="container-fluid">
              <a class="navbar-brand" href="/">Post Management</a>
              <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
                  <span class="navbar-toggler-icon"></span>
              </button>
              <div class="collapse navbar-collapse" id="navbarNav">
                  <ul class="navbar-nav">
                      <li class="nav-item">
                          <a class="nav-link" href="">Posts</a>
                      </li>
                      <li class="nav-item">
                          <a class="nav-link" href="/create">Create Post</a>
                      </li>
                  </ul>
              </div>
          </div>
      </nav>

      <div class="container">
          <div class="content">
              {% block content %}{% endblock %}
          </div>
      </div>

      <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
  </body>
  </html>
  ~~~


  В этом примере мы создали пример простого приложения постов
  - ##### В файле `app.py` мы создали приложение DarkFream, добавили маршруты:
  - `/` первая страница со всеми постами
  - `/create` страница создания поста (можно зайти еслси пользователь вошол в систему)
  - `/posts/<id>` страница просмотра определёного поста
  - `/edit/<id>` страница редактирования постов
  - `delete/<id>` страница удаления поста
  - `/login/` страница для входа в систему


  В этом примере мы использовали функцию `migrate([Post])` которая встроеная в DarkFream и нужна для создания бд с моделью User (Рекомендую всегда вставлять эту строчку).
  Также в DarkFream присутствует встроеная админка доступная по адресу `/admin/`


  - **ВКонтакте**: https://vk.com/vsp210
  - **Телеграм**: https://t.me/vsp210
  - **Электронная почта**: vsp210@gmail.com
  - **Проект на pypi.org**: https://pypi.org/project/DarkFream/1.1.8/









  - ##### Улучшена скорость
  - ##### Добавлена возможность создания большой кастомизации
  - ##### системы шифрования данных через сессии
  - ##### Добавлена возможность создания кастомных шаблонов


pkgId: 093c56e2b5b3a83a6f1b90c13dc816b541fdc43a7ba6145891aaef78b10485cc
name: python-DartLintBear
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: 'DartLintBear' bear for coala (http://coala.rtfd.org/)
url: https://pypi.org/project/DartLintBear/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DartLintBear-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Checks the code with ``dart-linter``.

      This bear expects dart commands to be on your ``PATH``. Please ensure
      /path/to/dart-sdk/bin is in your ``PATH``.


pkgId: 58f30f4fb5554b4a804dd9a4cd72a00758d5f45d7899aeb499c3da7145920f90
name: python-Dash-Signature
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Signature element for Dash sites in Python
url: https://pypi.org/project/Dash-Signature/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Dash-Signature-0.1.9-1.src.rpm
checksum_type: sha256
description:
  cd into this folder
  create the python virtual environment
  install depenedencies with `pip install -r requirements.txt`
  install wheel with `pip install wheel`
  install node dependencies with `yarn install`
  build the css with `yarn run css`
  build the node package with `yarn run build`
  build the python package with `python setup.py sdist bdist_wheel`
  update the dependencies of myijack in pyproject.toml to have this:
  dash_signature = { path = "/workspace/dash_signature", develop = true }




  Dash-Signature is a Dash element for adding a signature field to a form.

  None

  Get started with:
  1. Install Dash and its dependencies: https://dash.plotly.com/installation
  2. Run `python usage.py`
  3. Visit http://localhost:8050 in your web browser



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



  Clone this code and open it in a Development container in VS Code, which will install Python 3, NodeJS, NPM, and Yarn.

  1. Install npm packages with Yarn or NPM
      ```
      $ yarn install || npm install
      ```
  2. Install Poetry packages for Python
      ```
      $ poetry install
      ```
  3. Build the Dash custom component
      ```
      $ yarn run build
      ```



  - The demo app is in `src/demo` and you will import your example component code into your demo app.
  - Test your code in a Python environment:
      1. Build your code
          ```
          $ yarn run build
          ```
      2. Run and modify the `usage.py` sample dash app:
          ```
          $ python usage.py
          ```
  - Write tests for your component.
      - A sample test is available in `tests/test_usage.py`, it will load `usage.py` and you can then automate interactions with selenium.
      - Run the tests with `$ pytest tests`.
      - The Dash team uses these types of integration tests extensively. Browse the Dash component code on GitHub for more examples of testing (e.g. https://github.com/plotly/dash-core-components)
  - Add custom styles to your component by putting your custom CSS files into your distribution folder (`dash_signature`).
      - Make sure that they are referenced in `MANIFEST.in` so that they get properly included when you're ready to publish your component.
      - Make sure the stylesheets are added to the `_css_dist` dict in `dash_signature/__init__.py` so dash will serve them automatically when the component suite is requested.
  - [Review your code](./review_checklist.md)



  1. Build your code:
      ```
      $ yarn run build
      ```
  2. Create a Python distribution
      ```
      $ python setup.py sdist bdist_wheel
      ```
      This will create source and wheel distribution in the generated the `dist/` folder.
      See [PyPA](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project)
      for more information.

  3. Test your tarball by copying it into a new environment and installing it locally:
      ```
      $ pip install dash_signature-0.1.5.tar.gz
      ```

  4. If it works, then you can publish the component to NPM and PyPI:
      1. Publish on PyPI
          ```
          $ twine upload dist/*
          ```
      2. Cleanup the dist folder (optional)
          ```
          $ rm -rf dist
          ```
      3. Publish on NPM (Optional if chosen False in `publish_on_npm`)
          ```
          $ npm publish
          ```
          _Publishing your component to NPM will make the JavaScript bundles available on the unpkg CDN. By default, Dash serves the component library's CSS and JS locally, but if you choose to publish the package to NPM you can set `serve_locally` to `False` and you may see faster load times._

  5. Share your component with the community! https://community.plotly.com/c/dash
      1. Publish this repository to GitHub
      2. Tag your GitHub repository with the plotly-dash tag so that it appears here: https://github.com/topics/plotly-dash
      3. Create a post in the Dash community forum: https://community.plotly.com/c/dash


pkgId: ccfc911a7734bf95e444d9803fdd82d89ef0242ceb130a5eb61ae2f76d1e065e
name: python-DataAnalysisEnedis
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/ZephyrIt0/DataAnalysisEnedis
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-DataAnalysisEnedis-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  DataAnalysis_enedis est une classe Python conçue pour faciliter l'analyse de données dans le cadre de la gestion de flux de données d'Enedis

description:
  **Author**: Grace LUSAKUMUNU DIMBU.


  - [Installation](#installation)
  - [Pré-requis](#pré-requis)
  - [Classes principales](#classes-principales)
  - [Exemple d'utilisation](#exemple-dutilisation)
  - [Configuration](#configuration)
  - [Tests](#tests)



  Pour installer la librairie, vous pouvez utiliser pip :

  ```bash
  pip install DataAnalysis_enedis

  ```

  Cette librairie permet de gérer la connexion à des bases de données, de manipuler des fichiers cryptés, de se connecter à un serveur SFTP, et d'exécuter diverses analyses de données. La classe principale `DataAnalysis_enedis` hérite de plusieurs classes utilitaires : `BDD`, `QueryFlux`, et `Decriptage`.




  `DataAnalysis_enedis` est une classe Python conçue pour faciliter l'analyse de données dans le cadre de la gestion de flux de données d'Enedis. Elle permet de lire et traiter des fichiers JSON et XML, de se connecter à des bases de données PostgreSQL et SQL Server, et de gérer les fichiers décompressés et décryptés à l'aide d'AES. Cette librairie est idéale pour l'automatisation des processus de transformation, d'analyse et d'insertion des données dans une base de données.



  - **Traitement des fichiers JSON et XML** : Lecture et transformation de fichiers JSON contenant des mesures et de fichiers XML spécifiques au format F12 et F15.
  - **Analyse de données** : Extraction des données pertinentes à partir des fichiers et transformation en DataFrames pour une analyse ultérieure.
  - **Connexion aux bases de données** : Connexion à des bases de données PostgreSQL et SQL Server pour insérer ou récupérer des données.
  - **Décryptage AES** : Gestion des fichiers protégés par cryptage AES pour assurer la sécurité des données.
  - **Support SFTP** : Récupération des informations de connexion SFTP pour télécharger ou envoyer des fichiers.


  - [__init__](#__init__)
    Le constructeur de la classe permet d'initialiser les différents paramètres et de charger le fichier de configuration.

  - [load_settings](#load_settings)
    Charge le fichier JSON de configuration.

  - [get_content_HT](#get_content_HT)
    Lit un fichier JSON, le transforme en DataFrame et l'enregistre dans un fichier Excel.

  - [f12_parse_xml_fl](#f12_parse_xml_fl)
    Parse un fichier XML au format F12 et retourne un DataFrame avec les données extraites.

  - [f15_parse_xml_fl](#f15_parse_xml_fl)
    Parse un fichier XML au format F15 et retourne un dictionnaire de DataFrames.

  - [f15_parse_xml_fa](#f15_parse_xml_fa)
    Parse un fichier XML F15 (version F15 avec attributs).

  - [get_sftp_username](#get_sftp_username)
    Retourne le nom d'utilisateur SFTP défini dans le fichier de configuration JSON.

  - [get_sftp_password](#get_sftp_password)
    Retourne le mot de passe SFTP défini dans le fichier de configuration JSON.

  - [get_sftp_server](#get_sftp_server)
    Retourne l'adresse du serveur SFTP définie dans le fichier de configuration JSON.

  - [get_sftp_directory_f15](#get_sftp_directory_f15)
    Retourne le répertoire F15 sur le serveur SFTP défini dans le fichier de configuration JSON.








  La classe `BDD` gère la connexion à des bases de données PostgreSQL et SQL Server.



  - **`__init__(self, config_path="db_settings.json")`**
    Initialise la connexion à la base de données en utilisant les paramètres du fichier de configuration `db_settings.json`.

  - **`load_config(config_path)`**
    Charge les paramètres de configuration depuis un fichier JSON.

  - **`connect_to_postgresql()`**
    Établit une connexion à PostgreSQL en utilisant les paramètres fournis.

  - **`connect_to_sqlServer(options='-csearch_path=dbo')`**
    Établit une connexion à SQL Server en utilisant les paramètres de configuration.

  - **`create_table(table_name, columns_json, unique_columns=None)`**
    Crée une table dans la base de données avec les colonnes spécifiées et une contrainte unique facultative.

  - **`insert_into(table, data=pd.DataFrame())`**
    Insère les données d'un `DataFrame` Pandas dans une table SQL.

  - **`getEngine()`**
    Retourne l'instance actuelle de l'objet `engine`.

  - **`disconnect()`**
    Ferme la connexion à la base de données.



  La classe `Decriptage` permet de décrypter des fichiers ZIP chiffrés à l'aide de la cryptographie AES et d'extraire les fichiers du ZIP.



  - **`__init__(self, aes_key_hex, iv_hex)`**
    Initialise la clé AES et le vecteur d'initialisation (IV) en hexadécimal.

  - **`setKeys(aes_key_hex, iv_hex)`**
    Définit la clé AES et le IV pour le chiffrement et le déchiffrement.

  - **`decrypt_file(input_path, output_path, path_unzip)`**
    Décrypte un fichier ZIP chiffré et le sauvegarde dans un nouveau fichier.

  - **`unzip_file()`**
    Extrait tous les fichiers d'un fichier ZIP décrypté.



  La classe `QueryFlux` permet de se connecter à un serveur SFTP, de télécharger des fichiers et de gérer des dossiers distants.



  - **`__init__(self, flux_name="QueryF12", path_unzip="Unzip_f12", path_decrypted="Decrypted_f12")`**
    Initialise la connexion au serveur SFTP et crée les répertoires nécessaires pour l'extraction des fichiers.

  - **`connect_to_sftp(username, password, server)`**
    Se connecte à un serveur SFTP en utilisant les identifiants fournis.

  - **`create_directory(directory)`**
    Crée un répertoire local pour stocker les fichiers téléchargés.

  - **`getFiles(files=[])`**
    Télécharge les fichiers spécifiés dans la liste `files` à partir du serveur SFTP.

  - **`setFolder_flux(folder_name)`**
    Définit un nouveau dossier pour stocker les fichiers téléchargés.





  ```python
  from DataAnalysis import DataAnalysis_enedis


  data_analysis = DataAnalysis_enedis(config_path="db_settings.json")


  data_analysis.connect_to_postgresql()


  columns_json = {
      "id": {"type": "INTEGER", "nullable": False},
      "name": {"type": "VARCHAR", "nullable": True, "length": 25},
      "created_at": {"type": "DATETIME", "nullable": False}
  }
  data_analysis.create_table("my_table", columns_json)


  data = pd.DataFrame({
      "id": [1, 2],
      "name": ["Alice", "Bob"],
      "created_at": ["2024-11-01", "2024-11-02"]
  })
  data_analysis.insert_into("my_table", data)


  data_analysis.setKeys(aes_key_hex="your_aes_key", iv_hex="your_iv")
  data_analysis.decrypt_file("path/to/encrypted.zip", "path/to/decrypted.zip", "path/to/unzip")


  data_analysis.connect_to_sftp("username", "password", "ftp.server.com")
  data_analysis.getFiles(["path/to/file1.zip", "path/to/file2.zip"])

  ```



  ```json
  {
      "postgresql_database": "",
      "postgresql_user": "",
      "postgresql_password": "",
      "postgresql_host": "",
      "postgresql_port": 5432,

      "sql_server_user": "",
      "sql_server_password": "",
      "sql_server_host": "192.x.x.x\\SQLEXPRESS",
      "sql_server_port": 1433,
      "sql_server_database": "",
      "sql_server_driver": "ODBC Driver 17 for SQL Server",

      "decryptage": {
          "aes_key_hex": "",
          "iv_hex": ""
      },
      "sftp": {
          "server": "",
          "username": "",
          "password": "",
          "directory_f15": "/flux_enedis/F15",
          "directory_f12": "/flux_enedis/F12"
      }
  }


  ```


  ```python
  import sys
  import pandas as pd
  from DataAnalysis import DataAnalysis_enedis

  ID_TEST = 3


  dataAnalysis_enedis = DataAnalysis_enedis("tests/settings.json")

  match (ID_TEST):

      case 1:
          
          data = dataAnalysis_enedis.get_content_HT("tests/data/ENEDIS_R64_P_INDEX_M073565K_00001_20241112103114_Injection.JSON", "content")
          data['d'] = pd.to_datetime(data['d'])

          
          columns_json = {
              "prm": {"type": "VARCHAR", "length": 14, "nullable": True},
              "d": {"type": "DATETIME", "nullable": True},
              "v": {"type": "FLOAT", "nullable": True},
              "unite": {"type": "VARCHAR", "length": 5, "nullable": True},
              "grandeurPhysique": {"type": "VARCHAR", "length": 5, "nullable": True},
              "libelleClasseTemporelle": {"type": "VARCHAR", "length": 100, "nullable": True},
              "idCalendrier": {"type": "VARCHAR", "length": 20, "nullable": True},
              "iv": {"type": "VARCHAR", "length": 5, "nullable": True},
          }

          
          dataAnalysis_enedis.connect_to_sqlServer()
          dataAnalysis_enedis.create_table("ht_injection", columns_json, None)
          dataAnalysis_enedis.insert_into("ht_injection", data)

      case 2:
          
          status = dataAnalysis_enedis.connect_to_sftp(dataAnalysis_enedis.get_sftp_username(),
                                                      dataAnalysis_enedis.get_sftp_password(),
                                                      dataAnalysis_enedis.get_sftp_server())
          folders = dataAnalysis_enedis.set_root_directory()
          files_f12 = dataAnalysis_enedis.change_directory_sftp(dataAnalysis_enedis.get_sftp_directory_f12())

          dataAnalysis_enedis.setFolder_flux("fichiers_f12")
          dataAnalysis_enedis.getFiles(files_f12)

      case 3:
          
          status = dataAnalysis_enedis.connect_to_sftp(dataAnalysis_enedis.get_sftp_username(),
                                                      dataAnalysis_enedis.get_sftp_password(),
                                                      dataAnalysis_enedis.get_sftp_server())
          folders = dataAnalysis_enedis.set_root_directory()
          files_f15 = dataAnalysis_enedis.change_directory_sftp(dataAnalysis_enedis.get_sftp_directory_f15())

          
          dataAnalysis_enedis.create_directory("fichiers_decrypters")
          dataAnalysis_enedis.create_directory("content_zip")

          dataAnalysis_enedis.setKeys(dataAnalysis_enedis.get_aes_key_decryptage(),
                                      dataAnalysis_enedis.get_iv_decryptage())

          dataAnalysis_enedis.decrypt_file("fichiers_f15\\17X100A100A0001A_F15_17X000001117366M_GRD-F139_0322_C_M_0_P_00001_20240603050837.zip",
                                            "fichiers_decrypters\\17X100A100A0001A_F15_17X000001117366M_GRD-F139_0322_C_M_0_P_00001_20240603050837.zip",
                                            "content_zip")
  ```


pkgId: b0762665232d252d09ad1ae8fcdb771f19ff69ab22f02f5fbf7d5e467e7d1d48
name: python-a-bigelow.cdk-eventbridge-partner-processors
arch: src
version: 0.0.420
epoch: 0
release: 1
summary: cdk-eventbridge-partner-processors
url: https://github.com/a-bigelow/cdk-eventbridge-partner-processors.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-bigelow.cdk-eventbridge-partner-processors-0.0.420-1.src.rpm
checksum_type: sha256
description:
  [![View on Construct Hub](https://constructs.dev/badge?package=cdk-eventbridge-partner-processors)](https://constructs.dev/packages/cdk-eventbridge-partner-processors)

  [![npm version](https://badge.fury.io/js/cdk-eventbridge-partner-processors.svg)](https://badge.fury.io/js/cdk-eventbridge-partner-processors)
  [![PyPI version](https://badge.fury.io/py/a-bigelow.cdk-eventbridge-partner-processors.svg)](https://badge.fury.io/py/a-bigelow.cdk-eventbridge-partner-processors)
  [![Go project version](https://badge.fury.io/go/github.com%2Fa-bigelow%2Fcdk-eventbridge-partner-processors-go.svg)](https://badge.fury.io/go/github.com%2Fa-bigelow%2Fcdk-eventbridge-partner-processors-go)

  This CDK Construct library provides CDK constructs for the 1st-party (i.e. developed by AWS) lambda fURL webhook receivers for:

  * GitHub
  * Stripe
  * Twilio



  These examples are consistent for all 3 primary exported constructs of this library:

  * `GitHubEventProcessor`
  * `TwilioEventProcessor`
  * `StripeEventProcessor`

  > Note: Click on the above `View on Construct Hub` button to view auto-generated examples in Python/Go



  ```python
  import { GitHubEventProcessor } from 'cdk-eventbridge-partner-processors';
  import { Stack, StackProps } from 'aws-cdk-lib';
  import { Construct } from 'constructs';
  import { EventBus } from 'aws-cdk-lib/aws-events';
  import { Secret } from 'aws-cdk-lib/aws-secretsmanager';

  export class MyStackWithABetterName extends Stack {
      constructor(scope: Construct, id: string, props: StackProps) {
          super(scope, id, props);

          // This library has no opinion on how you reference your EventBus,
          // It just needs to fulfill the IEventBus protocol
          const myEventBus = new EventBus(this, 'TheBestBusEver', {
              eventBusName: 'TheGreatestBus'
          });

          // This library has no opinion on how you reference your secret,
          // It just needs to fulfill the ISecret protocol
          const mySecret = Secret.fromSecretNameV2(this, 'MyNuclearCodeSecret', '/home/recipes/icbm')

          // Function will automatically receive permission to:
          // 1. Post events to the given bus
          // 2. Read the given secret
          const githubEventProcessor = new GitHubEventProcessor(this, 'GitHubProcessor', {
              eventBus: myEventBus,
              webhookSecret: mySecret,
              lambdaInvocationAlarmThreshold: 2000,
          })

      }
  }
  ```



  ```go
  package main

  import (
  	partner "github.com/a-bigelow/cdk-eventbridge-partner-processors-go"
  	"github.com/aws/aws-cdk-go/awscdk/v2"
  	"github.com/aws/aws-cdk-go/awscdk/v2/awsevents"
  	"github.com/aws/constructs-go/constructs/v10"
  	"github.com/aws/jsii-runtime-go"
  )

  type ClusterStackProps struct {
  	awscdk.StackProps
  }

  func NewClusterStack(scope constructs.Construct, id string, props *ClusterStackProps) awscdk.Stack {
  	var sprops awscdk.StackProps
  	if props != nil {
  		sprops = props.StackProps
  	}
  	stack := awscdk.NewStack(scope, &id, &sprops)

  	// The code that defines your stack goes here
  	eventProps := awsevents.EventBusProps{EventBusName: jsii.String("name")}

  	eventBus := awsevents.NewEventBus(stack, jsii.String("id"), &eventProps)

  	secret := secretsmanager.secret.fromSecretNameV2(scope, jsii.String("secret"), jsii.String("secretName"))
  	partnerProcessor := partner.GithubEventProcessor{
  		EventBus:                       eventBus,
  		WebhookSecret:                  secret,
  		LambdaInvocationAlarmThreshold: 2000,
  	}

  	_ = partner.NewGitHubEventProcessor(stack, jsii.String("id"), partnerProcessor)

  	return stack
  }
  ```



  > :warning: The Lambda Functions that handle the actual event processing in this Library are owned and maintained by Amazon Web Services. This CDK Construct library provides a thin deployment wrapper for these functions. Changes made to the S3 location of the functions will break this library. Until I have a way to deterministically track where these things are, please raise an **issue** if you have reason to believe that the functions have moved.



  See [here](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-saas-furls.html) for additional information.


pkgId: 4246a952be671d8654a109fadddef9eb21f695f106a49ec24c3ea7ce89e11dda
name: python-a-cv-imwrite-imread-plus
arch: src
version: 0.13
epoch: 0
release: 1
summary: Less trouble reading/writing images with OpenCV (from url/path/buffer/base64...)
url: https://github.com/hansalemaos/a_cv_imwrite_imread_plus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-cv-imwrite-imread-plus-0.13-1.src.rpm
checksum_type: sha256
description:
  ```python
  $pip install a-cv-imwrite-imread-plus
  from a_cv_imwrite_imread_plus import add_imwrite_plus_imread_plus_to_cv2
  add_imwrite_plus_imread_plus_to_cv2()
  cv2.imwrite_plus("f:\\ö\\ö\\ö\\öädssdzß.jpg", base64img2cv)


  from a_cv_imwrite_imread_plus import save_cv_image
  save_cv_image("f:\\ö\\ö\\ö\\öädssdzß.jpg", base64img2cv)


  	Parameters:
  		filepath:str
  			folders will be created if they don't exist
  		image:np.ndarray
  			image as np
  	Returns:
  		filepath:str
  ```


  ```python
  from a_cv_imwrite_imread_plus import add_imwrite_plus_imread_plus_to_cv2
  add_imwrite_plus_imread_plus_to_cv2()
  import base64
  from PIL import Image
  import cv2


  base64img = r"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAApgAAAKYB3X3/OAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAANCSURBVEiJtZZPbBtFFMZ/M7ubXdtdb1xSFyeilBapySVU8h8OoFaooFSqiihIVIpQBKci6KEg9Q6H9kovIHoCIVQJJCKE1ENFjnAgcaSGC6rEnxBwA04Tx43t2FnvDAfjkNibxgHxnWb2e/u992bee7tCa00YFsffekFY+nUzFtjW0LrvjRXrCDIAaPLlW0nHL0SsZtVoaF98mLrx3pdhOqLtYPHChahZcYYO7KvPFxvRl5XPp1sN3adWiD1ZAqD6XYK1b/dvE5IWryTt2udLFedwc1+9kLp+vbbpoDh+6TklxBeAi9TL0taeWpdmZzQDry0AcO+jQ12RyohqqoYoo8RDwJrU+qXkjWtfi8Xxt58BdQuwQs9qC/afLwCw8tnQbqYAPsgxE1S6F3EAIXux2oQFKm0ihMsOF71dHYx+f3NND68ghCu1YIoePPQN1pGRABkJ6Bus96CutRZMydTl+TvuiRW1m3n0eDl0vRPcEysqdXn+jsQPsrHMquGeXEaY4Yk4wxWcY5V/9scqOMOVUFthatyTy8QyqwZ+kDURKoMWxNKr2EeqVKcTNOajqKoBgOE28U4tdQl5p5bwCw7BWquaZSzAPlwjlithJtp3pTImSqQRrb2Z8PHGigD4RZuNX6JYj6wj7O4TFLbCO/Mn/m8R+h6rYSUb3ekokRY6f/YukArN979jcW+V/S8g0eT/N3VN3kTqWbQ428m9/8k0P/1aIhF36PccEl6EhOcAUCrXKZXXWS3XKd2vc/TRBG9O5ELC17MmWubD2nKhUKZa26Ba2+D3P+4/MNCFwg59oWVeYhkzgN/JDR8deKBoD7Y+ljEjGZ0sosXVTvbc6RHirr2reNy1OXd6pJsQ+gqjk8VWFYmHrwBzW/n+uMPFiRwHB2I7ih8ciHFxIkd/3Omk5tCDV1t+2nNu5sxxpDFNx+huNhVT3/zMDz8usXC3ddaHBj1GHj/As08fwTS7Kt1HBTmyN29vdwAw+/wbwLVOJ3uAD1wi/dUH7Qei66PfyuRj4Ik9is+hglfbkbfR3cnZm7chlUWLdwmprtCohX4HUtlOcQjLYCu+fzGJH2QRKvP3UNz8bWk1qMxjGTOMThZ3kvgLI5AzFfo379UAAAAASUVORK5CYII="
  base64img2 = r"iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAApgAAAKYB3X3/OAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAANCSURBVEiJtZZPbBtFFMZ/M7ubXdtdb1xSFyeilBapySVU8h8OoFaooFSqiihIVIpQBKci6KEg9Q6H9kovIHoCIVQJJCKE1ENFjnAgcaSGC6rEnxBwA04Tx43t2FnvDAfjkNibxgHxnWb2e/u992bee7tCa00YFsffekFY+nUzFtjW0LrvjRXrCDIAaPLlW0nHL0SsZtVoaF98mLrx3pdhOqLtYPHChahZcYYO7KvPFxvRl5XPp1sN3adWiD1ZAqD6XYK1b/dvE5IWryTt2udLFedwc1+9kLp+vbbpoDh+6TklxBeAi9TL0taeWpdmZzQDry0AcO+jQ12RyohqqoYoo8RDwJrU+qXkjWtfi8Xxt58BdQuwQs9qC/afLwCw8tnQbqYAPsgxE1S6F3EAIXux2oQFKm0ihMsOF71dHYx+f3NND68ghCu1YIoePPQN1pGRABkJ6Bus96CutRZMydTl+TvuiRW1m3n0eDl0vRPcEysqdXn+jsQPsrHMquGeXEaY4Yk4wxWcY5V/9scqOMOVUFthatyTy8QyqwZ+kDURKoMWxNKr2EeqVKcTNOajqKoBgOE28U4tdQl5p5bwCw7BWquaZSzAPlwjlithJtp3pTImSqQRrb2Z8PHGigD4RZuNX6JYj6wj7O4TFLbCO/Mn/m8R+h6rYSUb3ekokRY6f/YukArN979jcW+V/S8g0eT/N3VN3kTqWbQ428m9/8k0P/1aIhF36PccEl6EhOcAUCrXKZXXWS3XKd2vc/TRBG9O5ELC17MmWubD2nKhUKZa26Ba2+D3P+4/MNCFwg59oWVeYhkzgN/JDR8deKBoD7Y+ljEjGZ0sosXVTvbc6RHirr2reNy1OXd6pJsQ+gqjk8VWFYmHrwBzW/n+uMPFiRwHB2I7ih8ciHFxIkd/3Omk5tCDV1t+2nNu5sxxpDFNx+huNhVT3/zMDz8usXC3ddaHBj1GHj/As08fwTS7Kt1HBTmyN29vdwAw+/wbwLVOJ3uAD1wi/dUH7Qei66PfyuRj4Ik9is+hglfbkbfR3cnZm7chlUWLdwmprtCohX4HUtlOcQjLYCu+fzGJH2QRKvP3UNz8bWk1qMxjGTOMThZ3kvgLI5AzFfo379UAAAAASUVORK5CYII="
  base64imgcv = cv2.imread_plus(base64img)
  base64img2cv = cv2.imread_plus(base64img2)
  base64imgcv = cv2.imread_plus(base64img, channels_in_output=4)
  base64img2cv = cv2.imread_plus(base64img2, channels_in_output=4)
  base64imgcv = cv2.imread_plus(base64img, channels_in_output=2)
  base64img2cv = cv2.imread_plus(base64img2, channels_in_output=2)


  pininterestlogo = "https://camo.githubusercontent.com/7f81f312b05694ccc8cd29e3c3466945ff8e73a13320d3fd0f90c6915bbb4ffb/68747470733a2f2f63646e2e6a7364656c6976722e6e65742f67682f646d68656e647269636b732f7369676e61747572652d736f6369616c2d69636f6e732f69636f6e732f726f756e642d666c61742d66696c6c65642f353070782f70696e7465726573742e706e67"
  linkcv1 = cv2.imread_plus(pininterestlogo)
  linkcv2 = cv2.imread_plus(pininterestlogo, channels_in_output=4)
  linkcv3 = cv2.imread_plus(pininterestlogo, channels_in_output=2)
  linkcv4 = cv2.imread_plus(pininterestlogo, channels_in_output=3)


  byteimage = base64.b64decode(base64img2)
  byteimage1 = cv2.imread_plus(byteimage)
  byteimage2 = cv2.imread_plus(byteimage, channels_in_output=4)
  byteimage3 = cv2.imread_plus(byteimage, channels_in_output=2)
  byteimage4 = cv2.imread_plus(byteimage, channels_in_output=3)


  pilimage = Image.fromarray(byteimage2)
  pilimage1 = cv2.imread_plus(pilimage)
  pilimage2 = cv2.imread_plus(pilimage, channels_in_output=4)
  pilimage3 = cv2.imread_plus(pilimage, channels_in_output=2)
  pilimage4 = cv2.imread_plus(pilimage, channels_in_output=3)


  floatimage = pilimage4.astype(float)
  floatimage1 = cv2.imread_plus(floatimage)
  floatimage2 = cv2.imread_plus(floatimage, channels_in_output=4)
  floatimage3 = cv2.imread_plus(floatimage, channels_in_output=2)
  floatimage4 = cv2.imread_plus(floatimage, channels_in_output=3)


  filepath = "c:\\testestestes.png"
  pilimage.save(filepath)
  filepath1 = cv2.imread_plus(filepath, bgr_to_rgb=True)
  filepath2 = cv2.imread_plus(filepath, channels_in_output=4, bgr_to_rgb=True)
  filepath3 = cv2.imread_plus(filepath, channels_in_output=2, bgr_to_rgb=True)
  filepath4 = cv2.imread_plus(filepath, channels_in_output=3, bgr_to_rgb=True)




  from a_cv_imwrite_imread_plus import open_image_in_cv

  base64img = r"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAApgAAAKYB3X3/OAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAANCSURBVEiJtZZPbBtFFMZ/M7ubXdtdb1xSFyeilBapySVU8h8OoFaooFSqiihIVIpQBKci6KEg9Q6H9kovIHoCIVQJJCKE1ENFjnAgcaSGC6rEnxBwA04Tx43t2FnvDAfjkNibxgHxnWb2e/u992bee7tCa00YFsffekFY+nUzFtjW0LrvjRXrCDIAaPLlW0nHL0SsZtVoaF98mLrx3pdhOqLtYPHChahZcYYO7KvPFxvRl5XPp1sN3adWiD1ZAqD6XYK1b/dvE5IWryTt2udLFedwc1+9kLp+vbbpoDh+6TklxBeAi9TL0taeWpdmZzQDry0AcO+jQ12RyohqqoYoo8RDwJrU+qXkjWtfi8Xxt58BdQuwQs9qC/afLwCw8tnQbqYAPsgxE1S6F3EAIXux2oQFKm0ihMsOF71dHYx+f3NND68ghCu1YIoePPQN1pGRABkJ6Bus96CutRZMydTl+TvuiRW1m3n0eDl0vRPcEysqdXn+jsQPsrHMquGeXEaY4Yk4wxWcY5V/9scqOMOVUFthatyTy8QyqwZ+kDURKoMWxNKr2EeqVKcTNOajqKoBgOE28U4tdQl5p5bwCw7BWquaZSzAPlwjlithJtp3pTImSqQRrb2Z8PHGigD4RZuNX6JYj6wj7O4TFLbCO/Mn/m8R+h6rYSUb3ekokRY6f/YukArN979jcW+V/S8g0eT/N3VN3kTqWbQ428m9/8k0P/1aIhF36PccEl6EhOcAUCrXKZXXWS3XKd2vc/TRBG9O5ELC17MmWubD2nKhUKZa26Ba2+D3P+4/MNCFwg59oWVeYhkzgN/JDR8deKBoD7Y+ljEjGZ0sosXVTvbc6RHirr2reNy1OXd6pJsQ+gqjk8VWFYmHrwBzW/n+uMPFiRwHB2I7ih8ciHFxIkd/3Omk5tCDV1t+2nNu5sxxpDFNx+huNhVT3/zMDz8usXC3ddaHBj1GHj/As08fwTS7Kt1HBTmyN29vdwAw+/wbwLVOJ3uAD1wi/dUH7Qei66PfyuRj4Ik9is+hglfbkbfR3cnZm7chlUWLdwmprtCohX4HUtlOcQjLYCu+fzGJH2QRKvP3UNz8bWk1qMxjGTOMThZ3kvgLI5AzFfo379UAAAAASUVORK5CYII="
  base64img2 = r"iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAApgAAAKYB3X3/OAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAANCSURBVEiJtZZPbBtFFMZ/M7ubXdtdb1xSFyeilBapySVU8h8OoFaooFSqiihIVIpQBKci6KEg9Q6H9kovIHoCIVQJJCKE1ENFjnAgcaSGC6rEnxBwA04Tx43t2FnvDAfjkNibxgHxnWb2e/u992bee7tCa00YFsffekFY+nUzFtjW0LrvjRXrCDIAaPLlW0nHL0SsZtVoaF98mLrx3pdhOqLtYPHChahZcYYO7KvPFxvRl5XPp1sN3adWiD1ZAqD6XYK1b/dvE5IWryTt2udLFedwc1+9kLp+vbbpoDh+6TklxBeAi9TL0taeWpdmZzQDry0AcO+jQ12RyohqqoYoo8RDwJrU+qXkjWtfi8Xxt58BdQuwQs9qC/afLwCw8tnQbqYAPsgxE1S6F3EAIXux2oQFKm0ihMsOF71dHYx+f3NND68ghCu1YIoePPQN1pGRABkJ6Bus96CutRZMydTl+TvuiRW1m3n0eDl0vRPcEysqdXn+jsQPsrHMquGeXEaY4Yk4wxWcY5V/9scqOMOVUFthatyTy8QyqwZ+kDURKoMWxNKr2EeqVKcTNOajqKoBgOE28U4tdQl5p5bwCw7BWquaZSzAPlwjlithJtp3pTImSqQRrb2Z8PHGigD4RZuNX6JYj6wj7O4TFLbCO/Mn/m8R+h6rYSUb3ekokRY6f/YukArN979jcW+V/S8g0eT/N3VN3kTqWbQ428m9/8k0P/1aIhF36PccEl6EhOcAUCrXKZXXWS3XKd2vc/TRBG9O5ELC17MmWubD2nKhUKZa26Ba2+D3P+4/MNCFwg59oWVeYhkzgN/JDR8deKBoD7Y+ljEjGZ0sosXVTvbc6RHirr2reNy1OXd6pJsQ+gqjk8VWFYmHrwBzW/n+uMPFiRwHB2I7ih8ciHFxIkd/3Omk5tCDV1t+2nNu5sxxpDFNx+huNhVT3/zMDz8usXC3ddaHBj1GHj/As08fwTS7Kt1HBTmyN29vdwAw+/wbwLVOJ3uAD1wi/dUH7Qei66PfyuRj4Ik9is+hglfbkbfR3cnZm7chlUWLdwmprtCohX4HUtlOcQjLYCu+fzGJH2QRKvP3UNz8bWk1qMxjGTOMThZ3kvgLI5AzFfo379UAAAAASUVORK5CYII="
  base64imgcv = open_image_in_cv(base64img)
  base64img2cv = open_image_in_cv(base64img2)
  base64imgcv = open_image_in_cv(base64img, channels_in_output=4)
  base64img2cv = open_image_in_cv(base64img2, channels_in_output=4)
  base64imgcv = open_image_in_cv(base64img, channels_in_output=2)
  base64img2cv = open_image_in_cv(base64img2, channels_in_output=2)


  pininterestlogo = "https://camo.githubusercontent.com/7f81f312b05694ccc8cd29e3c3466945ff8e73a13320d3fd0f90c6915bbb4ffb/68747470733a2f2f63646e2e6a7364656c6976722e6e65742f67682f646d68656e647269636b732f7369676e61747572652d736f6369616c2d69636f6e732f69636f6e732f726f756e642d666c61742d66696c6c65642f353070782f70696e7465726573742e706e67"
  linkcv1 = open_image_in_cv(pininterestlogo)
  linkcv2 = open_image_in_cv(pininterestlogo, channels_in_output=4)
  linkcv3 = open_image_in_cv(pininterestlogo, channels_in_output=2)
  linkcv4 = open_image_in_cv(pininterestlogo, channels_in_output=3)


  byteimage = base64.b64decode(base64img2)
  byteimage1 = open_image_in_cv(byteimage)
  byteimage2 = open_image_in_cv(byteimage, channels_in_output=4)
  byteimage3 = open_image_in_cv(byteimage, channels_in_output=2)
  byteimage4 = open_image_in_cv(byteimage, channels_in_output=3)


  pilimage = Image.fromarray(byteimage2)
  pilimage1 = open_image_in_cv(pilimage)
  pilimage2 = open_image_in_cv(pilimage, channels_in_output=4)
  pilimage3 = open_image_in_cv(pilimage, channels_in_output=2)
  pilimage4 = open_image_in_cv(pilimage, channels_in_output=3)


  floatimage = pilimage4.astype(float)
  floatimage1 = open_image_in_cv(floatimage)
  floatimage2 = open_image_in_cv(floatimage, channels_in_output=4)
  floatimage3 = open_image_in_cv(floatimage, channels_in_output=2)
  floatimage4 = open_image_in_cv(floatimage, channels_in_output=3)


  filepath = "c:\\testestestes.png"
  pilimage.save(filepath)
  filepath1 = open_image_in_cv(filepath, bgr_to_rgb=True)
  filepath2 = open_image_in_cv(filepath, channels_in_output=4, bgr_to_rgb=True)
  filepath3 = open_image_in_cv(filepath, channels_in_output=2, bgr_to_rgb=True)
  filepath4 = open_image_in_cv(filepath, channels_in_output=3, bgr_to_rgb=True)


  from a_cv2_imshow_thread import add_imshow_thread_to_cv2
  add_imshow_thread_to_cv2()
  cv2.imshow_thread(
      [
          base64imgcv,
          base64img2cv,
          linkcv1,
          linkcv2,
          linkcv3,
          linkcv4,
          byteimage1,
          byteimage2,
          byteimage3,
          byteimage4,
          pilimage1,
          pilimage2,
          pilimage3,
          pilimage4,
          floatimage1,
          floatimage2,
          floatimage3,
          floatimage4,
          filepath1,
          filepath2,
          filepath3,
          filepath4,
      ]
  )
          Parameters:
              image:Any
                  Can be URL, bytes, base64, file path, np.ndarray, PIL
              channels_in_output:Union[int,None]
                  None (original image won't be changed)
                  2 (GRAY)
                  3 (BGR)
                  4 (BGRA)
                  (default=None)
              bgr_to_rgb:bool=False
                  Converts BGRA to RGBA / BGR to RGB
          Returns:
              image:np.ndarray
                  (Always as np.uint8)
  ```


pkgId: f715ee240fc83d6b9411d046ba08e689e0a607f8e9abf7ebe32778c5ce4de814
name: python-a-cv2-easy-resize
arch: src
version: 0.10
epoch: 0
release: 1
summary: Different ways of resizing pictures in OpenCV
url: https://github.com/hansalemaos/a_cv2_easy_resize
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-cv2-easy-resize-0.10-1.src.rpm
checksum_type: sha256
description:
  ```python

  pip install a-cv2-easy-resize



  from a_cv2_easy_resize import add_easy_resize_to_cv2

  from a_cv_imwrite_imread_plus import add_imwrite_plus_imread_plus_to_cv2

  add_imwrite_plus_imread_plus_to_cv2()

  add_easy_resize_to_cv2()

  import cv2

  pic = cv2.imread_plus(r"https://raw.githubusercontent.com/hansalemaos/screenshots/main/splitted1.jpeg")

  pic1 = cv2.easy_resize_image(

      pic.copy(), width=200, height=None, percent=None, interpolation=cv2.INTER_AREA

  )

  pic2 = cv2.easy_resize_image(

      pic.copy(), width=None, height=200, percent=None, interpolation=cv2.INTER_AREA

  )

  pic3 = cv2.easy_resize_image(

      pic.copy(), width=100, height=200, percent=None, interpolation=cv2.INTER_AREA

  )

  pic4 = cv2.easy_resize_image(

      pic.copy(), width=None, height=None, percent=40, interpolation=cv2.INTER_AREA

  )

  pic5 = cv2.easy_resize_image(

      pic.copy(), width=None, height=None, percent=None, interpolation=cv2.INTER_AREA

  )  # returns original

  cv2.imwrite('f:\\papagei\\pic1.png', pic1)

  cv2.imwrite('f:\\papagei\\pic2.png', pic2)

  cv2.imwrite('f:\\papagei\\pic3.png', pic3)

  cv2.imwrite('f:\\papagei\\pic4.png', pic4)

  cv2.imwrite('f:\\papagei\\pic5.png', pic5)



  ```





  <img src="https://github.com/hansalemaos/screenshots/raw/main/pic1.png"/>





  <img src="https://github.com/hansalemaos/screenshots/raw/main/pic2.png"/>





  <img src="https://github.com/hansalemaos/screenshots/raw/main/pic3.png"/>





  <img src="https://github.com/hansalemaos/screenshots/raw/main/pic4.png"/>





  <img src="https://github.com/hansalemaos/screenshots/raw/main/pic5.png"/>


pkgId: 94002549632e5171f5050546fa94a94e92120532e6af30cef415bf110b387c95
name: python-a-pandas-ex-apply-ignore-exceptions
arch: src
version: 0.10
epoch: 0
release: 1
summary: Use DataFrame.apply / Series.apply with a default value for Exceptions
url: https://github.com/hansalemaos/a_pandas_ex_apply_ignore_exceptions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-pandas-ex-apply-ignore-exceptions-0.10-1.src.rpm
checksum_type: sha256
description:
  ```python

  pip install a-pandas-ex-apply-ignore-exceptions

  ```



  ```python



  from a_pandas_ex_apply_ignore_exceptions import pd_add_apply_ignore_exceptions

  import pandas as pd

  pd_add_apply_ignore_exceptions()

  df = pd.read_csv(

      "https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv"

  )





  df1 = df.PassengerId.ds_apply_ignore(pd.NA, lambda x: x / 3)

  df2 = df.ds_apply_ignore(pd.NA, lambda x: x["PassengerId"] / 3, axis=1)

  df3 = df.PassengerId.ds_apply_ignore(pd.NA, lambda x: x / 0)

  df4 = df.ds_apply_ignore(pd.NA, lambda x: x["PassengerId"] / 0, axis=1)

  print(df1)

  print(df2)

  print(df3)

  print(df4)





  r"""

  0        0.333333

  1        0.666667

  2        1.000000

  3        1.333333

  4        1.666667

            ...

  886    295.666667

  887    296.000000

  888    296.333333

  889    296.666667

  890    297.000000

  Name: PassengerId, Length: 891, dtype: float64

  0        0.333333

  1        0.666667

  2        1.000000

  3        1.333333

  4        1.666667

            ...

  886    295.666667

  887    296.000000

  888    296.333333

  889    296.666667

  890    297.000000

  Length: 891, dtype: float64

  0      <NA>

  1      <NA>

  2      <NA>

  3      <NA>

  4      <NA>

         ...

  886    <NA>

  887    <NA>

  888    <NA>

  889    <NA>

  890    <NA>

  Name: PassengerId, Length: 891, dtype: object

  0      <NA>

  1      <NA>

  2      <NA>

  3      <NA>

  4      <NA>

         ...

  886    <NA>

  887    <NA>

  888    <NA>

  889    <NA>

  890    <NA>

  Length: 891, dtype: object



  """





  ```


pkgId: 4f093d934ebdc566906fbfdc997330db08bc05149b7b75cd3f301389ad5949a0
name: python-a-pandas-ex-less-memory-more-speed
arch: src
version: 0.38
epoch: 0
release: 1
url: https://github.com/hansalemaos/a_pandas_ex_less_memory_more_speed
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-pandas-ex-less-memory-more-speed-0.38-1.src.rpm
checksum_type: sha256
summary:
  A Python package to reduce the memory usage of pandas DataFrames. It speeds up your workflow and reduces the risk of running out of memory.

description:
  df.PassengerId Is numeric!
  df.PassengerId Max: 891
  df.PassengerId Min: 1
  df.PassengerId: Only .000 in columns -> Using int - Checking which size fits best ...
  df.PassengerId: Using dtype: np.uint16
  â–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆâ–ˆ


pkgId: 7a3a4b931beab93dd1987c0ffd18c8f9041d03647f721f3caa2636e4678102ac
name: python-a-pandas-ex-plode-tool
arch: src
version: 0.44
epoch: 0
release: 1
summary: No more sleepless nights due to a nested dict, json, list or whatsoever
url: https://github.com/hansalemaos/a_pandas_ex_plode_tool
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-pandas-ex-plode-tool-0.44-1.src.rpm
checksum_type: sha256
description:
      df: pd.DataFrame
          DataFrame to convert
      groupby: str
          column whose values will be the top level keys
      subkeys: list
          columns wholse values will be the nested keys
      df = pd.read_csv(    "https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          Nested dict from DataFrame:
      df[:5].d_df_to_nested_dict(groupby='Survived', subkeys=['PassengerId', 'Age', 'Pclass', 'Name', 'Sex'])
      {0: {'PassengerId': {0: 1, 4: 5},
        'Age': {0: 22.0, 4: 35.0},
        'Pclass': {0: 3, 4: 3},
        'Name': {0: 'Braund, Mr. Owen Harris', 4: 'Allen, Mr. William Henry'},
        'Sex': {0: 'male', 4: 'male'}},
       1: {'PassengerId': {1: 2, 2: 3, 3: 4},
        'Age': {1: 38.0, 2: 26.0, 3: 35.0},
        'Pclass': {1: 1, 2: 3, 3: 1},
        'Name': {1: 'Cumings, Mrs. John Bradley (Florence Briggs Thayer)',
         2: 'Heikkinen, Miss. Laina',
         3: 'Futrelle, Mrs. Jacques Heath (Lily May Peel)'},
        'Sex': {1: 'female', 2: 'female', 3: 'female'}}}
      df[:5].d_df_to_nested_dict(groupby='Sex', subkeys=['PassengerId', 'Name'])
      Out[39]:
      {'male': {'PassengerId': {0: 1, 4: 5},
        'Name': {0: 'Braund, Mr. Owen Harris', 4: 'Allen, Mr. William Henry'}},
       'female': {'PassengerId': {1: 2, 2: 3, 3: 4},
        'Name': {1: 'Cumings, Mrs. John Bradley (Florence Briggs Thayer)',
         2: 'Heikkinen, Miss. Laina',
         3: 'Futrelle, Mrs. Jacques Heath (Lily May Peel)'}}}
  ```

  ```python
      explode_lists_and_tuples_in_column(df: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], column: Optional[str] = None, concat_with_df: bool = False) -> pandas.core.frame.DataFrame
          df = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                              'value': [1, 2, 3, 5]})
          getdi = lambda x: [    (randrange(1, 4), randrange(1, 4)) for v in range(randrange(1,5))]  #create some random tuples
          df["dicttest"] = df.lkey.apply(lambda x: getdi(x))
          print(df)
          df1=df.s_explode_lists_and_tuples(column='dicttest', concat_with_df=True)
          print(df1)
          df2=df.s_explode_lists_and_tuples(column='dicttest', concat_with_df=False)
          print(df2)
          df3=df.dicttest.s_explode_lists_and_tuples(column=None)
          print(df3)
            lkey  value                  dicttest
          0  foo      1                  [(3, 3)]
          1  bar      2  [(2, 3), (2, 1), (2, 2)]
          2  baz      3          [(2, 3), (2, 3)]
          3  foo      5                  [(1, 2)]
            lkey  value                  dicttest dicttest_0 dicttest_1 dicttest_2
          0  foo      1                  [(3, 3)]     (3, 3)       <NA>       <NA>
          1  bar      2  [(2, 3), (2, 1), (2, 2)]     (2, 3)     (2, 1)     (2, 2)
          2  baz      3          [(2, 3), (2, 3)]     (2, 3)     (2, 3)       <NA>
          3  foo      5                  [(1, 2)]     (1, 2)       <NA>       <NA>
            dicttest_0 dicttest_1 dicttest_2
          0     (3, 3)       <NA>       <NA>
          1     (2, 3)     (2, 1)     (2, 2)
          2     (2, 3)     (2, 3)       <NA>
          3     (1, 2)       <NA>       <NA>
            dicttest_0 dicttest_1 dicttest_2
          0     (3, 3)       <NA>       <NA>
          1     (2, 3)     (2, 1)     (2, 2)
          2     (2, 3)     (2, 3)       <NA>
          3     (1, 2)       <NA>       <NA>
              Parameters:
                  df: Union[pd.Series, pd.DataFrame]
                      pd.Series, pd.DataFrame with lists/tuples in cells
                  column: Union[str, None]
                      None can only be used if a pd.Series is passed. If a DataFrame is passed, a column needs to be passed too.
                  concat_with_df: bool
                      if True -> returns df + exploded Series as DataFrame
                      if False -> returns exploded Series as DataFrame
              Returns:
                  pd.DataFrame
                       Missing values are filled with pd.NA
  ```

  ```python
      flatten_all_iters_in_cells(df: pandas.core.series.Series) -> pandas.core.series.Series
          df = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                          'value': [1, 2, 3, 5]})
          getdi = lambda x: [    (randrange(1, 4), randrange(1, 4)) for v in range(20)]  #create some random tuples
          df["dicttest"] = df.lkey.apply(lambda x: getdi(x))
          print(df)
          df["dicttest"]=df.dicttest.s_flatten_all_iters_in_cells()
          print(df)
            lkey  value                                           dicttest
          0  foo      1  [(2, 2), (3, 3), (3, 2), (1, 3), (1, 2), (2, 2...
          1  bar      2  [(1, 1), (3, 1), (1, 3), (3, 2), (3, 1), (2, 2...
          2  baz      3  [(3, 1), (1, 1), (3, 3), (1, 3), (3, 2), (3, 3...
          3  foo      5  [(3, 3), (3, 3), (3, 2), (2, 3), (3, 3), (2, 3...
            lkey  value                                           dicttest
          0  foo      1  [2, 2, 3, 3, 3, 2, 1, 3, 1, 2, 2, 2, 1, 3, 1, ...
          1  bar      2  [1, 1, 3, 1, 1, 3, 3, 2, 3, 1, 2, 2, 3, 1, 3, ...
          2  baz      3  [3, 1, 1, 1, 3, 3, 1, 3, 3, 2, 3, 3, 1, 3, 1, ...
          3  foo      5  [3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 2, 3, 3, 3, 3, ...
              Parameters:
              df : pd.Series
                  Column with duplicates that are difficult to handle
              Returns:
                  pd.Series
  ```

  ```python
      make_several_columns_fit_in_one(df: pandas.core.frame.DataFrame, columns: list) -> list
          df = pd.read_csv(
          "https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv"
          )[:20]
          print(df)
          df['Ticket_Fare_Embarked'] = df.d_multiple_columns_to_one(columns=['Ticket','Fare', 'Embarked'])
              PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0             1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1             2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2             3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3             4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4             5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          5             6         0       3                                   Moran, Mr. James    male  ...      0            330877   8.4583   NaN         Q
          6             7         0       1                            McCarthy, Mr. Timothy J    male  ...      0             17463  51.8625   E46         S
          7             8         0       3                     Palsson, Master. Gosta Leonard    male  ...      1            349909  21.0750   NaN         S
          8             9         1       3  Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)  female  ...      2            347742  11.1333   NaN         S
          9            10         1       2                Nasser, Mrs. Nicholas (Adele Achem)  female  ...      0            237736  30.0708   NaN         C
          10           11         1       3                    Sandstrom, Miss. Marguerite Rut  female  ...      1           PP 9549  16.7000    G6         S
          11           12         1       1                           Bonnell, Miss. Elizabeth  female  ...      0            113783  26.5500  C103         S
          12           13         0       3                     Saundercock, Mr. William Henry    male  ...      0         A/5. 2151   8.0500   NaN         S
          13           14         0       3                        Andersson, Mr. Anders Johan    male  ...      5            347082  31.2750   NaN         S
          14           15         0       3               Vestrom, Miss. Hulda Amanda Adolfina  female  ...      0            350406   7.8542   NaN         S
          15           16         1       2                   Hewlett, Mrs. (Mary D Kingcome)   female  ...      0            248706  16.0000   NaN         S
          16           17         0       3                               Rice, Master. Eugene    male  ...      1            382652  29.1250   NaN         Q
          17           18         1       2                       Williams, Mr. Charles Eugene    male  ...      0            244373  13.0000   NaN         S
          18           19         0       3  Vander Planke, Mrs. Julius (Emelia Maria Vande...  female  ...      0            345763  18.0000   NaN         S
          19           20         1       3                            Masselmani, Mrs. Fatima  female  ...      0              2649   7.2250   NaN         C
          [20 rows x 12 columns]
          df
          Out[30]:
              PassengerId  Survived  Pclass                                               Name     Sex  ...            Ticket     Fare  Cabin Embarked          Ticket_Fare_Embarked
          0             1         0       3                            Braund, Mr. Owen Harris    male  ...         A/5 21171   7.2500    NaN        S          [A/5 21171, 7.25, S]
          1             2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...          PC 17599  71.2833    C85        C        [PC 17599, 71.2833, C]
          2             3         1       3                             Heikkinen, Miss. Laina  female  ...  STON/O2. 3101282   7.9250    NaN        S  [STON/O2. 3101282, 7.925, S]
          3             4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...            113803  53.1000   C123        S             [113803, 53.1, S]
          4             5         0       3                           Allen, Mr. William Henry    male  ...            373450   8.0500    NaN        S             [373450, 8.05, S]
          5             6         0       3                                   Moran, Mr. James    male  ...            330877   8.4583    NaN        Q           [330877, 8.4583, Q]
          6             7         0       1                            McCarthy, Mr. Timothy J    male  ...             17463  51.8625    E46        S           [17463, 51.8625, S]
          7             8         0       3                     Palsson, Master. Gosta Leonard    male  ...            349909  21.0750    NaN        S           [349909, 21.075, S]
          8             9         1       3  Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)  female  ...            347742  11.1333    NaN        S          [347742, 11.1333, S]
          9            10         1       2                Nasser, Mrs. Nicholas (Adele Achem)  female  ...            237736  30.0708    NaN        C          [237736, 30.0708, C]
          10           11         1       3                    Sandstrom, Miss. Marguerite Rut  female  ...           PP 9549  16.7000     G6        S            [PP 9549, 16.7, S]
          11           12         1       1                           Bonnell, Miss. Elizabeth  female  ...            113783  26.5500   C103        S            [113783, 26.55, S]
          12           13         0       3                     Saundercock, Mr. William Henry    male  ...         A/5. 2151   8.0500    NaN        S          [A/5. 2151, 8.05, S]
          13           14         0       3                        Andersson, Mr. Anders Johan    male  ...            347082  31.2750    NaN        S           [347082, 31.275, S]
          14           15         0       3               Vestrom, Miss. Hulda Amanda Adolfina  female  ...            350406   7.8542    NaN        S           [350406, 7.8542, S]
          15           16         1       2                   Hewlett, Mrs. (Mary D Kingcome)   female  ...            248706  16.0000    NaN        S             [248706, 16.0, S]
          16           17         0       3                               Rice, Master. Eugene    male  ...            382652  29.1250    NaN        Q           [382652, 29.125, Q]
          17           18         1       2                       Williams, Mr. Charles Eugene    male  ...            244373  13.0000    NaN        S             [244373, 13.0, S]
          18           19         0       3  Vander Planke, Mrs. Julius (Emelia Maria Vande...  female  ...            345763  18.0000    NaN        S             [345763, 18.0, S]
          19           20         1       3                            Masselmani, Mrs. Fatima  female  ...              2649   7.2250    NaN        C              [2649, 7.225, C]
          [20 rows x 13 columns]
              Parameters:
                  df: pd.DataFrame
                      DataFrame
                  columns: list
                      columns to squeeze
              Returns:
                  list
  ```

  ```python
      normalize_lists_in_column_end_user(df: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], column: Optional[str] = None) -> pandas.core.series.Series
          df = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                          'value': [1, 2, 3, 5]})
          getdi = lambda x: [    (randrange(1, 4), randrange(1, 4)) for v in range(randrange(1,5))]  #create some random tuples
          df["dicttest"] = df.lkey.apply(lambda x: getdi(x))
          print(df)
          df1=df.ds_normalize_lists(column='dicttest')
          print(df1)
          df2=df.dicttest.ds_normalize_lists(column='dicttest')
          print(df2)
            lkey  value          dicttest
          0  foo      1          [(3, 2)]
          1  bar      2          [(3, 1)]
          2  baz      3  [(3, 2), (3, 3)]
          3  foo      5  [(2, 3), (2, 1)]
          0      [(3, 2), <NA>]
          1      [(3, 1), <NA>]
          2    [(3, 2), (3, 3)]
          3    [(2, 3), (2, 1)]
          Name: dicttest, dtype: object
          0      [(3, 2), <NA>]
          1      [(3, 1), <NA>]
          2    [(3, 2), (3, 3)]
          3    [(2, 3), (2, 1)]
          Name: dicttest, dtype: object
              Parameters:
                  df: Union[pd.Series, pd.DataFrame]
                      pd.Series, pd.DataFrame with lists/tuples in cells
                  column: Union[str, None]
                      None can only be used if a pd.Series is passed. If a DataFrame is passed, a column needs to be passed too.
              Returns:
                  pd.DataFrame
                       Missing values are filled with pd.NA
  ```

  ```python
      qq_ds_merge_multiple_dfs_and_series_on_index(df: pandas.core.frame.DataFrame, list_with_ds: list[typing.Union[pandas.core.series.Series, pandas.core.frame.DataFrame]], how='inner', on=None, sort=False, suffixes=('_x', '_y'), indicator=False, validate=None) -> pandas.core.frame.DataFrame
          df1 = pd.DataFrame({'lkeyaaaaaaaaaaaaaaaaaa': ['foo', 'bar', 'baz', 'foo'],
                          'value': [1, 2, 3, 5]})
          df2 = pd.DataFrame({'lkeybbbbbbbbbb': ['foo', 'bar', 'baz', 'foo'],
                              'value': [5, 6, 7, 8]})
          df3 = pd.DataFrame({'lkeyccccccccccccccc': ['foo', 'bar', 'baz', 'foo'],
                              'value': [15, 16, 17, 18]})
          df4 = pd.DataFrame({'lkeyddddddddddddd': ['foo', 'bar', 'baz', 'foo'],
                              'value': [115, 116, 117, 118]})
          df5 = pd.DataFrame({'lkeyeeeee': ['foo', 'bar', 'baz', 'foo'],
                              'value': [1115, 1116, 1117, 1118]})
          df1.d_merge_multiple_dfs_and_series_on_index(list_with_ds=[df2,df3,df4,df5], how="outer")
          Out[85]:
            lkeyaaaaaaaaaaaaaaaaaa  value_x_000 lkeybbbbbbbbbb  value_y_000 lkeyccccccccccccccc  value_x_002 lkeyddddddddddddd  value_y_002 lkeyeeeee  value
          0                    foo            1            foo            5                 foo           15               foo          115       foo   1115
          1                    bar            2            bar            6                 bar           16               bar          116       bar   1116
          2                    baz            3            baz            7                 baz           17               baz          117       baz   1117
          3                    foo            5            foo            8                 foo           18               foo          118       foo   1118
              Parameters:
                  df : pd.DataFrame
                      DataFrame
                  list_with_ds: list[Union[pd.Series, pd.DataFrame]]
                      A list of DataFrames and Series you want to merge
                  how: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = "inner"  )
                  on: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = None  )
                  sort: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = False  )
                  suffixes: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = ("_x", "_y"))
                  indicator: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = False  )
                  validate: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = None  )
              Returns:
                  pd.DataFrame
  ```
  ```python
      qq_ds_merge_multiple_dfs_and_series_on_column(df: pandas.core.frame.DataFrame, list_with_ds: list[typing.Union[pandas.core.series.Series, pandas.core.frame.DataFrame]], column: str, how='inner', sort=False, suffixes=('_x', '_y'), indicator=False, validate=None) -> pandas.core.frame.DataFrame
          df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                          'value': [1, 2, 3, 5]})
          df2 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                              'value': [5, 6, 7, 8]})
          df3 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                              'value': [15, 16, 17, 18]})
          df4 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                              'value': [115, 116, 117, 118]})
          df5 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                              'value': [1115, 1116, 1117, 1118]})
          df1.d_merge_multiple_dfs_and_series_on_one_column(list_with_ds=[df2,df3,df4,df5],column='lkey',    how="outer",
              sort=False,
              suffixes=("_x", "_y"),
              indicator=False,
              validate=None,)
             lkey  value_x_000  value_y_000  value_x_002  value_y_002  value
          0   foo            1            5           15          115   1115
          1   foo            1            5           15          115   1118
          2   foo            1            5           15          118   1115
          3   foo            1            5           15          118   1118
          4   foo            1            5           18          115   1115
          5   foo            1            5           18          115   1118
          6   foo            1            5           18          118   1115
          7   foo            1            5           18          118   1118
          8   foo            1            8           15          115   1115
          9   foo            1            8           15          115   1118
          10  foo            1            8           15          118   1115
          11  foo            1            8           15          118   1118
          12  foo            1            8           18          115   1115
          13  foo            1            8           18          115   1118
          14  foo            1            8           18          118   1115
          15  foo            1            8           18          118   1118
          16  foo            5            5           15          115   1115
          17  foo            5            5           15          115   1118
          18  foo            5            5           15          118   1115
          19  foo            5            5           15          118   1118
          20  foo            5            5           18          115   1115
          21  foo            5            5           18          115   1118
          22  foo            5            5           18          118   1115
          23  foo            5            5           18          118   1118
          24  foo            5            8           15          115   1115
          25  foo            5            8           15          115   1118
          26  foo            5            8           15          118   1115
          27  foo            5            8           15          118   1118
          28  foo            5            8           18          115   1115
          29  foo            5            8           18          115   1118
          30  foo            5            8           18          118   1115
          31  foo            5            8           18          118   1118
          32  bar            2            6           16          116   1116
          33  baz            3            7           17          117   1117
              Parameters:
                  df:pd.DataFrame:
                      DataFrame
                  list_with_ds:list[Union[pd.Series, pd.DataFrame]]
                      A list of DataFrames and Series you want to merge
                  column:str
                      Column to merge on - has to be present in every df
                  how: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = "inner"  )
                  sort: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = False  )
                  suffixes: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = ("_x", "_y"))
                  indicator: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = False  )
                  validate: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html
                      (default = None  )
              Returns:
                  pd.DataFrame
  ```

  ```python
      series_as_flattened_list(df) -> list
          df = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'],
                          'value': [1, 2, 3, 5]})
          getdi = lambda x: [    (randrange(1, 4), randrange(1, 4)) for v in range(20)]  #create some random tuples
          df["dicttest"] = df.lkey.apply(lambda x: getdi(x))
          print(df)
          lkey  value                                           dicttest
          0  foo      1  [(3, 2), (3, 3), (3, 1), (1, 2), (2, 1), (3, 2...
          1  bar      2  [(1, 3), (3, 3), (1, 2), (3, 3), (2, 3), (1, 3...
          2  baz      3  [(1, 1), (1, 1), (3, 3), (1, 2), (1, 1), (2, 2...
          3  foo      5  [(2, 1), (2, 1), (1, 3), (1, 3), (3, 2), (2, 1...
          list_=df.dicttest.s_as_flattened_list()
          print(list_[:20])
          [3, 2, 3, 3, 3, 1, 1, 2, 2, 1, 3, 2, 2, 1, 1, 2, 3, 3, 2, 2]
              Parameters:
                  df: pd.Series
                      Series to flatten (removes all keys in dicts, only keeps the values)
              Returns:
                  list
  ```

  ```python
      unstacked_df_back_to_multiindex(dataframe: pandas.core.frame.DataFrame) -> pandas.core.frame.DataFrame
              Don't use df.stack()!!!!
          nested = {
          "Moli": {
              "Buy": 75,
              "Sell": 53,
              "Quantity": 300,
              "TF": True},
          "Anna": {
              "Buy": 55,
              "Sell": 83,
              "Quantity": 154,
              "TF": False},
          "Bob": {
              "Buy": 25,
              "Sell": 33,
              "Quantity": 100,
              "TF": False},
          "Annie": {
              "Buy": 74,
              "Sell": 83,
              "Quantity": 96,
              "TF": True}
          }
          df1=pd.Q_AnyNestedIterable_2df(nested, unstack=True)
          print(df1)
          df1.d_stack()
             level_0   level_1        aa_all_keys aa_value
          0     Anna       Buy        (Anna, Buy)       55
          1     Anna  Quantity   (Anna, Quantity)      154
          2     Anna      Sell       (Anna, Sell)       83
          3     Anna        TF         (Anna, TF)    False
          4    Annie       Buy       (Annie, Buy)       74
          5    Annie  Quantity  (Annie, Quantity)       96
          6    Annie      Sell      (Annie, Sell)       83
          7    Annie        TF        (Annie, TF)     True
          8      Bob       Buy         (Bob, Buy)       25
          9      Bob  Quantity    (Bob, Quantity)      100
          10     Bob      Sell        (Bob, Sell)       33
          11     Bob        TF          (Bob, TF)    False
          12    Moli       Buy        (Moli, Buy)       75
          13    Moli  Quantity   (Moli, Quantity)      300
          14    Moli      Sell       (Moli, Sell)       53
          15    Moli        TF         (Moli, TF)     True
          Out[64]:
                                  aa_all_keys aa_value
          level_0 level_1
          Anna    Buy             (Anna, Buy)       55
                  Quantity   (Anna, Quantity)      154
                  Sell           (Anna, Sell)       83
                  TF               (Anna, TF)    False
          Annie   Buy            (Annie, Buy)       74
                  Quantity  (Annie, Quantity)       96
                  Sell          (Annie, Sell)       83
                  TF              (Annie, TF)     True
          Bob     Buy              (Bob, Buy)       25
                  Quantity    (Bob, Quantity)      100
                  Sell            (Bob, Sell)       33
                  TF                (Bob, TF)    False
          Moli    Buy             (Moli, Buy)       75
                  Quantity   (Moli, Quantity)      300
                  Sell           (Moli, Sell)       53
                  TF               (Moli, TF)     True
              Parameters:
                  dataframe:pd.DataFrame
                      pd.DataFrame
              Returns:
                  pd.DataFrame
  ```

          There are plenty of good libraries out there that help you with finding the right encoding for your file,
          but sometimes they don't work like expected, and you have to choose the best encoding manually. This method
          opens any file in all encodings available in your env and returns all results in a DataFrame.
  ```python
          pd.Q_ReadFileWithAllEncodings_2df(r"C:\Users\Gamer\Documents\Downloads\corruptjson1.json")
                          codec                                     strict_encoded  \
          0           ascii  ['ascii' codec can't decode byte 0xef in posit...
          1    base64_codec                                [Incorrect padding]
          2            big5  [({\r\n"doc_id": "some_number",\r\n"url": "www...
          3       big5hkscs  [({\r\n"doc_id": "some_number",\r\n"url": "www...
          4       bz2_codec                              [Invalid data stream]
          115         utf_7  ['utf7' codec can't decode byte 0xef in positi...
          116         utf_8  [({\r\n"doc_id": "some_number",\r\n"url": "www...
          117     utf_8_sig  [({\r\n"doc_id": "some_number",\r\n"url": "www...
          118      uu_codec               [Missing "begin" line in input data]
          119    zlib_codec  [Error -3 while decompressing data: incorrect ...
               strict_bad                                     ignore_encoded  \
          0          True  [({\r\n"doc_id": "some_number",\r\n"url": "www...
          1          True                                                 []
              Parameters:
                  filepath (str): file path
              Returns:
                  pd.DataFrame
  ```

  ```python
      read_corrupt_json(filepath: str) -> dict
          Usage: pdQ_CorruptJsonFile_2dictf(r'C:\corruptjson1.json')
          If you need to read a corrupted JSON file, you can try this method.
          It will first try to read the file using ujson.
          Second step: The file will be read using all encoders found in your env. Each result will be passed to ast.literal_eval, json.loads and ujson.loads
          Third step: Keys and values are extracted using regex
          All positive results are returned as a dict, you have to check which one fits best to your needs
              finaldict = {
                  "ujson_file_reading_result": ujson_file_reading_result,
                  "literal_eval_after_newline_removed": literal_eval_after_newline_removed,
                  "json_after_head_tail_removed": json_after_head_tail_removed,
                  "ujson_after_head_tail_removed": ujson_after_head_tail_removed,
                  "regex_get_single_item_keys": allgoodresultsdict,
              }
          If the keys are not double-quoted, it won't work.
          It works well with spaces and not correctly escaped characters
          Example from https://stackoverflow.com/questions/59927549/how-to-fix-a-possibly-corrupted-json-file-problems-with-a-curly-bracket-charact
          {
          "doc_id": "some_number",
          "url": "www.seedurl1.com",
          "scrape_date": "2019-10-22 16:17:22",
          "publish_date": "unknown",
          "author": "unknown",
          "urls_out": [
          "https://www.something.com",
          "https://www.sometingelse.com/smth"
          ],
          "text": "lots of text here"
          }
          ﻿{
          "doc_id": "some_other_number",
          "url": "www.seedurl2.com/smth",
          "scrape_date": "2019-10-22 17:44:40",
          "publish_date": "unknown",
          "author": "unknown",
          "urls_out": [
          "www.anotherurl.com/smth",
          "http://urlx.com/smth.htm"
          ],
          "text": "lots more text over here."
          }
          Result:
          {'ujson_file_reading_result': None,
           'literal_eval_after_newline_removed': Empty DataFrame
           Columns: [level_0, level_1, level_2, aa_all_keys, aa_value, ast_results]
           Index: [],
           'json_after_head_tail_removed':       level_0  ...                                         json_loads
           862  punycode  ...  {'doc_id': 'some_number', 'url': 'www.seedurl1...
           865  punycode  ...  {'doc_id': 'some_number', 'url': 'www.seedurl1...
           [2 rows x 8 columns],
           'ujson_after_head_tail_removed':       level_0  ...                                        ujson_loads
           862  punycode  ...  {'doc_id': 'some_number', 'url': 'www.seedurl1...
           865  punycode  ...  {'doc_id': 'some_number', 'url': 'www.seedurl1...
           [2 rows x 9 columns],
           'regex_get_single_item_keys': [{'aa_value': {0: 'some_number',
              1: 'www.seedurl1.com',
              2: '2019-10-22 16:17:22',
              3: 'unknown',
              4: 'unknown',
              5: ['https://www.something.com', 'https://www.sometingelse.com/smth'],
              6: 'lots of text here'},
             'aa_key': {0: 'doc_id',
              1: 'url',
              2: 'scrape_date',
              3: 'publish_date',
              4: 'author',
              5: 'urls_out',
              6: 'text'}},
            {'aa_value': {7: 'some_other_number',
              8: 'www.seedurl2.com/smth',
              9: '2019-10-22 17:44:40',
              10: 'unknown',
              Parameters:
                  filepath (str): file path
              Returns:
                  dict
  ```

  ```python
      qq_d_sort_columns_alphabetically(df: pandas.core.frame.DataFrame, reverse: bool = False) -> pandas.core.frame.DataFrame
          Sorts columns alphabetically with sorted()! Not with natsort()!
          df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          print(df)
          df.d_sort_columns_with_sorted()
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...      0            211536  13.0000   NaN         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607  23.4500   NaN         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...      0            111369  30.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...      0            370376   7.7500   NaN         Q
          [891 rows x 12 columns]
          Out[66]:
                Age Cabin Embarked     Fare                                               Name  ...  Pclass     Sex  SibSp Survived            Ticket
          0    22.0   NaN        S   7.2500                            Braund, Mr. Owen Harris  ...       3    male      1        0         A/5 21171
          1    38.0   C85        C  71.2833  Cumings, Mrs. John Bradley (Florence Briggs Th...  ...       1  female      1        1          PC 17599
          2    26.0   NaN        S   7.9250                             Heikkinen, Miss. Laina  ...       3  female      0        1  STON/O2. 3101282
          3    35.0  C123        S  53.1000       Futrelle, Mrs. Jacques Heath (Lily May Peel)  ...       1  female      1        1            113803
          4    35.0   NaN        S   8.0500                           Allen, Mr. William Henry  ...       3    male      0        0            373450
          886  27.0   NaN        S  13.0000                              Montvila, Rev. Juozas  ...       2    male      0        0            211536
          887  19.0   B42        S  30.0000                       Graham, Miss. Margaret Edith  ...       1  female      0        1            112053
          888   NaN   NaN        S  23.4500           Johnston, Miss. Catherine Helen "Carrie"  ...       3  female      1        0        W./C. 6607
          889  26.0  C148        C  30.0000                              Behr, Mr. Karl Howell  ...       1    male      0        1            111369
          890  32.0   NaN        Q   7.7500                                Dooley, Mr. Patrick  ...       3    male      0        0            370376
          [891 rows x 12 columns]
              Parameters:
                  df : pd.DataFrame
                  reverse: bool
                      Z-A instead of A-Z (default = False)
              Returns:
                  pd.DataFrame
  ```

  ```python
      is_nan_true_false_check(df: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], include_na_strings: bool = True, include_empty_iters: bool = False, include_0_len_string: bool = False) -> Union[pandas.core.series.Series, pandas.core.frame.DataFrame]
          df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          df.ds_isna()
          Out[107]:
               PassengerId  Survived  Pclass   Name    Sex  ...  Parch  Ticket   Fare  Cabin  Embarked
          0          False     False   False  False  False  ...  False   False  False   True     False
          1          False     False   False  False  False  ...  False   False  False  False     False
          2          False     False   False  False  False  ...  False   False  False   True     False
          3          False     False   False  False  False  ...  False   False  False  False     False
          4          False     False   False  False  False  ...  False   False  False   True     False
          886        False     False   False  False  False  ...  False   False  False   True     False
          887        False     False   False  False  False  ...  False   False  False  False     False
          888        False     False   False  False  False  ...  False   False  False   True     False
          889        False     False   False  False  False  ...  False   False  False  False     False
          890        False     False   False  False  False  ...  False   False  False   True     False
          [891 rows x 12 columns]
          df.Cabin.ds_isna()
          Out[108]:
          0       True
          1      False
          2       True
          3      False
          4       True
          886     True
          887    False
          888     True
          889    False
          890     True
          Name: Cabin, Length: 891, dtype: bool
              Parameters:
                  df: Union[pd.Series, pd.DataFrame]
                      pd.Series, pd.DataFrame
                  include_na_strings: bool
                      When True -> treated as nan:
                      [
                      "<NA>",
                      "<NAN>",
                      "<nan>",
                      "np.nan",
                      "NoneType",
                      "None",
                      "-1.#IND",
                      "1.#QNAN",
                      "1.#IND",
                      "-1.#QNAN",
                      "#N/A N/A",
                      "#N/A",
                      "N/A",
                      "n/a",
                      "NA",
                      "#NA",
                      "NULL",
                      "null",
                      "NaN",
                      "-NaN",
                      "nan",
                      "-nan",
                      ]
                      (default =True)
                  include_empty_iters: bool
                      When True -> [], {} are treated as nan (default = False )
                  include_0_len_string: bool
                      When True -> '' is treated as nan (default = False )
                      Returns:
                  dict
              Returns:
                  Union[pd.Series, pd.DataFrame]
  ```

  ```python
      df_loc_add(df: pandas.core.frame.DataFrame, condition: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], add_to_colum: Any, column: str, throw_towel_early: bool = False, as_last_chance_convert_to_string: bool = False) -> pandas.core.frame.DataFrame
          df = pd.read_csv(
          "https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv"
          )
          print(df[:6])
          df[:6].d_add_value_to_existing_columns_with_loc(condition=(df.Pclass == 3), add_to_colum=100000, column="Fare")
             PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0            1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2            3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4            5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          5            6         0       3                                   Moran, Mr. James    male  ...      0            330877   8.4583   NaN         Q
          [6 rows x 12 columns]
          Out[37]:
             PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket         Fare Cabin  Embarked
          0            1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171  100007.2500   NaN         S
          1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599      71.2833   C85         C
          2            3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282  100007.9250   NaN         S
          3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803      53.1000  C123         S
          4            5         0       3                           Allen, Mr. William Henry    male  ...      0            373450  100008.0500   NaN         S
          5            6         0       3                                   Moran, Mr. James    male  ...      0            330877  100008.4583   NaN         Q
          [6 rows x 12 columns]
              Parameters:
                  df: pd.DataFrame
                      DataFrame to update
                  condition: Union[pd.Series, pd.DataFrame]
                      Pass a condition with df.loc: df.loc[df['shield'] > 6]
                  add_to_colum:: Any
                      Value that you want to add to old values
                  column: str
                      Column which should be updated
                  throw_towel_early: bool
                      If False: If there is an exception, will be iterating line by line changing each value.
                      If it fails, it will keep the old value. (default = False)
                  as_last_chance_convert_to_string: bool
                      If you want to change the value at any cost, you can change both values to strings and add them up, which will result in:
                      1+1 = "11"
                      "Big" + "Brother" = "BigBrother"
              Returns:
                  pd.DataFrame
  ```

  ```python
      df_loc_drop(df: pandas.core.frame.DataFrame, condition: Union[pandas.core.series.Series, pandas.core.frame.DataFrame]) -> pandas.core.frame.DataFrame
          df.d_drop_rows_with_df_loc(df.level_1.str.contains("aa_k")) is the same as df.loc[~df.level_1.str.contains('aa_k')].copy()
          df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          df
          Out[54]:
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...      0            211536  13.0000   NaN         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607  23.4500   NaN         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...      0            111369  30.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...      0            370376   7.7500   NaN         Q
          [891 rows x 12 columns]
          df.d_drop_rows_with_df_loc(df.Sex.str.contains(r"male$", regex=True, na=False))
          Out[55]:
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          8              9         1       3  Johnson, Mrs. Oscar W (Elisabeth Vilhelmina Berg)  female  ...      2            347742  11.1333   NaN         S
          9             10         1       2                Nasser, Mrs. Nicholas (Adele Achem)  female  ...      0            237736  30.0708   NaN         C
          880          881         1       2       Shelley, Mrs. William (Imanita Parrish Hall)  female  ...      1            230433  26.0000   NaN         S
          882          883         0       3                       Dahlberg, Miss. Gerda Ulrika  female  ...      0              7552  10.5167   NaN         S
          885          886         0       3               Rice, Mrs. William (Margaret Norton)  female  ...      5            382652  29.1250   NaN         Q
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607  23.4500   NaN         S
          [314 rows x 12 columns]
              Parameters:
                  df: pd.DataFrame
                      DataFrame
                  condition: Union[pd.Series, pd.DataFrame]
                      Condition with df.loc: df.loc[df['shield'] > 6]
              Returns:
                  pd.DataFrame
  ```

  ```python
      df_loc_set(df: pandas.core.frame.DataFrame, condition: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], new_data: Any, column: str) -> pandas.core.frame.DataFrame
          df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          df
          Out[51]:
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...      0            211536  13.0000   NaN         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607  23.4500   NaN         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...      0            111369  30.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...      0            370376   7.7500   NaN         Q
          [891 rows x 12 columns]
          df.d_set_values_with_df_loc(condition = df.Sex.str.contains(r"male$", regex=True, na=False),column = 'Fare',new_data = 100000)
          Out[52]:
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket         Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171  100000.0000   NaN         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599      71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282       7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803      53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...      0            373450  100000.0000   NaN         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...      0            211536  100000.0000   NaN         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053      30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607      23.4500   NaN         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...      0            111369  100000.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...      0            370376  100000.0000   NaN         Q
          [891 rows x 12 columns]
              Parameters:
                  df: pd.Dataframe
                      DataFrame
                  condition: Union[pd.Series, pd.DataFrame]
                      Pass a condition with df.loc: df.loc[df['shield'] > 6]
                  new_data: Any
                      New values for update
                  column: str
                      Column which should be updated
              Returns:
                  pd.DataFrame
  ```

  ```python
      df_loc(df: pandas.core.frame.DataFrame, condition: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], column: Optional[str] = None) -> Union[pandas.core.series.Series, pandas.core.frame.DataFrame]
          df.d_dfloc(df.aa_value.str.contains("author")) is the same as df.loc[df.aa_value.str.contains('author')].copy()
          df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          print(df)
          print(df.d_dfloc(df.Sex.str.contains(r"male$", regex=True, na=False)))
          df.d_dfloc(df.Sex.str.contains(r"male$", regex=True, na=False),column='Name')
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...      0            211536  13.0000   NaN         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607  23.4500   NaN         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...      0            111369  30.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...      0            370376   7.7500   NaN         Q
          [891 rows x 12 columns]
               PassengerId  Survived  Pclass                            Name   Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3         Braund, Mr. Owen Harris  male  ...      0         A/5 21171   7.2500   NaN         S
          4              5         0       3        Allen, Mr. William Henry  male  ...      0            373450   8.0500   NaN         S
          5              6         0       3                Moran, Mr. James  male  ...      0            330877   8.4583   NaN         Q
          6              7         0       1         McCarthy, Mr. Timothy J  male  ...      0             17463  51.8625   E46         S
          7              8         0       3  Palsson, Master. Gosta Leonard  male  ...      1            349909  21.0750   NaN         S
          883          884         0       2   Banfield, Mr. Frederick James  male  ...      0  C.A./SOTON 34068  10.5000   NaN         S
          884          885         0       3          Sutehall, Mr. Henry Jr  male  ...      0   SOTON/OQ 392076   7.0500   NaN         S
          886          887         0       2           Montvila, Rev. Juozas  male  ...      0            211536  13.0000   NaN         S
          889          890         1       1           Behr, Mr. Karl Howell  male  ...      0            111369  30.0000  C148         C
          890          891         0       3             Dooley, Mr. Patrick  male  ...      0            370376   7.7500   NaN         Q
          [577 rows x 12 columns]
          Out[60]:
          0             Braund, Mr. Owen Harris
          4            Allen, Mr. William Henry
          5                    Moran, Mr. James
          6             McCarthy, Mr. Timothy J
          7      Palsson, Master. Gosta Leonard
          883     Banfield, Mr. Frederick James
          884            Sutehall, Mr. Henry Jr
          886             Montvila, Rev. Juozas
          889             Behr, Mr. Karl Howell
          890               Dooley, Mr. Patrick
          Name: Name, Length: 577, dtype: object
              Parameters:
                  df: pd.DataFrame
                      DataFrame
                  condition: Union[pd.Series, pd.DataFrame]
                      Pass a condition with df.loc: df.loc[df['shield'] > 6]
                  column: Union[None, str]
                      if a string is passed, the method will return pd.Series
                      None will return the whole DataFrame (default = None )
              Returns:
                  Union[pd.Series, pd.DataFrame]
  ```

  ```python
      all_nans_in_df_to_pdNA(df: Union[pandas.core.series.Series, pandas.core.frame.DataFrame], include_na_strings: bool = True, include_empty_iters: bool = False, include_0_len_string: bool = False) -> Union[pandas.core.series.Series, pandas.core.frame.DataFrame]
          df = pd.read_csv("https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv")
          df
          Out[86]:
               PassengerId  Survived  Pclass                                               Name     Sex  ...  Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...      0         A/5 21171   7.2500   NaN         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...      0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...      0  STON/O2. 3101282   7.9250   NaN         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...      0            113803  53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...      0            373450   8.0500   NaN         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...      0            211536  13.0000   NaN         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...      0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...      2        W./C. 6607  23.4500   NaN         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...      0            111369  30.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...      0            370376   7.7500   NaN         Q
          [891 rows x 12 columns]
          df.ds_all_nans_to_pdNA()
          Out[87]:
               PassengerId  Survived  Pclass                                               Name     Sex  ... Parch            Ticket     Fare Cabin  Embarked
          0              1         0       3                            Braund, Mr. Owen Harris    male  ...     0         A/5 21171   7.2500  <NA>         S
          1              2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  ...     0          PC 17599  71.2833   C85         C
          2              3         1       3                             Heikkinen, Miss. Laina  female  ...     0  STON/O2. 3101282   7.9250  <NA>         S
          3              4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  ...     0            113803  53.1000  C123         S
          4              5         0       3                           Allen, Mr. William Henry    male  ...     0            373450   8.0500  <NA>         S
          886          887         0       2                              Montvila, Rev. Juozas    male  ...     0            211536  13.0000  <NA>         S
          887          888         1       1                       Graham, Miss. Margaret Edith  female  ...     0            112053  30.0000   B42         S
          888          889         0       3           Johnston, Miss. Catherine Helen "Carrie"  female  ...     2        W./C. 6607  23.4500  <NA>         S
          889          890         1       1                              Behr, Mr. Karl Howell    male  ...     0            111369  30.0000  C148         C
          890          891         0       3                                Dooley, Mr. Patrick    male  ...     0            370376   7.7500  <NA>         Q
          [891 rows x 12 columns]
          df.Cabin.ds_all_nans_to_pdNA()
          Out[88]:
          0      <NA>
          1       C85
          2      <NA>
          3      C123
          4      <NA>
          886    <NA>
          887     B42
          888    <NA>
          889    C148
          890    <NA>
          Name: Cabin, Length: 891, dtype: object
              Parameters:
                  df: Union[pd.Series, pd.DataFrame]
                      pd.Series, pd.DataFrame
                  include_na_strings: bool
                      When True -> treated as nan:
                      [
                      "<NA>",
                      "<NAN>",
                      "<nan>",
                      "np.nan",
                      "NoneType",
                      "None",
                      "-1.#IND",
                      "1.#QNAN",
                      "1.#IND",
                      "-1.#QNAN",
                      "#N/A N/A",
                      "#N/A",
                      "N/A",
                      "n/a",
                      "NA",
                      "#NA",
                      "NULL",
                      "null",
                      "NaN",
                      "-NaN",
                      "nan",
                      "-nan",
                      ]
                      (default =True)
                  include_empty_iters: bool
                      When True -> [], {} are treated as nan (default = False )
                  include_0_len_string: bool
                      When True -> '' is treated as nan (default = False )
                      Returns:
                  dict
              Returns:
                  Union[pd.Series, pd.DataFrame]
  ```


pkgId: bae2cb0e462ce8983befa3f1c4d87713be8e91d85dc392f0e87b87f87f04ab53
name: python-a-world-of-countries
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/lucagrandicelli/a-world-of-countries-py
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a-world-of-countries-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  A World of Countries (AWOC) is a fully-featured library that provides an easy layer to access mutiple data about world continents and countries, according to the ISO Standard 3166-1.

description:
  ![](images/awoc-cover.jpg)
  A World of Countries (AWOC) is a fully-featured library that provides an easy layer to access mutiple data about world continents and countries, according to the ISO Standard 3166-1.

  **Note:** A NodeJS version of this library is available [here](https://github.com/lucagrandicelli/a-world-of-countries/)



  ```
  $ pip install a-world-of-countries
  ```



  ```python

  import awoc


  my_world = awoc.AWOC()


  countries_of_europe = my_world.get_countries_list_of('Europe')



  italy_data = my_world.get_country_data('Italy')
  """
  Returns:
  {
    'Country Name': 'Italy',
    ISO2: 'IT',
    ISO3: 'ITA',
    TLD: 'it',
    FIPS: 'IT',
    'ISO Numeric': '380',
    GeoNameID: '3175395',
    E164: '39',
    'Phone Code': '39',
    'Continent Name': 'Europe',
    'Continent Code': 'eu',
    Capital: 'Rome',
    'Time Zone in Capital': 'Europe/Rome',
    'Currency Name': 'Euro',
    Languages:
     'Italian (official), German (parts of Trentino-Alto Adige region are predominantly German-speaking), French (small French-speaking minority in Valle d\'Aosta region), Slovene (Slovene-speaking minority in the Trieste-Gorizia area)',
    'Area KM2': '301230'
  }
  """
  ```



  A World of Countries is a library based upon a world.json file which holds all the continents and countries informations we need. The file is ntly evolving and this library, encoded in the form of a JS class, exposes a list of methods you can use to access those data without the hassle of writing data extraction code.

  In the `data/world.json` (known as Global World Data Object, GWDO) file, every country is encoded as an object /w the following properties:

  - **Country Name** - Full name of the country. E.g. "Italy".
  - **ISO2** - ISO2/3166-1 alpha-2 country code. E.g. "IT"
  - **ISO3** - ISO2/3166-1 alpha-2 country code. E.g. "ITA"
  - **TLD** - Top Level Domain code. E.g. "it"
  - **FIPS** - Federal Information Processing Standards (FIPS) code. E.g. "IT"
  - **ISO Numeric** - ISO 3166-1 numeric code. E.g. "380"
  - **GeoNameID** - GEO Name ID. E.g. "3175395"
  - **E164** - International Public Telecommunication Numbering Plan Code. E.g. "39"
  - **Phone Code**- Country phone code. E.g. "39"
  - **Continent Name** - Full name of the continent the country belongs to. E.g. "Europe"
  - **Continent Code** - Continent code the country belongs to. E.g. "eu"
  - **Capital** - Country capital city. E.g. "Rome"
  - **Time Zone in Capital** - Full definition of the country time zone. E.g. "Europe/Rome"
  - **Currency Name** - Full currency name. E.g. "Euro"
  - **Languages** - A verbose list of spoken languages. E.g. "Italian (official), German (parts of Trentino-Alto Adige region are predominantly German-speaking), French (small French-speaking minority in Valle d'Aosta region), Slovene (Slovene-speaking minority in the Trieste-Gorizia area)"
  - **Area KM2** - Geographic extension area in km2/mi2. E.g. "301230"



  The whole library code is heavily commented, so every class property or method exposes a verbose explanation of its purpose. Feel free to inspect the code and find you preferred method of work. The following is the updated list of all AWOC available methods.



  _List of all AWOC.js methods about world continents._



  **Description**: returns a list of continent names as strings.

  ```python

  continents_list = my_world.get_continents_list()

  ```



  **Description**: returns a list of continent objects.

  ```python

  continents_data = my_world.get_continents()
  """
   Returns:
   [
    { 'Continent Code': 'af', 'Continent Name': 'Africa' },
    { 'Continent Code': 'an', 'Continent Name': 'Antarctica' },
    { 'Continent Code': 'as', 'Continent Name': 'Asia' },
    { 'Continent Code': 'eu', 'Continent Name': 'Europe' },
    { 'Continent Code': 'na', 'Continent Name': 'North America' },
    { 'Continent Code': 'oc', 'Continent Name': 'Oceania' },
    { 'Continent Code': 'sa', 'Continent Name': 'South America' }
   ]
  """
  ```





  **Description**: This method extracts all the countries data from the GWOD. It performs an additional sort by country name to ensure the correct alphabetical order, regardless of the GWOD json objects order (which might fail).

  ```python

  countries = my_world.get_countries()
  """
   Returns the full list of country objects.
   [...
   { 'Country Name': 'Cocos Islands', ISO2: 'CC', ISO3: 'CCK', TLD: 'cc', .. },
   { 'Country Name': 'Colombia', ISO2: 'CO', ISO3: 'COL', TLD: 'co', ... },
   ... ]
  """
  ```



  **Description**: this method returns a single country object data. If a `field` parameter is specified, then the method will return its value. For a list of available fields, please check the country data structure above.

  ```python

  capital_of_spain = my_world.get_country_data('Spain', 'Capital')



  spain_data = my_world.get_country_data('Spain')

  ```



  **Description**: this method returns a list of country names sorted alphabetically.

  ```python

  get_countries_list = my_world.get_countries_list()

  ```



  **Description**: this method returns a list of country names sorted alphabetically for a specific continent.

  ```python

  nations_of_europe = my_world.get_countries_list_of('Europe')

  ```



  **Description**: this method returns a list of country objects alphabetically sorted per each country name for a specific continent.

  ```python

  nations_of_europe = my_world.get_countries_data_of('Europe')
  """
   Returns:
   [
    { 'Country Name': 'Albania', ISO2: 'AL', ISO3: 'ALB', ... },
    { 'Country Name': 'Andorra', ISO2: 'AD', ISO3: 'AND', ... }
   ]
  """
  ```



  **Description**: this method returns the ISO2 code for the specified country.

  ```python
  italy_ISO2 = my_world.get_country_ISO2('Italy')

  ```



  **Description**: this method returns the ISO3 code for the specified country.

  ```python
  italy_ISO3 = my_world.get_country_ISO3('Italy')

  ```



  **Description**: this method returns the Top Level Domain (TLD) for the specified country.

  ```python
  italy_TLD = my_world.get_country_TLD('Italy')

  ```



  **Description**: this method returns the FIPS country code for the specified country.

  ```python
  italy_FIPS = my_world.get_country_FIPS('Italy')

  ```



  **Description**: this method returns the ISO Numeric code for the specified country.

  ```python
  italy_ISO_numeric = my_world.get_country_ISO_numeric('Italy')

  ```



  **Description**: this method returns the GEO Name ID for the specified country.

  ```python
  italy_GEO_name_ID = my_world.get_country_geo_name_ID('Italy')

  ```



  **Description**: this method returns the E164 code for the specified country.

  ```python
  italy_E164 = my_world.get_country_E164('Italy')

  ```



  **Description**: this method returns the Phone Code for the specified country.

  ```python
  italy_phone_code = my_world.get_country_phone_code('Italy')

  ```



  **Description**: this method returns the continent data the specified country belongs to.

  ```python
  italy_continent_name = my_world.get_country_continent_name('Italy')

  ```



  **Description**: this method returns the continent code the specified country belongs to.

  ```python
  italy_continent_code = my_world.get_country_continent_code('Italy')

  ```



  **Description**: this method returns the capital city of the specified country.

  ```python
  capital_of_italy = my_world.get_country_capital_city('Italy')

  ```



  **Description**: this method returns a time zone value for the specific country.

  ```python
  italy_time_zone = my_world.get_country_time_zone('Italy')

  ```



  **Description**: this method returns the currency name for the specified country.

  ```python
  italy_currency_name = my_world.get_country_currency_name('Italy')

  ```



  **Description**: this method returns a list of country names filtered by a specific currency.

  ```python

  dollar_nations = my_world.get_countries_list_by_currency('Dollar')



  dollar_nations_in_south_america = my_world.get_countries_list_by_currency(
    'Dollar',
    'South America'
  )

  ```



  **Description**: this method returns one or multiple country object data for a specific currency.

  ```python

  dollar_nations_obj = my_world.get_countries_data_by_currency('Dollar')
  """
   Returns:
   [...
    { 'Country Name': 'American Samoa', ISO2: 'AS', ISO3: 'ASM', TLD: 'as', FIPS: 'AQ', ... },
    { 'Country Name': 'Anguilla', ISO2: 'AI', ISO3: 'AIA', TLD: 'ai', FIPS: 'AV', ... },
   ...]
  """


  dollar_nations_in_south_americaObj = my_world.get_countries_data_by_currency(
    'Dollar',
    'South America'
  )
  """
   Returns:
   [
     { 'Country Name': 'Ecuador', ISO2: 'EC', ISO3: 'ECU', TLD: 'ec', FIPS: 'EC', ... },
     { 'Country Name': 'Guyana',  ISO2: 'GY', ISO3: 'GUY', TLD: 'gy', FIPS: 'GY', ... },
     { 'Country Name': 'Suriname', ISO2: 'SR', ISO3: 'SUR', TLD: 'sr', FIPS: 'NS', ... }
   ]
   """
  ```



  **Description**: this method returns a list of languages for the specific country.

  ```python
  italy_language_codes = my_world.get_country_languages('Italy')

  ```



  **Description**: this method returns the country area in km2 or mi2.

  ```python

  italy_extension_area_km2 = my_world.get_country_area('Italy')



  italy_extension_area_mi2 = my_world.get_country_area('Italy', 'mi2')

  ```





  Initial release.



  [MIT](https:#github.com/lucagrandicelli/a-world-of-countries-py/blob/master/LICENSE)



  - Cover image by [freepik](https:#it.freepik.com/foto-vettori-gratuito/viaggio).


pkgId: 9920e702a4a03c1391b987a741d71318468de94b026a14d5ac0a18b93d335ddd
name: python-a0_baas_sdk
arch: src
version: 0.1.0a12
epoch: 0
release: 1
summary: baas sdk for a0 project
url: https://pypi.org/project/a0_baas_sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a0_baas_sdk-0.1.0a12-1.src.rpm
checksum_type: sha256
description:
  For baas usage please refer to the following link:
  ...

  urllib3 and requests are used in this project.


pkgId: 4f4f04a410b91c82699340a79ddebac545a0395235a5ed828103f8544a35b14c
name: python-a10-neutron-lbaas
arch: src
version: 1.8.1
epoch: 0
release: 1
summary: A10 Networks Openstack LBaaS Driver Middleware
url: https://github.com/a10networks/a10-neutron-lbaas
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a10-neutron-lbaas-1.8.1-1.src.rpm
checksum_type: sha256
description:
  A10 Networks LBaaS Driver for Thunder, vThunder and AX Series Appliances
  Supported releases:
  * OpenStack: Liberty through current release.
  * LBaaS versions: v2
  * ACOS versions: ACOS 2/AxAPI 2.1 (ACOS 2.7.2+), ACOS 4/AxAPI 3.0 (ACOS 4.0.1-GA +)
  Working but not available for support:
  * OpenStack: git/master
  Unsupported, but may work with minor tweaking:
  * OpenStack: v1 on any release, v2 Havana through Kilo

  - [a10-neutron-lbaas](https://github.com/a10networks/a10-neutron-lbaas) - Main A10 LBaaS driver repo. Middleware sitting between the
  openstack driver and our API client, mapping openstack constructs to A10's AxAPI.
  - [acos-client](https://github.com/a10networks/acos-client) - AxAPI client used by A10's OpenStack driver
  - [a10-openstack-lbaas](https://github.com/a10networks/a10-openstack-lbaas) - OpenStack LBaaS driver,
  identical to the files that are currently merged into neutron-lbaas.  Pypi package
  'a10-openstack-lbaas'.
  - [a10-openstack-lbaas, havana branch](https://github.com/a10networks/a10-openstack-lbaas/tree/havana) - OpenStack
  LBaaS driver, for the Havana release.  Pypi package 'a10-openstack-lbaas-havana'.
  - [a10networks-ci/project-config](https://github.com/a10networks-ci/project-config) - A10 Networks OpenStack third-party CI setup scripts

  ![image2](https://cloud.githubusercontent.com/assets/1424573/2849597/47192238-d0df-11e3-9e1e-9e234be58412.png)


  Make sure you have neutron installed, and neutron-lbaas if applicable. This
  driver will need to be installed on all of your neutron controller nodes
  (anywhere that neutron-server is running.)

  The latest supported version of a10-neutron-lbaas is available via standard pypi repositories and the current development version is available on github.

  ```sh
  sudo pip install a10-neutron-lbaas
  ```

  Download the driver from: <https://github.com/a10networks/a10-neutron-lbaas>
  ![screen shot 2016-03-22 at 4 41 04 pm](https://cloud.githubusercontent.com/assets/603553/13970211/ee35777c-f04c-11e5-9cd2-7c4dd8a66a3a.png)
  ```sh
  sudo pip install git+https://github.com/a10networks/a10-neutron-lbaas.git
  ```
  ```sh
  git clone https://github.com/a10networks/a10-neutron-lbaas.git
  cd a10-neutron-lbaas
  sudo pip install -e .
  ```

  Post-installation configuration requires modification of your neutron.conf or neutron_lbaas.conf (neutron_lbaas.conf is only present in LBaaSv2) typically located in `/etc/neutron`.

  Open `/etc/neutron/neutron.conf` in your preferred text editor.
  Under the `service_plugins` setting, ensure `lbaas` or `lbaasv2` is listed depending on your configuration.
  In the list of `service_provider` settings, add a service provider for A10
  Networks:
  `service_provider = LOADBALANCER:A10Networks:neutron_lbaas.services.loadbalancer.drivers.a10networks.driver_v1.ThunderDriver:default`
  Save and close neutron.conf

  Open `/etc/neutron/neutron.conf` in your preferred text editor.
  Under the `service_plugins` setting, ensure `lbaasv2` is listed.
  Save and close neutron.conf.
  Open `/etc/neutron/neutron_lbaas.conf` in your preferred text editor.
  In the list of `service_provider` settings, add a service provider for A10
  Networks:
  `service_provider = LOADBALANCERV2:A10Networks:neutron_lbaas.drivers.a10networks.driver_v2.ThunderDriver:default`

  Open `/etc/neutron/neutron.conf` in your preferred text editor.
  Under the `service_plugins` setting, ensure `a10_neutron_lbaas.neutron_ext.services.a10_device_instance.plugin.A10DeviceInstancePlugin` is listed. The `service_plugins` are separated by `,`s.
  Under the `api_extensions_path` setting, ensure the path to `a10_neutron_lbaas.neutron_ext.extensions` is listed. The `api_extensions_path`s are separated by `:`s. You can find the path of the installed extension by running `python -c "import os; import a10_neutron_lbaas.neutron_ext.extensions as m; print(os.path.dirname(os.path.abspath(m.__file__)))"`.

  After installation, you will need to provide configuration for the driver so the driver is aware of the appliances you have configured.  The configuration is a python file stored in `/etc/a10/config.py`.  Below is a sample to show options and formatting, though any legal python can be used to calculate values or define classes:
  ```python
  devices = {
      "ax1": {
          "name": "ax1",
          "host": "10.10.100.20",
          "port": 443,
          "username": "admin",
          "password": "a10",
          "autosnat": True,
          "api_version": "3.0",
      }
  }
  ```

  A10's LBaaS driver supports a default scheduling strategy of "one appliance per tenant".  Below is a sample configuration (stored in `/etc/a10/config.py`):
  ```python
  vthunder = {
      'username': 'admin',
      'password': 'a10',
      'api_version': '3.0',
      'nova_flavor': 'acos.min',
      'glance_image': 'c2722746-0c06-48b1-93c3-a9dbc2f6e628',
      'vthunder_tenant_name': 'admina',
      'vthunder_tenant_username': 'admina',
      'vthunder_tenant_password': 'password',
      'vthunder_management_network': 'private',
      'vthunder_data_networks': ['vipnet', 'membernet']
  }
  ```

  The administrator username on your vThunder appliance image.

  The administrator password on your vThunder appliance image.

  The AXAPI version utilized to access vThunder appliances.  This is dependent on your vThunder appliance image version:
  * 2.7.x - `"2.1"`
  * 4.x.x - `"3.0"`

  The name of the nova flavor used to construct vThunder device instances.  The minimum requirements are dependent on your vThunder appliance image version:

  * CPU: 1 VCPU
  * RAM: 2GB
  * Storage: 12GB

  * CPU: 1 VCPU
  * RAM: 4GB
  * Storage: 12GB

  The Glance or Nova image ID of your vThunder appliance image.  This can be obtained through Horizon or the Openstack CLI.

  The name of the service tenant where vThunder appliance instances will be created.

  The Openstack user login name which has access to the above-named service tenant.

  The Openstack password of the above-mentioned login.

  The Openstack network name or ID that the vThunder management interface will be connected to.

  A list of Openstack network names or IDs that the vThunder data interfaces will be connected to.  A minimum of one is required.
  For complete documentation of the a10 config.py file, please refer to the [sample config file](https://github.com/a10networks/a10-neutron-lbaas/blob/master/a10_neutron_lbaas/etc/config.py).


  The ip address or host name of the A10 appliance. For a virtual chassis configuration, this should be the floating host or ip address of the master.

  Port that the AXAPI is exposed on

  Authentication credentials to control the A10 appliance via the AXAPI.

  Version of the A10 appliance's AXAPI. `"2.1"` for 2.X series ACOS versions,
  `"3.0"` for 4.X versions.

  The A10 vThunder virtual load balancing appliance has a flexible system for licensing.  Below is a sample configuration for license management (stored in `/etc/a10/config.py`):
  ```python
  license_manager = {
          "hosts": [
                  {"ip": "pdx.a10cloud.com", "port": 443},
                  {"ip": "sfo.a10cloud.com", "port": 443},
                  {"ip": "iad.a10cloud.com", "port": 443}
          ],
          "serial": "SN0123456789ABCDEF",
          "instance-name": "SCALING_INSTANCE",
          "bandwidth-base": 100,
          "interval": 3,
          "use-mgmt-port": True
  }
  ```

  A list of host entries specifying the IP address or hostname and TCP port of licensing servers.

  The serial number used for your vThunder appliances

  The instance name attached to the license.

  The feature's bandwidth base measured in megabytes.

  The feature's bandwidth allowance interval.
  * 1 - Monthly
  * 2 - Daily
  * 3 - Hourly

  The appliance will use the management port for communicating with the licensing server if set to True.  By default, the appliance will use the use the first available interface for license server operations.
  More details about A10 Licensing can be found at `TODO(Add licensing info url)`.

  If 'use_database' is enabled, after installing the package and after any
  upgrades, run:
  ```
  a10-manage upgrade
  ```

  Restart neutron after configuration updates (exact command may vary depending
    on OpenStack packaging.)
  ```sh
  service neutron-server restart
  ```

  You must configure the network elements of the Thunder appliance for OpenStack.

  ![image3](https://cloud.githubusercontent.com/assets/1424573/2849593/4708b7ea-d0df-11e3-8ed7-f6bf73b31535.png)

  ![image4](https://cloud.githubusercontent.com/assets/1424573/2849595/471863d4-d0df-11e3-87c7-2423aaaaedca.png)


  Login to the OpenStack dashboard.
  ![image7](https://cloud.githubusercontent.com/assets/1424573/2849592/46f86d4a-d0df-11e3-8b57-25d2d796f1cc.png)

  Under the “Network” menu, go to the “Load Balancers” tab and select “Add Pool”:
  ![image8](https://cloud.githubusercontent.com/assets/1424573/2849594/47169bda-d0df-11e3-9fda-af2da76cdb00.png)
  Once you have added a pool, a success message should appear.
  ![image9](https://cloud.githubusercontent.com/assets/1424573/2849599/471a7c14-d0df-11e3-918e-778dbea9be45.png)

  Login to the GUI on your Thunder or AX device, and validate which configuration was applied if the ADPs are set. The ADP name is the first 13 characters of the tenant ID.
  ![image10](https://cloud.githubusercontent.com/assets/1424573/2849596/4718b0b4-d0df-11e3-9a6b-506bb832dcce.png)
  _Repeat this for all configuration steps, then delete all resources if ADPs are configured. They should be deleted when the tenant has no more resources configured._

  See [name-based config example](https://github.com/a10networks/a10-neutron-lbaas/tree/master/a10_neutron_lbaas/etc) for details.

  See [CHANGELOG](https://github.com/a10networks/a10-neutron-lbaas/tree/master/CHANGELOG) for changes made. NOTE: We didn't have a changelog until 1.6.5

  Feel free to fork, submit pull requests, or join us on freenode IRC, channel #a10-openstack. Serious support escalations and formal feature requests must
  still go through standard A10 processes.

  1. Fork it
  2. Create your feature branch (`git checkout -b my-new-feature`)
  3. Commit your changes (`git commit -am 'Add some feature'`)
  4. Push to the branch (`git push origin my-new-feature`)
  5. Create new Pull Request


pkgId: 5bad729b56074632c09b08f2f65d18962279f0c4dc91eb88084788aa89727d08
name: python-a10-octavia
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A10 Octavia Provider Driver
url: https://github.com/a10networks/a10-octavia
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a10-octavia-2.2.0-1.src.rpm
checksum_type: sha256
description:
  1. [Overview](#Overview)

  2. [Project Resources](#Project-Resources)

  3. [Issues and Inquiries](#Issues-and-Inquiries)



  **This solution is currently in beta stage with limited support**

  The A10 Networks Octavia Driver allows for configuration of Thunder, vThunder, and AX Series Appliances deployed in
  an Openstack enviroment. While the default Octavia provider leverages an "Amphora per VIP" architecture,
  this provider driver uses a "vThunder-Amphora per Tenant" architecture. Therefore, each tenant may only be serviced by a single
  **active** vThunder-Amphora device.

  No such limitation exists for hardware Thunder devices in versions >=1.3. Through the use of Octavia flavors, operators may now have any number of hadware Thunder devices servicing a singular project.



  ```
  | a10-octavia            | acos-client   | ACOS Version        |
  | v1.1                   | v2.6.1        | 5.2.1, 4.1.4-GR1-P5 |
  | v1.2                   | v2.7.0        | 5.2.1-p1            |
  | v1.3, v1.3.1, v1.3.2   | v2.8.0        | 5.2.1-p1            |
  | v2.0                   | v2.9.0        | 5.2.1-p2            |
  | v2.1                   | v2.9.1        | 5.2.1-p2            |
  | v2.2                   | v2.10.0       | 5.2.1-p2 and later  |
  ```



  Installation and usage information is available at https://documentation.a10networks.com/Install/Software/A10_ACOS_Install/pdf/A10_OCTAVIA_INSTALL.pdf

  Release notes are available at https://documentation.a10networks.com/Install/Software/A10_ACOS_Install/pdf/A10_OCTAVIA_RN.pdf


  For all issues, please send an email to support@a10networks.com


pkgId: f0cbcac6912b03d9e5e8f776455731ed4cf733d5b12ab02192fbc7a5cb29f4d0
name: python-a10sa-script
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A10SA Script
url: https://github.com/bhrevol/a10sa-script
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a10sa-script-0.1.2-1.src.rpm
checksum_type: sha256
description:
  |PyPI| |Status| |Python Version| |License|
  |Read the Docs| |Tests| |Codecov|
  |pre-commit| |Black|
  Library for manipulating Vorze A10 sex toy scripts.


pkgId: f1f42ba50a5b8dad332786315d81bc4a58f8241ec0757baa1eddd0930d2b7ce0
name: python-a2
arch: src
version: 0.10.13
epoch: 0
release: 1
url: https://pypi.org/project/a2/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2-0.10.13-1.src.rpm
checksum_type: sha256
summary:
  Package for predicting information about the weather from social media data as application 2 for maelstrom project


pkgId: c35d3053254e467aa4fc351f6da3833d15ba4763126e8b8b96bdca7da8239ff9
name: python-a2conf
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: apache2 configuration file parser and query tool
url: https://github.com/yaroslaff/a2conf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2conf-0.3.4-1.src.rpm
checksum_type: sha256
description:
  a2conf is python3 module which provides easy way to configure apache2. a2conf used by [a2utils](https://github.com/yaroslaff/a2utils) package, so you may use a2utils as examples.

  For all examples we will use test config file `examples/example.conf` in source code. Use `export PYTHONPATH=.` to use module if it's not installed.

  **Create simple apache config**

  see examples/ex5_create.py for full code:
  ~~~python
  vhost = root.insert('<VirtualHost *:80>')
  vhost.insert([
          '# This VirtualHost is auto-generated',
          'ServerName example.com',
          'ServerAlias www.example.com',
          '',
          'DocumentRoot /var/www/example.com/'
          ])
  ~~~

  **Read apache config**

  list all SSL hosts (see examples/ex2_query.py for full code):
  ~~~python
  root = a2conf.Node(config)
  for vhost in root.children('<VirtualHost>'):
      servername = vhost.first('servername').args # First query method, via first(). Not much fail-safe but short.

      try:
          ssl_option = next(vhost.children('sslengine')).args # Second query method, via children()
          if ssl_option.lower() == 'on':
              print("{} has SSL enabled".format(servername))
      except StopIteration:
          
          pass
  ~~~

  **Get VirtualHost**
  ~~~python
          root = a2conf.Node(config)
          vh1 = root.find_vhost('example.com', '*:80')
          vh2 = root.find_vhost('www.example.com', '*:443')
          vh3 = root.find_vhost('example.example.com')

          for vhost in root.yield_vhost('example.com'):
              do_something(vhost)
  ~~~

  **Save virtualHost**

  If you will call `write_file()` method of vhost, it will write only this vhost. To save file with all vhosts, use save_file().

  ~~~python
          root = a2conf.Node(config)
          vh = root.find_vhost('example.com')
          vh.insert(['CustomLog /var/log/apache2/example.com-access.log'])
          vh.save_file()
  ~~~





  `raw` - text line as-is, with all spaces, tabs and with comments

  `cmd` - cmd ('ServerName') without args or None (if section)

  `section` - section (e.g. 'VirtualHost')

  `args` - one text line args to cmd or section. for vhost args could be '*:80', for ServerAlias: 'example.com example.org'

  `name` - name of node. cmd if node has cmd, or section name (in brackets) if this is section. e.g. 'ServerName' or
  '<VirtualHost>'

  `content` - list of child nodes (possible empty). For container sections (VirtualHost) attribute `content` is list
   of children. For usual commands (e.g. ServerName) - empty list.




  `__init__(self, read=filename, raw=None, parent=None, name=None, path=None, line=None, includes=True)` - In most cases you should not need to use
  any parameters here except `includes` and `read`. `read` is apache config filename to read. Use `includes=False` if you want `read_file` method to ignore `Include*` directives.

  `children(name=None, recursive=None)` - Main query method, returns generator for all children  nodes (e.g. for VirtualHost node). Generator is empty if no
  children. If name specified, generator will return only nodes with this name (e.g. 'servername' or '<VirtualHost>'). If recursive is On,
  generator will return nested nodes too (e.g. what is inside `<IfModule>` or `<Directory>` settings). To get just one first element use
  `next(node.children('ServerName'))`. It will raise `StopIteration` if node has no such children elements.

  `first(name, recursive=None)` - wrapper for `children()`. Returns only first element or `None`. Not raising exceptions.

  `read_file(filename)` - Reads apache config. Called automatically from `__init__` if you specified `read` argument.

  `dump(fh=sys.stdout, depth=0)` - dump loaded config in unified format (indented). if fh not specified, just dumps to stdout()

  `write_file(filename)` - opens file for writing and dump() to this file.

  `save_file()` - saves whole file with this vhost (with changes and with other vhosts)

  `add(child)` - add new child node to content of Node after all other nodes (including possible closing
  Node `</VirtualHost>`). Child is Node type, use `add_raw(line)` to add raw string.

  `insert(child, after)` - smarter then `add()`. Add new child node, place it after last node with name `after`. e.g.:
  ~~~
  doc_root = Node(raw='DocumentRoot /var/www/site1')
  vhost.insert([doc_root], after=['ServerName','ServerAlias'])
  ~~~

  `child` is list of `Node`s to insert. But a2conf is friendly: if you pass single element, it will be converted to list with this element, and then if any element is string, it will be converted to node. So, this command woks well too:
  ~~~
  vhost.insert('DocumentRoot /var/www/site1', after=['ServerName','ServerAlias'])
  ~~~

  If `after` not specified, or not found, child is appended to end. If specified, method tries to insert new node
  after last found node in `after`.

  In this example, new node will be inserted after `ServerAlias` (if it exists). If not, it will be inserted after `ServerName` (if it exists). And if all commands listed in `after` is not found, node will be inserted as last node, right before closing tag (e.g., right before `</VirtualHost>`).

  Returns first inserted child. So you may write code like this:
  ~~~

  vhost = root.insert("<VirtualHost *:80>")
  vhost.insert('ServerName example.net')
  ~~~

  `delete()` - removes this Node from parent (e.g. remove vhost from apache config or remove directive from vhost).
  You should not call `delete()` while iterating over `children()` (unless you want to delete just one node). Proper usage:
  ~~~python
      
      for n in vhost.children('Redirect'):
          n.delete()

      
      deleted=list()
      for n in vhost.children('Redirect'):
          deleted.append(n)
      for n in deleted:
          n.delete()
  ~~~




  `examples/ex1_dump.py` just loads config and dumps its structure (without comments) as JSON:
  ~~~python

  import sys
  import a2conf
  import json

  root = a2conf.Node(sys.argv[1])

  def section_dump(node):
      data = dict()

      for ch in node.children():
          if ch.section and not ch.section.startswith('/'):
              if ch.args:
                  key = ch.section + ' ' + ch.args
              else:
                  key = ch.section
              data[key] = section_dump(ch)
          elif ch.cmd:
              data[ch.cmd] = ch.args
      return data

  data = section_dump(root)
  print(json.dumps(data, indent=4))
  ~~~

  Output:
  ~~~
  $ examples/ex1_dump.py examples/example.conf
  {
      "VirtualHost *:80": {
          "DocumentRoot": "/var/www/example",
          "ServerName": "example.com",
          "ServerAlias": "www.example.com example.com 1.example.com 2.example.com",
          "DirectoryIndex": "index.html index.htm default.htm index.php",
          "Options": "-Indexes +FollowSymLinks"
      },
      "VirtualHost *:443": {
          "DocumentRoot": "/var/www/example",
          "ServerName": "example.com",
          "ServerAlias": "www.example.com 1.example.com 2.example.com secure.example.com",
          "DirectoryIndex": "index.html index.htm default.htm index.php",
          "Options": "-Indexes +FollowSymLinks",
          "SSLEngine": "On",
          "SSLCertificateFile": "/etc/letsencrypt/live/example.com/fullchain.pem",
          "SSLCertificateKeyFile": "/etc/letsencrypt/live/example.com/privkey.pem",
          "SSLCertificateChainFile": "/etc/letsencrypt/live/example.com/chain.pem"
      }
  }
  ~~~
  Note - this is short example just for demo, it's not very good for production: if virtualhost has more then one directive
  (e.g. `ServerAlias`, `RewriteRule`, `RewriteCond`), only last one will be used.



  `examples/ex2_query.py` print all SSL sites from config:
  ```python

  import sys
  import a2conf
  root = a2conf.Node(sys.argv[1])

  for vhost in root.children('<VirtualHost>'):
      servername = vhost.first('servername').args # One query method, via first(). Not much fail-safe but short.

      try:
          ssl_option = next(vhost.children('sslengine')).args # Other query method, via children()
          if ssl_option.lower() == 'on':
              print("{} has SSL enabled".format(servername))
      except StopIteration:
          
          continue
  ```

  Output:
  ```
  $ examples/ex2_query.py examples/example.conf
  example.com has SSL enabled
  ```


  `examples/ex3_replace_delete.py` disables SSLEngine directive:
  ~~~python

  import sys
  import a2conf
  root = a2conf.Node(sys.argv[1])

  for vhost in root.children('<VirtualHost>'):
      if vhost.first('sslengine'):
          vhost.delete() # Delete SSL vhost
      else:
          
          vhost.first('DocumentRoot').args = '/var/www/example2'
          vhost.first('DocumentRoot').suffix = '# New DocumentRoot!'
          
          vhost.first('ServerAlias').delete()

  root.dump()
  ~~~

  Output:
  ~~~shell
  $ examples/ex3_replace_delete.py examples/example.conf



  <VirtualHost *:80>
      
      DocumentRoot /var/www/example2 # New DocumentRoot!
      ServerName example.com # .... OUR TEST SITE ....
      DirectoryIndex index.html index.htm default.htm index.php
      Options -Indexes +FollowSymLinks
  </VirtualHost>
  ~~~


pkgId: 519919fcbb45079ff5c997dc1796adb1c09c86450aee439dfe3ddd682918a259
name: python-a2d_diary
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A2D-Diary web app. Create and encode paper diaries automatically
url: https://a2d-diary.netlify.com
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2d_diary-0.1.5-1.src.rpm
checksum_type: sha256
description:
  **A2D-Diary** is a web app that helps you to create multiple-choice
  questionnaires/diaries that can be marked automatically and transcribed
  to a digital CSV file. This web app was developed as part of the SKIP
  project at the Interaction Analysis and Modelling (IAM) Lab of the
  University of Manchester, UK.
  **For more information check the official docs at


pkgId: 9baf620e986248e87b390d08a94519f4e96eb462216f2e89f3295aa65f7ccc44
name: python-a2od
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Convert Anki style flashcards to Emacs org-drill format
url: https://github.com/yfe404/anki2orgdrill
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2od-0.0.5-1.src.rpm
checksum_type: sha256
description:
  1.  [anki2orgdrill](#org16aa707)
      1.  [What are flashcards ?](#orgacb78d5)
      2.  [What is Anki ?](#org00ee51f)
      3.  [What is org-drill ?](#org96d902c)
      4.  [Features](#orgdaf61d2)
      5.  [Installation](#org0061677)
      6.  [Usage](#org6c59d99)
          1.  [Example](#orge9cc94e)
      7.  [References](#org28994ef)


  <a id="org16aa707"></a>




  <a id="orgacb78d5"></a>



  From Wikipedia:

  A flashcard or flash card is a card bearing information, as words or numbers, on either or both sides, used in classroom drills or in private study. One writes a question on a side and an answer overleaf. Flashcards can bear vocabulary, historical dates, formulae or any subject matter that can be learned via a question-and-answer format. Flashcards are widely used as a learning drill to aid memorization. They are often associated with spaced repetition, i.e. reviewed at expanding time intervals.


  <a id="org00ee51f"></a>



  Anki is a spaced repetition flashcard program.


  <a id="org96d902c"></a>



  Org-Drill is an extension for Org mode. Org-Drill uses a spaced repetition algorithm to conduct interactive "drill sessions", using org files as sources of facts to be memorised.


  <a id="orgdaf61d2"></a>



  Convert a single export file in plain text from Anki to a single
  file in org-drill format.

  **Currently, only two-sided cards are supported.**


  <a id="org0061677"></a>



      pip install a2od


  <a id="org6c59d99"></a>



      Usage: a2od convert [OPTIONS] SRC DST

        Convert Anki style flashcards to Emacs org-drill format.

        params:   src: Anki Cards in plain text export.   dst: Destination org
        file.

      Options:
        --help  Show this message and exit.


  <a id="orge9cc94e"></a>



      a2od convert ~/Downloads/AllDecks.txt decks.org


  <a id="org28994ef"></a>



  -   <https://en.wikipedia.org/wiki/Flashcard>
  -   <https://en.wikipedia.org/wiki/Anki_(software)>
  -   <https://orgmode.org/worg/org-contrib/org-drill.html>
  -   <https://orgmode.org/>


pkgId: 7f68de5713a50fe089b68c7b5e6ca7375123e7c40fe36bee3e671eb759181845
name: python-a2p2
arch: src
version: 0.7.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: http://www.jmmc.fr/a2p2
rpm_license: OSI Approved :: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2p2-0.7.3-1.src.rpm
checksum_type: sha256
description:
  Prepare your observations within Aspro2_ ( V0.9.9.3+ ) and run a2p2_ to submit your OB.
  Once setup ready, select your target and use Interop Menu
  CHARA OB are only displayed in the GUI for the first implementations.
  ESO OB are ready to be submitted through P2_. You can use the demo account for tests or have to provide your credential for real cases.
  A tutorial_ is provided for your first steps with Aspro2_.


pkgId: f7675953f289e795e645890527abdf6a7f2a925b2e8e4261cf210d048c1c541b
name: python-a2pcej
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: a2pcej, "convert Alphabet to Phonetic Code in English and Japanease."
url: https://github.com/kacchan822/a2pcej
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2pcej-0.2.3-1.src.rpm
checksum_type: sha256
description:
  |Code Climate| |Issue Count| |Coverage Status|
  **a2pcej**, convert Alphabet to Phonetic Code in English and Japanease.
  This module convert each alphabet letters to phonetic code, and also
  convert each alphabet letterts to katakana.
  Functions
  ~~~~~~~~~
  conv\_al(letters, delimiter='-', upper\_sign='(CAPS)', num=False)
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  letters is string.
      def conv_al(letters, delimiter='-', sign='(CAPS)', num=False):
          return <unicode>
  conv\_ak(letters, delimiter='・', upper\_sign='（大文字）', num=False)
  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  letters is string.
      def conv_ak(letters, delimiter='・', sign='（大文字）', num=False):
          return <unicode>
  Simple example of usage as below... (on Python3.5)
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  First of all, import module.
      Import module.
      >>> from a2pcej import *
  Convert 'examples' to Ponetic code in English.
      >>> conv_al('examples')
      'Echo-Xray-Alfa-Mike-Papa-Lima-Echo-Sierra'
  Convert 'examples' to Ponetic code in Japanese Katakana.
      >>> conv_ak('examples')
      'イー・エクス・エイ・エム・ピー・エル・イー・エス'
  | Non alphabet letters are not convert (default).
  | Upper case lattters has (CAPS) or (大文字) sign (default).
      >>> conv_al('Examples002')
      'Echo(CAPS)-Xray-Alfa-Mike-Papa-Lima-Echo-Sierra-0-0-2'
      >>> conv_ak('Examples002')
      'イー（大文字）・エクス・エイ・エム・ピー・エル・イー・エス・0・0・2'
  You can change delimiter and Upper case letters sign.
      >>> conv_al('Examples003', delimiter=', ', sign='(CAPITAL)')
      'Echo(CAPITAL), Xray, Alfa, Mike, Papa, Lima, Echo, Sierra, 0, 0, 3'
      >>> conv_ak('Examples003', delimiter='／', sign='(大)')
      'イー(大)／エクス／エイ／エム／ピー／エル／イー／エス／0／0／3'
  If you would like to convert numbers to phonetic code, set ``num=True``.
      >>> conv_al('Examples004', num=True)
      'Echo(CAPS)-Xray-Alfa-Mike-Papa-Lima-Echo-Sierra-zero-zero-four'
      >>> conv_ak('Examples004', num=True)
      'イー（大文字）・エクス・エイ・エム・ピー・エル・イー・エス・ゼロ・ゼロ・ヨン'


pkgId: 5e3f7f8a49450f8dbc9b605777fd6bed91844d5b7063d77032e763faade14710
name: python-a2squery
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A2SQuery is a python implementation of Valve's A2S protocol
url: https://github.com/linKhehe/a2squery
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2squery-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A2SQuery is a python implementation of [Valve's A2S protocol](https://developer.valvesoftware.com/wiki/Server_queries>).


pkgId: cdcc9fa3dfd66546b9db5b077dca3e13bc0accc3f1afe1e72a642adbb0bb5af6
name: python-a2svm
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Simple CLI tool to create and delete easily virtual hosts in Apache.
url: https://github.com/cypx/a2svm
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2svm-0.1.5-1.src.rpm
checksum_type: sha256
description:
  **********************************************
  A2SVM  - Apache 2 Simple Virtualhost Manager
  **********************************************

  **a2svm** is a Simple CLI tool to create and delete easily virtualhosts in Apache.

  usage: a2svm [-h] [-v] {mk,ls,rm,en,ds} ...

  a2svm commands are:

  * **mk**         Create a virtualhosts
  * **ls**         Show managed virtualhosts on Apache server
  * **rm**         Delete a virtualhosts
  * **en**         Enable a virtualhosts
  * **ds**         Disable a virtualhosts

  See 'a2svm <command> -h' for more information on a specific command.

  PyPI package `<http://pypi.python.org/pypi/a2svm>`__

  Sources `<https://github.com/cypx/a2svm>`__

  Requirements


  a2svm need apache mod_macro which could be installed on debian 6 by the following command

  .. code-block:: bash

  	$ aptitude install libapache2-mod-macro

  Once mod_macro is avalaible some template could be created for use by a2svm like this one

  .. code-block:: xml

  	<Macro vhost_standard $name $servername $directory>
  	  <VirtualHost *:80>

  	    ServerName $servername

  	    DocumentRoot /var/www/$directory/public

  	    <Directory /var/www/$directory>
  	        Options  FollowSymLinks MultiViews
  	        AllowOverride All
  	        Order allow,deny
  	        allow from all
  	    </Directory>

  	    ErrorLog ${APACHE_LOG_DIR}/error-$name.log

  	    
  	    
  	    LogLevel warn

  	    CustomLog ${APACHE_LOG_DIR}/access-$name.log combined
  	  </VirtualHost>
  	</Macro>

  	
  	
  	
  	
  	
  	
  	
  	



  Installation


  Install it easily:

  Using pip
  **************

  .. code-block:: bash

  	$ pip install a2svm

  Warning! On some old distribution using Python 2.x, you could require to upgrade pip to support install, run:

  .. code-block:: bash

  	$ pip install --index-url=https://pypi.python.org/simple/ --upgrade pip setuptools

  Using easy_install
  *********************

  On most Linux distribution

  .. code-block:: bash

  	$ easy_install a2svm

  But on some, prerequisites are required, for example, on Debian 6

  .. code-block:: bash

  	$ aptitude install python-pip


  Upgrade


  Using pip
  **************

  .. code-block:: bash

  	$ pip --upgrade a2svm

  Using easy_install
  *********************

  .. code-block:: bash

  	$ easy_install --upgrade a2svm

  From sources
  ***************

  .. code-block:: bash

      $ git clone https://github.com/cypx/a2svm
      $ cd a2svm
  	$ pip install -r requirements.txt
      $ python setup.py install

  Reminder
  ***************

  To publish package on pypi

  .. code-block:: bash

      $ pip install twine
      $ rm -rf dist
      $ python setup.py sdist bdist_wheel
      $ twine upload dist/*


pkgId: 87ead6ec7efb3c460123cb1a720fe792726876c1fa7909e287542768de3a80d8
name: python-a2t
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Ask2Transformers is a library for zero-shot classification based on Transformers.
url: https://github.com/osainz59/Ask2Transformers
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2t-0.4.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Ask2Transformers</h1>
  <h3 align="center">A Framework for Textual Entailment based Zero Shot text classification</h3>
  <p align="center">
   <a href="https://paperswithcode.com/sota/domain-labelling-on-babeldomains?p=ask2transformers-zero-shot-domain-labelling">
    <img align="center" alt="Contributor Covenant" src="https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/ask2transformers-zero-shot-domain-labelling/domain-labelling-on-babeldomains">
   </a>
  </p>

  This repository contains the code for out of the box ready to use zero-shot classifiers among different tasks, such as Topic Labelling or Relation Extraction. It is built on top of 🤗 HuggingFace [Transformers](https://github.com/huggingface/transformers) library, so you are free to choose among hundreds of models. You can either, use a dataset specific classifier or define one yourself with just labels descriptions or templates! The repository contains the code for the following publications:

  - 📄 [Ask2Transformers - Zero Shot Domain Labelling with Pretrained Transformers](https://aclanthology.org/2021.gwc-1.6/) accepted in [GWC2021](http://globalwordnet.org/global-wordnet-conferences-2/).
  - 📄 [Label Verbalization and Entailment for Effective Zero- and Few-Shot Relation Extraction](https://aclanthology.org/2021.emnlp-main.92/) accepted in [EMNLP2021](https://2021.emnlp.org/)
  - 📄 [Textual Entailment for Event Argument Extraction: Zero- and Few-Shot with Multi-Source Learning]() accepted as Findings in [NAACL2022]()

  <!-- ### Supported (and benchmarked) tasks:
  Follow the links to see some examples of how to use the library on each task.
  - [Topic classification](./a2t/topic_classification/) evaluated on BabelDomains (Camacho-
  Collados and Navigli, 2017)  dataset.
  - [Relation classification](./a2t/relation_classification/) evaluated on TACRED (Zhang et al., 2017) dataset. -->

  To get started with the repository consider reading the **new** [documentation](https://osainz59.github.io/Ask2Transformers)!




  By using Pip (check the last release)

  ```shell script
  pip install a2t
  ```

  Or by clonning the repository

  ```shell script
  git clone https://github.com/osainz59/Ask2Transformers.git
  cd Ask2Transformers
  python -m pip install .
  ```

  <!-- [//]: <img src="./imgs/RE_NLI.svg" style="background-color: white; border-radius: 15px"> -->



  We have realeased a demo on Zero-Shot Information Extraction using Textual Entailment ([ZS4IE: A toolkit for Zero-Shot Information Extraction with simple Verbalizations](https://arxiv.org/abs/2203.13602)) accepted in the [Demo Track of NAACL 2022](). The code is publicly availabe on its own GitHub repository: [ZS4IE](https://github.com/bbn-e/zs4ie).



  By default, `roberta-large-mnli` checkpoint is used to perform the inference. You can try different models to perform the zero-shot classification, but they need to be finetuned on a NLI task and be compatible with the `AutoModelForSequenceClassification` class from Transformers. For example:

  * `roberta-large-mnli`
  * `joeddav/xlm-roberta-large-xnli`
  * `facebook/bart-large-mnli`
  * `microsoft/deberta-v2-xlarge-mnli`

  **Coming soon:** `t5-large` like generative models support.



  We now provide (task specific) pre-trained entailment models to: (1) **reproduce** the results of the papers and (2) **reuse** them for new schemas of the same tasks. The models are publicly available on the 🤗 HuggingFace Models Hub.

  The model name describes the configuration used for training as follows:

  <!-- $$\text{HiTZ/A2T\_[pretrained\_model]\_[NLI\_datasets]\_[finetune\_datasets]}$$ -->

  <h3 align="center">HiTZ/A2T_[pretrained_model]_[NLI_datasets]_[finetune_datasets]</h3>


  - `pretrained_model`: The checkpoint used for initialization. For example: RoBERTa<sub>large</sub>.
  - `NLI_datasets`: The NLI datasets used for pivot training.
      - `S`: Standford Natural Language Inference (SNLI) dataset.
      - `M`: Multi Natural Language Inference (MNLI) dataset.
      - `F`: Fever-nli dataset.
      - `A`: Adversarial Natural Language Inference (ANLI) dataset.
  - `finetune_datasets`: The datasets used for fine tuning the entailment model. Note that for more than 1 dataset the training was performed sequentially. For example: ACE-arg.

  Some models like `HiTZ/A2T_RoBERTa_SMFA_ACE-arg` have been trained marking some information between square brackets (`'[['` and `']]'`) like the event trigger span. Make sure you follow the same preprocessing in order to obtain the best results.


  There is no special script for fine-tuning your own entailment based models. In our experiments, we have used the publicly available [run_glue.py](https://github.com/huggingface/transformers/blob/master/examples/pytorch/text-classification/run_glue.py) python script (from HuggingFace Transformers). To train your own model, first, you will need to convert your actual dataset in some sort of NLI data, we recommend you to have a look to [tacred2mnli.py](https://github.com/osainz59/Ask2Transformers/blob/master/scripts/tacred2mnli.py) script that serves as an example.



  **Coming soon!**



  To obtain the results reported in the papers run the [`evaluation.py`](./a2t/evaluation.py) script with the corresponding configuration [files](./resources/predefined_configs/). A configuration file containing the task and evaluation information should look like this:

  ```json
  {
      "name": "BabelDomains",
      "task_name": "topic-classification",
      "features_class": "a2t.tasks.text_classification.TopicClassificationFeatures",
      "hypothesis_template": "The domain of the sentence is about {label}.",
      "nli_models": [
          "roberta-large-mnli"
      ],
      "labels": [
          "Animals",
          "Art, architecture, and archaeology",
          "Biology",
          "Business, economics, and finance",
          "Chemistry and mineralogy",
          "Computing",
          "Culture and society",
          ...
          "Royalty and nobility",
          "Sport and recreation",
          "Textile and clothing",
          "Transport and travel",
          "Warfare and defense"
      ],
      "preprocess_labels": true,
      "dataset": "babeldomains",
      "test_path": "data/babeldomains.domain.gloss.tsv",
      "use_cuda": true,
      "half": true
  }
  ```

  Consider reading the papers to access the results.



  The old code of this repository has been moved to [`a2t.legacy`](./a2t/legacy/) module and is only intended to be use for experimental reproducibility. Please, consider moving to the new code. If you need help read the new [documentation](https://osainz59.github.io/Ask2Transformers) or post an Issue on GitHub.


  Cite this paper if you want to cite stuff related to Relation Extraction, etc.
  ```bibtex
  @inproceedings{sainz-etal-2021-label,
      title = "Label Verbalization and Entailment for Effective Zero and Few-Shot Relation Extraction",
      author = "Sainz, Oscar  and
        Lopez de Lacalle, Oier  and
        Labaka, Gorka  and
        Barrena, Ander  and
        Agirre, Eneko",
      booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing",
      month = nov,
      year = "2021",
      address = "Online and Punta Cana, Dominican Republic",
      publisher = "Association for Computational Linguistics",
      url = "https://aclanthology.org/2021.emnlp-main.92",
      pages = "1199--1212",
      abstract = "Relation extraction systems require large amounts of labeled examples which are costly to annotate. In this work we reformulate relation extraction as an entailment task, with simple, hand-made, verbalizations of relations produced in less than 15 min per relation. The system relies on a pretrained textual entailment engine which is run as-is (no training examples, zero-shot) or further fine-tuned on labeled examples (few-shot or fully trained). In our experiments on TACRED we attain 63{\%} F1 zero-shot, 69{\%} with 16 examples per relation (17{\%} points better than the best supervised system on the same conditions), and only 4 points short to the state-of-the-art (which uses 20 times more training data). We also show that the performance can be improved significantly with larger entailment models, up to 12 points in zero-shot, allowing to report the best results to date on TACRED when fully trained. The analysis shows that our few-shot systems are specially effective when discriminating between relations, and that the performance difference in low data regimes comes mainly from identifying no-relation cases.",
  }
  ```

  Cite this paper if you want to cite stuff related with topic labelling (A2TDomains or our paper results).
  ```bibtex
  @inproceedings{sainz-rigau-2021-ask2transformers,
      title = "{A}sk2{T}ransformers: Zero-Shot Domain labelling with Pretrained Language Models",
      author = "Sainz, Oscar  and
        Rigau, German",
      booktitle = "Proceedings of the 11th Global Wordnet Conference",
      month = jan,
      year = "2021",
      address = "University of South Africa (UNISA)",
      publisher = "Global Wordnet Association",
      url = "https://www.aclweb.org/anthology/2021.gwc-1.6",
      pages = "44--52",
      abstract = "In this paper we present a system that exploits different pre-trained Language Models for assigning domain labels to WordNet synsets without any kind of supervision. Furthermore, the system is not restricted to use a particular set of domain labels. We exploit the knowledge encoded within different off-the-shelf pre-trained Language Models and task formulations to infer the domain label of a particular WordNet definition. The proposed zero-shot system achieves a new state-of-the-art on the English dataset used in the evaluation.",
  }
  ```


pkgId: 9ca974f877d6bad29c716a66cbb1f2adced19b25140ef7579913b3d9092b34e6
name: python-a2utils
arch: src
version: 0.0.38
epoch: 0
release: 1
summary: apache2 config file utilities
url: https://github.com/yaroslaff/a2utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2utils-0.0.38-1.src.rpm
checksum_type: sha256
description:
  Info:
      (static.okerr.com) is local 37.59.102.26
      (static.okerr.com) Vhost: /etc/apache2/sites-enabled/static.okerr.com.conf:1
      (static.okerr.com) DocumentRoot: /var/www/virtual/static.okerr.com/
      (static.okerr.com) DocumentRoot /var/www/virtual/static.okerr.com/ matches LetsEncrypt and Apache


pkgId: db87630c5da8e0592b29d40274a1ec402589f913591b27ae83acf78b5df105cd
name: python-a2y-builda2y
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: http://www.kersci.com/a2y/builda2y.html
rpm_license: Private
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a2y-builda2y-1.2.0-1.src.rpm
checksum_type: sha256
description:
  这个模块包含了一些用于构建 Python 模块的小工具。



  1. 安装 wheel 模块（可能需要系统管理员权限）
      `pip install wheel`

  2. 运行打包命令
      `python setup.py bdist_wheel`



  - 2024-06-09 修正一些过时有误的信息。版本升级为 1.2.0。


pkgId: 7d3cbd09fb98d2af0ec0ecc75a13dc55f0c6a677a6d4f22a0c23356a0d076cb3
name: python-a360-python-libraries
arch: src
version: 0.9.5
epoch: 0
release: 1
summary: A collection of Python libraries for A360
url: https://pypi.org/project/a360-python-libraries/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a360-python-libraries-0.9.5-1.src.rpm
checksum_type: sha256
description:
  Python shared libraries for a360 applications


  This software is proprietary and is intended solely for use by Aesthetics-360 Inc.. Unauthorized use, distribution, or modification of this software outside of Aesthetics-360 Inc. is strictly prohibited.



  ```bash
  poetry add a360-python-libraries
  ```





  ```python
  from fastapi import APIRouter, Depends

  from a360_security.depends import require_role
  from a360_security.enums import Role

  router = APIRouter()

  @router.get(
      ...,
      dependencies=[Depends(require_role(Role.ADMIN))]
  )
  def get() -> dict:
      ...
  ```

  You can provide multiple roles to the `require_role` dependency, and they will be checked in OR fashion.

  ```python
  from fastapi import APIRouter, Depends

  from a360_security.depends import require_role
  from a360_security.enums import Role

  router = APIRouter()

  @router.get(
      ...,
      dependencies=[Depends(require_role(Role.ADMIN, Role.SERVICE))]
  )
  def get() -> dict:
      ...
  ```




  ```python
  from fastapi import APIRouter, Depends

  from a360_security.depends import valid_practice

  router = APIRouter()

  @router.get(
      ...,
      dependencies=[Depends(valid_practice())]
  )
  def get() -> dict:
      ...
  ```




  ```python
  from fastapi import APIRouter, Depends

  from a360_security.depends import require_user
  from a360_security.dto import UserDTO

  router = APIRouter()

  @router.get(
      ...,
  )
  def get(user: UserDTO = Depends(require_user)) -> dict:
      ...
  ```




  ```python
  from fastapi import APIRouter, Depends

  from a360_security.depends import require_client_platform
  from a360_security.enums import ClientPlatform

  router = APIRouter()

  @router.get(
      ...,
  )
  def get(client_platform: ClientPlatform = Depends(require_client_platform)) -> dict:
      ...
  ```



  ```python
  from fastapi import APIRouter, Depends

  from a360_services import get_dictionary_service
  from a360_services.services import DictionaryService

  router = APIRouter()

  @router.get(
      ...,
  )
  def get(dict_service: DictionaryService = Depends(get_dictionary_service)) -> dict:
      medical_conditions = dict_service.get_medical_conditions()
  ```



  ```python
  from fastapi import APIRouter, Depends

  from a360_notification import get_mail_service
  from a360_notification.services import AWSSesService

  router = APIRouter()

  @router.post(
      ...,
  )
  def create(mail_service: AWSSesService = Depends(get_mail_service)):
      mail_service.send_email(
          recipient_name='John Doe',
          recipient_address='john.doe@example.com',
          subject='Test email',
          html_content='<h1>Test email</h1>',
      )
  ```


pkgId: ce81ea5a8f22183bbd942d1bd107f19706b380f5575f4173343e34725a9bb999
name: python-a360-python-libraries
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A collection of Python libraries for A360
url: https://pypi.org/project/a360-python-libraries/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a360-python-libraries-1.1.1-1.src.rpm
checksum_type: sha256
description:
  Python shared libraries for a360 applications


  This software is proprietary and is intended solely for use by Aesthetics-360 Inc.. Unauthorized use, distribution, or modification of this software outside of Aesthetics-360 Inc. is strictly prohibited.



  ```bash
  poetry add a360-python-libraries
  ```



  * 🔒 Security
    * [Role based access control](docs/a360_security/role-based-access-control.md)
    * [User valid practice dependency](docs/a360_security/user-valid-practice-dependency.md)
    * [User dependency](docs/a360_security/user-dependency.md)
    * [Client platform](docs/a360_security/client-platform.md)
  * ⚙️ Services
    * [Dictionary service](docs/a360_services/dict/home.md)
      * [Geolocation data](docs/a360_services/dict/geo.md)
      * [Allergies](docs/a360_services/dict/allergies.md)
      * [Medical Conditions](docs/a360_services/dict/allergies.md)
      * [Tags Global Library](docs/a360_services/dict/tags.md)
      * [Services Global Library](docs/a360_services/dict/services.md)
      * [Products Global Library](docs/a360_services/dict/products.md)
      * [Visit Workflows Global Library](docs/a360_services/dict/visit_workflows.md)
    * [Practice service](docs/a360_services/practice/home.md)
      * [Experts](docs/a360_services/practice/experts.md)
      * [Practices](docs/a360_services/practice/practices.md)
    * [Patient service](docs/a360_services/practice/home.md)
      * [Patients](docs/a360_services/patient/patients.md)
      * [Visits](docs/a360_services/patient/visits.md)
      * [Attachments](docs/a360_services/patient/attachments.md)
  * 📧 Notification
    * [Email notification](docs/a360_notification/email-notification.md)
  * 🔧 Utils
    * [Image tools](docs/a360_utils/image_tools.md)


pkgId: a5a5ba5dd32ca2c3419abb515e89eec301f11ddf70645f64d1d5f7c8dc544216
name: python-a3cosmos
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: A Python Package of A3COSMOS Astronomical Data and Catalog Utilities.
url: https://sites.google.com/view/a3cosmos
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a3cosmos-0.9.3-1.src.rpm
checksum_type: sha256
description:
  This Python package contains some useful functions to query A3COSMOS catalog and make cutout images.
  It is currently under development.


pkgId: 55a7404ef4796f65982198de22fe1d06eee24165584fee918741a8baf0bf0984
name: python-a3cosmos-gas-evolution
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A Python Package for Galaxy Cold Molecular Gas and Star Formation Evolution Equations.
url: https://sites.google.com/view/a3cosmos
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a3cosmos-gas-evolution-1.1.1-1.src.rpm
checksum_type: sha256
description:
  This Python package provides functions to calculate a galaxy's cold molecular gas mass to stellar mass ratio (gas fraction), cold molecular gas depletion time and galaxy main-sequence star formation rate.
  The motivation is that the evolution of star-forming galaxies' star formation rate (SFR) and cold molecular gas reservoir have now been reasonably well measured out to very high redshift (z~6), from present time up to as early as one giga-year after the Big Bang (Madau & Dickinson 2014; Genzel et al. 2015; Scoville et al. 2016, 2017; Tacconi et al. 2018; Liu et al. 2018, 2019).
  These studies have found that the majority of galaxies have a steady and parametrizable evolution in their stellar mass growth, SFR, and molecular gas mass (or molecular gas to total baryon fraction, i.e., gas fraction).
  These evolution functions have provided crucial constraints to cosmological simulations of dark matter halo evolution and the semi-analytic modeling of the simulated galaxy evolution in the dark matter halo (e.g., Popping et al. 2014ab, 2016, 2017, 2019ab).
  However, currently there are many parametrizations (or we say "equations") in the literature and each has its own limitation which is not very well aware by the generic users.
  Therefore, we provide this Python package which contains as many galaxy gas, dust, star formation and stellar mass evolution equations as possible for easier comparison and study.


pkgId: 9f8c58d1e77bd6897d441a902428f31d614e771d82ef00857b92570248277896
name: python-a3d-cli
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Axial3D CLI
url: https://pypi.org/project/a3d-cli/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a3d-cli-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Accessing the Axial3D apis from the command line



  * Python 3.7, 3.8, 3.9



      pip install a3d-cli



  Create an order:

      a3dcli create --config_file config.json --dicom_location ./path_to_dicoms/ --order-type 3DPrint --notes notes --surgery 'Surgery' --patient-gender M --patient-birth-year 2001 --catalogue-item 101 --required-date '10-08-2021'

  Update an order

      a3dcli upload --config_file config.json --dicom_location ./path_to_dicoms/ --order_id 1000

  View help:

  ```
  a3dcli --help
  usage: a3dcli [-h] --config_file CONFIG_FILE --order-type [ORDER_TYPES [ORDER_TYPES ...]] --catalogue-item-id [CATALOGUE_ITEM_ID] --surgery [SURGERY] --required-date [REQUIRED_DATE]
                --patient-gender [{M,F,U}] --patient-birth-year [BIRTH_YEAR] --notes [NOTES] [--base_url BASE_URL] [--verify] [--username USERNAME] [--password PASSWORD] [--order_id ORDER_ID] [--dicom_location DICOM_LOCATION] {create,upload}

  Axial3D CLI (0.2.0)

  positional arguments:
    {create,upload}
                          Create Order, Upload by order id

  optional arguments:
    -h, --help            show this help message and exit
    --config_file CONFIG_FILE
                          a3dcli config file
    --order-type [ORDER_TYPES [ORDER_TYPES ...]]
                          Order Types
    --catalogue-item-id [CATALOGUE_ITEM_ID]
                          Catalogue Item
    --surgery [SURGERY]   Surgery
    --required-date [REQUIRED_DATE]
                          Required Date
    --patient-gender [{M,F,U}]
                          Gender
    --patient-birth-year [BIRTH_YEAR]
                          Gender
    --notes [NOTES]       Notes
    --base_url BASE_URL   Base url of axial3D API
    --verify
    --username USERNAME   axial3D account username
    --password PASSWORD   axial3D account password
    --order_id ORDER_ID   ID of the order
    --dicom_location DICOM_LOCATION
                          Path to DICOM files
  ```



  * Poetry - https://python-poetry.org/
  * Tox - https://tox.readthedocs.io/



      poetry build





      poetry run pytest



      poetry run pytest --integration --integration-user USERNAME --integration-password PASSWORD --integration-url https://example.com



      poetry build

      > Building a3d-cli (0.1.0)
      > - Building sdist
      > - Built a3d-cli-0.1.0.tar.gz
      > - Building wheel
      > - Built a3d_cli-0.1.0-py3-none-any.whl


pkgId: 6fa592afa0bd11cb4015016ff1c3f4fdf37cfe249ba9db91f19285231d85220e
name: python-a3py
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: python utils
url: https://gitee.com/three-kinds/a3py
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a3py-0.1.9-1.src.rpm
checksum_type: sha256
description:
  Python utils.

  [History.](HISTORY.md)



  ```shell script
  pip install a3py

  ```





  ```python
  from datetime import date
  from a3py.simplified.datetime import date2str

  assert date2str(date(2019, 10, 3)) == '2019-10-03'

  ```



  ```python
  from a3py.improved.json import fast_dumps

  fast_dumps([1, 2, 3])

  ```



  ```python
  from a3py.improved.readable import get_readable_size

  assert get_readable_size(1024 * 1024) == "1.0MB"

  ```


pkgId: c9aa2ab9f7772140d241b3bc599e250feba97f379a0ded3ed8118afb3cf1911e
name: python-a5py
arch: src
version: 0.1
epoch: 0
release: 1
summary: a5 hydrometeorologic database management system
url: http://github.com/jbianchi81/a5py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a5py-0.1-1.src.rpm
checksum_type: sha256
description:
      
      sudo apt update
      sudo apt install postgresql postgresql-contrib gdal-bin python3-gdal libgdal-dev postgis postgresql-16-postgis-3

      
      python -m venv myenv
      source myenv/bin/activate
      pip install .

      
      DBNAME=modis
      DBUSER=modis
      DBPASSWORD=modis
      DBHOST=localhost
      DBPORT=5432

      
      createdb -h $DBHOST -p $DBPORT $DBNAME
      psql $DBNAME -c "CREATE USER $DBUSER WITH SUPERUSER PASSWORD '$DBPASSWORD';" -h $DBHOST -p $DBPORT
      psql $DBNAME -c  "CREATE EXTENSION postgis" -h $DBHOST -p $DBPORT
      psql $DBNAME -c  "CREATE EXTENSION postgis_raster" -h $DBHOST -p $DBPORT
      psql $DBNAME -c "ALTER DATABASE $DBNAME SET postgis.gdal_enabled_drivers TO 'ENABLE_ALL';"
      sudo service postgresql restart

      
      a5py_config
      nano $HOME/.a5py.ini

      
      a5py create_tables -u "postgresql://$DBUSER:$DBPASSWORD@$DBHOST:$DBPORT/$DBNAME"



      
      a5py_config
      
      nano $HOME/a5py.ini



      
      a5py create_tables -u postgresql://modis:modis@localhost:5432/a5_test
      
      a5py create -m SerieRast '{"id":19, "fuentes_id":40}' -u postgresql://modis:modis@localhost:5432/a5_test
      
      python we2db.py -r $HOME/modis/output -D postgresql://modis:modis@localhost:5432/a5_test -o /tmp/inserted_rast.json -i 19
      
      a5py create -m Area $HOME/Downloads/area_138.json -g -u postgresql://modis:modis@localhost:5432/a5_test
      
      a5py create -m SerieAreal '{"id":1,"area_id":138, "var_id": 30, "proc_id": 5, "unit_id": 14, "fuentes_id": 40, "nombre:"Picasa - we"}' -u postgresql://modis:modis@localhost:5432/a5_test
      
      a5py rast2areal 19 138 2009-01-25 2009-02-10 -a mean -i -s 1 -o /tmp/obs_areal.json -u postgresql://modis:modis@localhost:5432/a5_test
      
      a5py export 2009-02-10 modis_we_20090210.tif




  - import gdal


pkgId: 84964534aed1b07f290b29f7bb16e3674b729ac7663e0f793cda9be533d458cf
name: python-a816
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: 65c816 patching assembler (Super Famicom)
url: https://pypi.org/project/a816/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a816-1.0.2-1.src.rpm
checksum_type: sha256
description:
  Another 65c816 assembler




  ```
  $ a816 --help
  usage: x816 [-h] [--verbose] [-o OUTPUT_FILE] [-f FORMAT] [-m MAPPING] [--copier-header] [--dump-symbols] [-D KEY=VALUE [KEY=VALUE ...]] input_file

  x816 usage

  positional arguments:
    input_file            The asm file to assemble.

  options:
    -h, --help            show this help message and exit
    --verbose             Displays all log levels.
    -o OUTPUT_FILE, --output OUTPUT_FILE
                          Output file
    -f FORMAT             Output format
    -m MAPPING            Address Mapping
    --copier-header       Adds 0x200 address delta corresponding to copier header in ips writer.
    --dump-symbols        Dumps symbol table
    -D KEY=VALUE [KEY=VALUE ...], --defines KEY=VALUE [KEY=VALUE ...]
                          Defines symbols.
  ```

  or directly from python code:



  ```python
  from a816.program import Program

  def build_patch(input, output):
      program = Program()
      program.assemble_as_patch(input, output)
      program.resolver.dump_symbol_map()
  ```





  ```
  adc, and, asl, bcc, bcs, beq, bit, bmi, bne, bpl, bra, brk, brl, bvc, bvs, clc, cld, cli, clv, cmp, cop, cpx, cpy, db, dec, dex, dey, eor, inc, inx, iny, jml, jmp, jsl, jsr, lda, ldx, ldy, lsr, mvn, mvp, nop, ora, pea, pei, per, pha, phb, phd, phk, php, phx, phy, pla, plb, pld, plp, plx, ply, rep, rol, ror, rti, rtl, rts, sbc, sec, sed, sei, sep, sta, stp, stx, sty, stz, tax, tay, tcd, tcs, tdc, trb, tsb, tsc, tsx, txa, txs, txy, tya, tyx, wai, xba, xce
  ```



  ```ca65
  ; define a macro
  .macro test(var_1, var_2) {
      lda.w var_1 << 16 + var_2
  }

  ; use that macro
  test(0x10, 0x10)

  ; should expand that way
  lda.w 0x10 << 16 + 0x10

  ; code generated
  lda.w 0x1010
  ```




  ```ca65
  *=0x008000
      jsr.l _intro
  ```




  ```ca65
  some_address = 0x54
  {
      lda.b some_address
      beq no_action
      ; this label is only visible inside this scope
      no_action:
  }
  ```



  ```ca65
  *=0x009000
  named_scope {
     addr = 0x1234
     youhou_text:
     .text 'youhou'
     .db 0
     yaha_text:
     .text 'yaha'
     .db 0
  }

  *=0x019A52
  	load_system_menu_text_pointer(named_scope.youhou_text)

  *=0x019A80
  	load_system_menu_text_pointer(named_scope.yaha_text)

  ```


pkgId: 08be9943482001d2e8b4206eed41ae46a42243920acfe07d39bf3b842ba133d8
name: python-a8logging
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: A utility for logging events in Python projects
url: https://github.com/devdp/python-logging.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a8logging-1.0.6-1.src.rpm
checksum_type: sha256
description:
  The a8logging function is a utility for logging events in Python projects. It provides a consistent and flexible way to log successes, errors, and other events, and supports multiple output options such as logging to a file or pushing the logs to Elasticsearch.


  - Logs events with the following fields: message, function name, project name, version, and status (success or error).
  - Optionally logs error tracebacks in case of errors.
  - Supports logging to a file, with the option to specify the file name and log rotation settings.
  - Supports logging to Elasticsearch, with the option to specify the Elasticsearch host and port, and other connection settings.
  - Provides a generalized function that can be easily integrated into any Python project.


  To install the log_event function, you will need to install the following dependencies:
  - logging: A built-in Python library for logging events.
  - traceback: A built-in Python library for printing stack traces in case of errors.
  - uuid: A built-in Python library for generating unique IDs.
  - elasticsearch: A third-party library for pushing logs to Elasticsearch.
  - You can install these dependencies by running the following command:

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


  To use the log_event function, you will need to import it into your Python code and call it with the appropriate arguments.
  Here is an example of how to log a success event:
  ```python3
  from a8logging import a8logging

  a8logging('success', "Test message", function_name='test_function', project_name='test_project', version='1.0.0')
  ```

  This will log a success event with the message 'Test message', the function name 'test_function', the project name 'test_project', and the version '1.0.0'.
  To log an error event, you can pass the error argument with an Exception object:
  ```python3
  from a8logging import a8logging

  try:
      
      raise Exception('Test error')
  except Exception as e:
      a8logging('error', "Test error", function_name='test_function', error=e, project_name='test_project', version='1.0.0')
  ```
  This will log an error event with the message 'Test error', the function name 'test_function', the project name 'test_project', and the version '1.0.0'. The error traceback will also be logged.

  To log to a file, you can pass the save_to_file argument with a value of True and the file_name argument with the desired file name:
  ```python3
  from a8logging import a8logging

  a8logging('success', "Test message", function_name='test_function', project_name='test_project', version='1.0.0', save_to_file=True, file_name='test.txt')
  ```
  This will log the event to the file 'test.txt'.


pkgId: c111bfa4cb0601a489c8f30e7fcba2d471ebe22947f85437861f758ee70c49ad
name: python-a9s
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Cli tool for navigation in Amazon AWS services. Highly inspired from k9s
url: https://github.com/IamShobe/a9s
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a9s-0.7.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/github/v/release/IamShobe/a9s) ![](https://img.shields.io/github/workflow/status/IamShobe/a9s/Create%20and%20publish%20a%20Python%20package?label=pypi%20build) ![](https://img.shields.io/github/workflow/status/IamShobe/a9s/Create%20and%20publish%20a%20Docker%20image?label=docker%20build)
  Cli tool for easily navigating in AWS services.
  Highly inspired from [k9s](https://github.com/derailed/k9s).




  ```shell
  pip install a9s
  ```



  ```shell
  docker build . -t a9s
  docker run -v ~/.aws/:/root/.aws -it --rm a9s
  ```



  ```shell
  docker run -v ~/.aws/:/root/.aws -it --rm ghcr.io/iamshobe/a9s
  ```





  Install poetry env:
  ```bash
  poetry install
  ```
  Start dev server:
  ```bash
  poetry run moto_server -p 54321
  ```
  Run mock data:
  ```bash
  poetry run python -m mocked_env.main
  ```


  ```bash
  docker-compose -f mocked_env/docker-compose.yaml up --build
  ```


  Run a9s in local mode (connects to mock server on port 54321):
  ```bash
  LOCAL=true poetry run a9s
  ```




  - [X] s3 support
  - [X] route53 support
  - [ ] EC2 support
  - [ ] ELB support
  - [ ] Cloudfront support



  - [X] responsive tables
  - [X] allow to easily switch between services
  - [X] auto-complete commands
  - [X] vim shortcuts support
  - [X] opening files in S3
  - [X] quick yank
  - [ ] smart navigation between services - route53 pointing to ELB etc..


pkgId: 73d3e5cee42eac9c8a94101a3895ed94facb33241f95da80901d354dd0cf7459
name: python-a9x-webstatistics
arch: src
version: 1.1.15
epoch: 0
release: 1
summary: Web Statistics and Analytics Package
url: https://github.com/ava007/a9x-webstatistics
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a9x-webstatistics-1.1.15-1.src.rpm
checksum_type: sha256
description:
  This package produces web statistics and analytical output based on nginx access log files.

  [![PyPI package](https://img.shields.io/badge/pip%20install-a9x_webstatistics-brightgreen)](https://pypi.org/project/a9x-webstatistics/) [![version number](https://img.shields.io/pypi/v/a9x_webstatistics?color=green&label=version)](https://github.com/ava007/a9x-webstatistics/releases) [![Actions Status](https://github.com/ava007/a9x-webstatistics/workflows/Test/badge.svg)](https://github.com/ava007/a9x-webstatistics/actions) [![License](https://img.shields.io/badge/license-own-blue)](https://github.com/ava007/a9x-webstatistics/blob/main/LICENSE)

  [![Downloads](https://img.shields.io/pypi/dm/a9x-webstatistics)](https://pypistats.org/packages/a9x-webstatistics)
  [![Python](https://img.shields.io/pypi/pyversions/a9x-webstatistics)](https://pypi.org/project/a9x-webstatistics)



  Visit the live example on [logikfabrik.com](https://www.logikfabrik.com/webstatsLF24.html).



  ```bash
  pip install a9x-webstatistics
  ```



  - nginx standard access log file
  - python3.9 onwards
  - optional: maxmind db which need to be download by end user after registration




  ```bash


  export LOG=/usr/local/www/webstats.log
  export PATH=/usr/local/www/django5/envpy311/bin:$PATH

  python3.11 -m a9x_webstatistics.main \
     --infile /var/log/nginx-access.log \
     --geoip /usr/local/share/GeoIP/GeoLite2-Country.mmdb \
     --domain https://www.logikfabrik.com \
     --statfile /usr/local/www/lf_static/webstatsLF24.json &> $LOG

  python3.11 -m a9x_webstatistics.gencockpit \
     --infile /usr/local/www/lf_static/webstatsLF24.json \
     --outfile /usr/local/www/lf_static/webstatsLF24.html &>> $LOG
  ```

  Cron-Job Entry for Linux / FreeBSD:
  ```bash

  13,58   *       *       *       *       dj1     /usr/local/www/cronjobs/cron_webstatistics.sh

  ```




  ```bash



  python -m venv c:\temp\webstatsenv


  c:\temp\webstatsenv\Scripts\activate.bat


  pip install a9x-webstatistics
  python -m pip install --upgrade pip
  python -m pip list
  ```



  ```bash

  c:
  cd \temp
  wget -URI https://www.logikfabrik.com/wlog/access.log -OutFile access.log


  c:\temp\webstatsenv\Scripts\activate.bat



  python -m a9x_webstatistics.main --infile access.log --statfile webstatsLF.json


  python -m a9x_webstatistics.gencockpit --infile webstatsLF.json --outfile webstatsLF.html
  ```



  ```bash


  export LOG=/usr/local/www/webstats.log
  export PATH=/usr/local/www/django5/envpy311/bin:$PATH

  _YEARNUM="$(date +'%Y')";
  _MONTHNUM="$(date +'%m')";


  cp /usr/local/www/lf_static/webstatsLF24.json /usr/local/www/lf_static/webstatsLF24$_YEARNUM$_MONTHNUM.json
  cp /usr/local/www/lf_static/webstatsLF24.html /usr/local/www/lf_static/webstatsLF24$_YEARNUM$_MONTHNUM.html


  pip install -U `pip list --outdated | awk 'NR > 2 {print $1}'` >> $LOG


  python3.11 -m a9x_webstatistics.main \
     --infile /var/log/nginx-access.log \
     --geoip /usr/local/share/GeoIP/GeoLite2-Country.mmdb \
     --domain https://www.logikfabrik.com \
     --statfile /usr/local/www/lf_static/webstatsLF24.json &> $LOG

  python3.11 -m a9x_webstatistics.gencockpit \
     --infile /usr/local/www/lf_static/webstatsLF24.json \
     --outfile /usr/local/www/lf_static/webstatsLF24.html &>> $LOG
  ```


pkgId: f13c67e0864def583bc4446af732db711715cf5bbc259182274f5627ef8855ac
name: python-a9x-webstatistics
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Web Statistics and Analytics Package
url: https://github.com/ava007/a9x-webstatistics
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a9x-webstatistics-1.1.3-1.src.rpm
checksum_type: sha256
description:
  This package produces web statistics and analytical output based on nginx access log files.

  [![PyPI package](https://img.shields.io/badge/pip%20install-a9x_webstatistics-brightgreen)](https://pypi.org/project/a9x-webstatistics/) [![version number](https://img.shields.io/pypi/v/a9x_webstatistics?color=green&label=version)](https://github.com/ava007/a9x-webstatistics/releases) [![Actions Status](https://github.com/ava007/a9x-webstatistics/workflows/Test/badge.svg)](https://github.com/ava007/a9x-webstatistics/actions) [![License](https://img.shields.io/badge/license-own-blue)](https://github.com/ava007/a9x-webstatistics/blob/main/LICENSE)

  [![Downloads](https://img.shields.io/pypi/dm/a9x-webstatistics)](https://pypistats.org/packages/a9x-webstatistics)
  [![Python](https://img.shields.io/pypi/pyversions/a9x-webstatistics)](https://pypi.org/project/a9x-webstatistics)



  Visit the live example on [logikfabrik.com](https://www.logikfabrik.com/webstatsLF24.html).



  ```bash
  pip install a9x-webstatistics
  ```



  - nginx standard access log file
  - python3.9 onwards
  - optional: maxmind db which need to be download by end user after registration




  ```bash


  export LOG=/usr/local/www/webstats.log
  export PATH=/usr/local/www/django5/envpy311/bin:$PATH

  python3.11 -m a9x_webstatistics.main \
     --infile /var/log/nginx-access.log \
     --geoip /usr/local/share/GeoIP/GeoLite2-Country.mmdb \
     --statfile /usr/local/www/lf_static/webstatsLF24.json &> $LOG

  python3.11 -m a9x_webstatistics.gencockpit \
     --infile /usr/local/www/lf_static/webstatsLF24.json \
     --outfile /usr/local/www/lf_static/webstatsLF24.html &>> $LOG
  ```

  Cron-Job Entry for Linux / FreeBSD:
  ```bash

  13,58   *       *       *       *       dj1     /usr/local/www/cronjobs/cron_webstatistics.sh

  ```




  ```bash



  python -m venv c:\temp\webstatsenv


  c:\temp\webstatsenv\Scripts\activate.bat


  pip install a9x-webstatistics
  python -m pip install --upgrade pip
  python -m pip list
  ```



  ```bash

  c:
  cd \temp
  wget -URI https://www.logikfabrik.com/wlog/access.log -OutFile access.log


  c:\temp\webstatsenv\Scripts\activate.bat



  python -m a9x_webstatistics.main --infile access.log --statfile webstatsLF.json


  python -m a9x_webstatistics.gencockpit --infile webstatsLF.json --outfile webstatsLF.html
  ```


pkgId: 073e831b08b6c94818cae087d716a06a9e2d9a7473b95b3a485b949873e8cf15
name: python-a9x-webstatistics
arch: src
version: 1.1.30
epoch: 0
release: 1
summary: Web Statistics and Analytics Package
url: https://github.com/ava007/a9x-webstatistics
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-a9x-webstatistics-1.1.30-1.src.rpm
checksum_type: sha256
description:
  This package produces web statistics and analytical output based on nginx access log files.

  [![PyPI package](https://img.shields.io/badge/pip%20install-a9x_webstatistics-brightgreen)](https://pypi.org/project/a9x-webstatistics/) [![version number](https://img.shields.io/pypi/v/a9x_webstatistics?color=green&label=version)](https://github.com/ava007/a9x-webstatistics/releases) [![Actions Status](https://github.com/ava007/a9x-webstatistics/workflows/Test/badge.svg)](https://github.com/ava007/a9x-webstatistics/actions) [![License](https://img.shields.io/badge/license-own-blue)](https://github.com/ava007/a9x-webstatistics/blob/main/LICENSE)

  [![Downloads](https://img.shields.io/pypi/dm/a9x-webstatistics)](https://pypistats.org/packages/a9x-webstatistics)
  [![Python](https://img.shields.io/pypi/pyversions/a9x-webstatistics)](https://pypi.org/project/a9x-webstatistics)



  Visit the live example on [logikfabrik.com](https://www.logikfabrik.com/webstatsLF24.html).

  <img src="https://github.com/ava007/a9x-webstatistics/blob/main/a9x-webstatistics_20241123.png">



  ```bash
  pip install a9x-webstatistics
  ```



  - nginx standard access log file
  - python3.9 onwards
  - optional: maxmind db which need to be download by end user after registration




  ```bash


  export LOG=/usr/local/www/webstats.log
  export PATH=/usr/local/www/django5/envpy311/bin:$PATH

  python3.11 -m a9x_webstatistics.main \
     --infile /var/log/nginx-access.log \
     --geoip /usr/local/share/GeoIP/GeoLite2-Country.mmdb \
     --domain https://www.logikfabrik.com \
     --statfile /usr/local/www/lf_static/webstatsLF24.json &> $LOG

  python3.11 -m a9x_webstatistics.gencockpit \
     --infile /usr/local/www/lf_static/webstatsLF24.json \
     --outfile /usr/local/www/lf_static/webstatsLF24.html &>> $LOG
  ```

  Cron-Job Entry for Linux / FreeBSD:
  ```bash

  13,58   *       *       *       *       dj1     /usr/local/www/cronjobs/cron_webstatistics.sh

  ```




  ```bash



  python -m venv c:\temp\webstatsenv


  c:\temp\webstatsenv\Scripts\activate.bat


  pip install a9x-webstatistics
  python -m pip install --upgrade pip
  python -m pip list
  ```



  ```bash

  c:
  cd \temp
  wget -URI https://www.logikfabrik.com/wlog/access.log -OutFile access.log


  c:\temp\webstatsenv\Scripts\activate.bat



  python -m a9x_webstatistics.main --infile access.log --statfile webstatsLF.json


  python -m a9x_webstatistics.gencockpit --infile webstatsLF.json --outfile webstatsLF.html
  ```



  ```bash


  export LOG=/usr/local/www/webstats.log
  export PATH=/usr/local/www/django5/envpy311/bin:$PATH

  _YEARNUM="$(date +'%Y')";
  _MONTHNUM="$(date +'%m')";


  cp /usr/local/www/lf_static/webstatsLF24.json /usr/local/www/lf_static/webstatsLF24$_YEARNUM$_MONTHNUM.json
  cp /usr/local/www/lf_static/webstatsLF24.html /usr/local/www/lf_static/webstatsLF24$_YEARNUM$_MONTHNUM.html


  pip install -U `pip list --outdated | awk 'NR > 2 {print $1}'` >> $LOG


  python3.11 -m a9x_webstatistics.main \
     --infile /var/log/nginx-access.log \
     --geoip /usr/local/share/GeoIP/GeoLite2-Country.mmdb \
     --domain https://www.logikfabrik.com \
     --statfile /usr/local/www/lf_static/webstatsLF24.json &> $LOG

  python3.11 -m a9x_webstatistics.gencockpit \
     --infile /usr/local/www/lf_static/webstatsLF24.json \
     --outfile /usr/local/www/lf_static/webstatsLF24.html &>> $LOG
  ```


pkgId: 8b3bee038cea2d1dbcd0b58dea89bc1c5e25e926274b1c773b7bcc5fe1a78a28
name: python-aCrypt
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Ciphering made easy.
url: https://repl.it/@ChezCoder/aCrypt
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aCrypt-0.1.7-1.src.rpm
checksum_type: sha256
description:
  Ciphering made easy.


  - Encode a string into numbers using a secret key
  - Decode encoded strings into their original form using a secret key
  - Generate a valid aCrypt key


  | Usage          | Params                   | Return Value      |
  | :------------- | :----------------------- | :---------------- |
  | `create_key()` | `None: None`             | `int: key`        |
  | `cipher()`     | `str: message, int: key` | `str: ciphered`   |
  | `decipher()`   | `str: message, int: key` | `str: deciphered` |


  Lets say you have private JSON data that you need to encode:
  ```python

  data = {
      "username": "ilovecats",
      "password": "meow123"
  }
  ```

  Of course though, writing this un-encoded data can be very unsafe. So the only way to protect it is to cipher it.
  ```python
  from json import dumps, loads
  from os import getenv

  data = {
      "username": "ilovecats",
      "password": "meow123"
  }


  data = dumps(data)


  encoded_data = cipher(data, os.getenv("CIPHER_KEY")) # you can also keep the key in a variable, thought this is unsafe as users can just use the key


  print(encoded_data)
  ```

  And to decipher the data and use it, you can do the reverse:

  ```python
  from json import dumps, loads
  from os import getenv


  decoded_data = decipher(encoded_data, os.getenv("CIPHER_KEY"))


  data = loads(decoded_data)


  print("Your username is" + data.username + "!")
  ```


  - Thank you to the repl.it community for providing such amazing services for free.
  - Thank you to Atticus Kuhn for pointing out safety concerns on the project.
  - Thank you to AmazingMech2418 (https://repl.it/@AmazingMech2418), for showing me the world of cryptography.
  - Thank you StealthHydra179 (https://repl.it/@StealthHydra179), for being the only person who cared about programming in my school.
  - Thank you Giothecoder (https://repl.it/@Giothecoder), for being there when I needed you most.



  - 0.0.1 - Cipher was added, deciphering was unfinished
  - 0.0.2 - Deciphering finished with lots of bugs
  - 0.0.3 - Atticus Kuhn pointed out a safety bug, and thus it was patched
  - 0.0.4 - Bugs fixes
  - 0.0.5 - Added Credits
  - 0.0.6 - AmazingMech2418 pointed out huge safety feature that should be added
  - 0.0.7 - Bugs fixes
  - 0.0.8 - Test Version
  - 0.0.9 - Test Version
  - 0.1.0 - Update 0.0.6 was revisited and implemented
  - 0.1.1 - Added changelog
  - 0.1.3 - Bug fixes
  - 0.1.4 - Made key generation more efficient
  - 0.1.5 - Added examples


pkgId: c02ae13f11206959a1661c55782db3a0c13da42e1481d048de4d62bae91b35d8
name: python-aEye
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Extensible Video Processing Framework
url: https://github.com/DISHDevEx/aEye
rpm_license: Dish Wireless
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aEye-1.2.4-1.src.rpm
checksum_type: sha256
description:
  Extensible Video Processing Framework with Additional Features Continuously Deployed



  ```
  ├──  aEye				contains video class and processor class that manage from loading, processing and uploading
  │   ├── video.py
  |   ├── auxiliary.py
  |   ├── extractor.py
  |   ├── labeler.py
  │   ├── auxiliary.py
  ├──  tests				contains unit tests
  │   ├── test_get_meta_data.py
  │   ├── conftest.py
  │   ├── test_data
  │      ├── test_video.mp4
  ├── setup.py
  ```



  1. clone/pull this repo to local machine

  ```console
  git clone https://github.com/DISHDevEx/aEye.git
  ```

  2. Run the following command to create the wheel file

  ```console
  python setup.py bdist_wheel --version <VERSION_NUMBER>
  ```
  **NOTE**: the ***<VERSION_NUMBER>*** only effects your local build.  You can use any version number you like.  This can be helpful in testing prior to submitting a pull request.  Alternatively, you can eclude the ***--version <VERSION_NUMBER>*** flag and the .whl file name will output as ***aEye-_VERSION_PLACEHOLDER_-py3-none-any.whl***

  3. Install the necessary requirements and wheel file

  ```console
  !pip install -r requirements.txt
  !pip install *.whl
  ```

  4. Run below to import in jyputer-notebook

  ```console
  import boto3
  import cv2
  from aEye.video import Video
  from aEye.auxiliary import Aux
  from aEye.labeler import Labeler
  from aEye.extractor import Extractor
  ```

  5. Initalize the auxiliary class. This creates a temporary directory for output files

  ```console
  aux = Aux()

  ```

  6. Load the video from the desired bucket and folder.

  ```console
  video_list_s3 = aux.load_s3(bucket = 'aeye-data-bucket', prefix = 'input_video/')
  ```


  7. Initalize the labeler and extractor

  ```console
  label = Labeler()


  extract = Extractor()

  ```


  How to process videos using Labeler and Extractor:

  The labeler provides multiple actions that can be applied to a video or a list of videos. Each action takes a video or list of videos as its first parameter and returns a modified video or list of videos.
  To chain multiple labels together, you can pass the output of one process as the input for the next process.

  Example:
  ```console

  to_process = label.trim_video_start_end(video_list_s3, 1, 9)


  to_process = label.trim_num_frames(to_process, 10, 60)


  output_video_list = aux.execute_label_and_write_local(to_process)


  ```

  If you want to create two different trims, you will need to execute via Aux in between those two operations:

  ```console

  to_process = label.trim_video_start_end(video_list_s3, 1, 9)
  processed = aux.execute_label_and_write_local(to_process)

  processed = label.trim_num_frames(processed, 10, 60)
  output_video_list = aux.execute_label_and_write_local(processed)



  ```

  The image extractor can extract frames from a video using openCV!

  Important note: Image extraction is executed the moment it is called! If you want to extract frames with processing, you must execute the video processing commands first using aux.execute_label_and_write_local(video_list).

  Keep in mind that processor modifications are not applied until the aux.execute_label_and_write_local(list) command is performed. Any image extraction that happens prior to an execution will not have any modifications applied.
  The framework allows frames to be extracted at any point while processing, but if there are pending processor modifications, a warning will be raised, and the resulting images will come from the original source.
  The execution order affects frame capture.

  Example:


  ```console
  label.change_resolution(video_list_s3, "720p")
  extract.specific_frame_extractor(aux, video_list_s3, 42)  # These screenshots will NOT be in 720p
  aux.execute_label_and_write_local(video_list_s3)



  label.change_resolution(video_list_s3, "720p")
  output_list = aux.execute_label_and_write_local(to_process)
  process.cv_extract_specific_frame(output_list, 42)  # These screenshots WILL be in 720p!


  ```

  All Label Utility:
  ```console

  resize_by_ratio(x_ratio, y_ratio,target) -> Add label of resizing video by multiplying width by the ratio to video.

  change_resolution(video_list, desired_res) -> Changes the resolution to a 'standard' resolution.

  trim_video_start_end(video_list, start, end) -> Given start and end times in seconds, modified a trimmed down version of the video to the modified file.

  trim_into_clips(video_list, interval) -> Splits the video into X second clips, sends all these clips to output folder.

  trim_on_frame(video_list, frame) -> Given a specific frame, start the video there, removes any preceding frames.

  trim_num_frames(video_list, start_frame, num_frames) -> Given a start frame and the amount of frames that a user wants "
  to copy, splits the video to all of the frames within that frame range.

  crop_video_section(video_list, start_x, start_y, width, height) -> Create a width x height crop of the input video starting at pixel values"\
  start_x, start_y and sends the smaller video to the modified file.

  blur_video(video_list, blur_level, blur_steps) -> Adds the blur_level amount of blur blur_steps amount of times to a video.

  set_bitrate(video_list, desired_bitrate) -> Sets the bitrate at which the video will re-encode to.

  change_fps(video_list, new_framerate) -> Sets the framerate at which the video will re-encode. Note, reducing the
  bitrate in comparison to the original will result in a loss of some i/b frames, but the output duration will remain the same.

  grayscale(video_list) -> Applies a grayscale filter to all videos in video_list.
  ```

  All Extract Utility:
  ```console
  frame_at_time_extractor(aux, video_list, time) -> Given a time (can be a float), find the closest B-Frame and extract it

  specific_frame_extractor(aux, video_list, frame) -> Extract the exact frame you pass as a PNG

  multiple_frame_extractor(aux, video_list, start_frame, num_frames) -> Beginning at start_frame, extract the next num_frames
  ```

  Limitations:

  Please note the following limitations of the framework:

  Frames cannot be extracted from a source that has been previously executed in the processor pipeline.
  The TRIM_INTO_CLIPS operation must be executed last. It creates multiple output videos from a single input, and these outputs cannot be processed further.
  Here's an example of using the labeler utility to downsize, crop, and trim a video:


  ```console
  to_process = label.trim_video_start_end(video_list_s3, 1, 9)              #Trims from 1s to 9s

  to_process = label.change_resolution(to_process, "720p")                  #Converts to 720p

  final_video_list = label.crop_video_section(to_process, 0, 0, 150, 100)   #Creates a 150x100 crop at (0,0)
  ```


  8. Use auxiliary class to execute and write the videos with labels.

  ```console
  aux.execute_label_and_write_local(final_video_list)
  ```

  9. Processing can create a lot of files! After, if you don't want to upload the generated files, you can use the following command to clean up:
  ```console
  aux.clean()
  ```

  10. Finally, you can upload the processed videos to the desired bucket using the upload_s3 function:

  ```console
  aux.upload_s3(res_trimmed_s3, bucket = 'aeye-data-bucket')
  ```

  11. Finish by removing the temp folder.

  ```console
  aux.clean()
  ```

  The following steps are to load and write locally.

  12. Load video files from data/ folder

  ```console
  video_list_local = aux.load_local('data/')
  ```

  13. Add Trim label for the local video files.


  ```console
  trimmed_local = label.trim_on_frame(video_list_local, 501)


  ```

  14. Execute all labels and write the output to data/ folder.

  ```console
  aux.execute_label_and_write_local(trimmed_local,'data/')
  ```


pkgId: 76c7879f18adc36cbd8941803b2a28c5fb8f866aa0a789e49b8e310dc846c6c6
name: python-aRez
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Async Python HiRez API wrapper
url: https://github.com/DevilXD/aRez
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aRez-0.2.4-1.src.rpm
checksum_type: sha256
description:
  This project was created to simplify access to the API, as well as incorporate some data
  pre-processing and consistency. I am aware that [PyRez](https://github.com/luissilva1044894/Pyrez)
  already exists, however this project aims to do couple of things differently:

  - It's entirely async from the ground up, built using 'aiohttp'
  - Uses modern objective programming approach
  - Utilizes a local data cache to return data-rich objects

  This library is supposed to be used as a module.
  **As of right now, only PaladinsAPI is supported.** Smite support is planned - please read below.

  Currently supported:

  - [x] `getgods / getchampions` and `getitems` regarding god / champion
  and card / talent / shop item information
  - [x] `getplayer` (Player stats)
  - [x] `getplayerbatch` (Multiple player stats at once)
  - [x] `getplayeridbyname`, `getplayeridsbygamertag` and `searchplayers` under a single,
  intuitive method (Finding the players)
  - [x] `getfriends` (Player friends)
  - [x] `getgodranks / getchampionranks` (God / Champion stats)
  - [x] `getplayerloadouts` (Player loadouts for each god / champion)
  - [x] `getplayerstatus` (Player status)
  - [x] `getmatchhistory` (Player's recent matches)
  - [x] `getmatchdetails` (Match details, by the ID or from player's recent matches)
  - [x] `getplayeridbyportaluserid` (Finding the player by their Portal ID)
  - [x] `getmatchplayerdetails` (Information about the current player's match)
  - [ ] `getplayerachievements` (Player overall match stats)
  - [x] `getmatchdetailsbatch` (Fetching multiple matches at once)
  - [x] `getmatchidsbyqueue` (Fetching all matches by queue)
  - [x] `getqueuestats` (Player match stats by queue)

  There are plans on expanding the existing framework to incorporate the above and below:

  - [x] Adding documentation
  - [ ] Support for SmiteAPI (support Smite endpoint URL)
      - [ ] Support for Teams
          - [ ] Support for `getteamdetails` endpoint
          - [ ] Support for `getteamplayers` endpoint
          - [ ] Support for `searchteams` endpoint

  If you have some experience with Smite and it's API, and would be interested in working with me
  together on expanding this project, please don't hessitate to contact me
  (you can find contact information below).



  - Python 3.8+
  - aiohttp 2.0+



  - [aRez Documentation](https://arez.readthedocs.io/en/latest/)
  - [Official HiRez API Documentation](
      https://docs.google.com/document/d/1OFS-3ocSx-1Rvg4afAnEHlT3917MAK_6eJTR6rzr-BM
  )



  Please see [example.py](https://github.com/DevilXD/aRez/blob/master/example.py) for more examples.

  ```py
  import asyncio

  import arez  # import the wrapper

  DEV_ID = 1234  # your Developer ID (example)
  AUTH_KEY = "L2U3M60A03662R24UKOMY0FIT4S2IBKU"  # your Auth Key (example)

  async def main():
      
      api = arez.PaladinsAPI(DEV_ID, AUTH_KEY)
      
      player = await api.get_player(5959045)
      
      print(player.ranked_best.rank.name)
      
      await api.close()

  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())  # run the async loop
  ```



  <div align="center">

  [![Buy me a coffee](https://i.imgur.com/cL95gzE.png)](
      https://www.buymeacoffee.com/DevilXD
  )
  [![Support me on Patreon](https://i.imgur.com/Mdkb9jq.png)](
      https://www.patreon.com/bePatron?u=26937862
  )

  </div>



  Reddit: https://www.reddit.com/u/DevilXD

  Discord: `DevilXD#4437`



  This is an alpha version - as of right now, everything is a subject to change.
  Once both Paladins and Smite (and maybe Realm Royale) APIs are supported, this wrapper is going to
  have it's v1.0 release, and I will try to manage the versioning the proper way from there.


pkgId: 505222a2d685df1954c31e628192dcd06b672464763572ebc4b843450489b88e
name: python-aStarEngine-package
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A package to find the shortest path in a map with up to 5 intermediate stops, using A*
url: https://github.com/Sathyanarayanan-ops/map_engine
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aStarEngine-package-1.0.0-1.src.rpm
checksum_type: sha256
description:
  map_engine is a Python package designed to calculate the shortest route between a start and end location, with support for up to 5 additional stops. It leverages the A* algorithm for efficient pathfinding and is ideal for applications requiring custom routing logic over a road network.

  Features

  Single-destination routing: Quickly calculate the shortest path between two locations.
  Multi-stop routing: Add up to 5 additional stops to your route.
  Flexible inputs: Provide locations as an ordered list of addresses or coordinates.
  Modular design: Well-structured modules for algorithms, utilities, and visualizations.
  Integration-ready: Easily integrate with frontend applications, providing optimized routes.

  Use following code to start using the pkg
  ```python

  from aStarEngine_package.algorithms.aStar_multi import astar_pathfind_multi_stop

  from aStarEngine_package.utils.routing import Routing


  graph_path = "data/LA_road_network.graphml"
  router = Routing(graph_path)


  locations = ["Venice Beach", "Staples Center", "Griffith Observatory"]
  route = router.get_route(locations)
  print("Multi-stop path:", route)


  ```


pkgId: c2295b1ae5d5fb00d793ad2fcd69fe0276606c651b87339484487a59347dba52
name: python-aTeam-PySparkLibrary
arch: src
version: 0.0.46
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/EgdeConsulting/aTeam-PySparkLibrary
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aTeam-PySparkLibrary-0.0.46-1.src.rpm
checksum_type: sha256
description:
  Pakkebibliotek laget av Edges A-Team som er distribuert via PYPI og som inneholder våre gjenbrukbare PySpark-funksjoner.

  Biblioteket heter ``aTeam-PySparkLibrary`` i PYPI.

  Dokumentasjon finner du på [denne Confluence-siden.](https://egdeservice.atlassian.net/wiki/spaces/SMIA/pages/431095809/PySparkLibrary)


pkgId: 2e44a2b2850858ea4deb29099a96e9365bc93078af41863ec23bc07a23a1366d
name: python-aa-alumni
arch: src
version: 0.2.0
epoch: 0
release: 1
url: https://gitlab.com/tactical-supremacy/aa-alumni
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aa-alumni-0.2.0-1.src.rpm
checksum_type: sha256
summary:
  Integration with Alliance Auths State System, creates and maintains an Alumni State for past members of an Alliance and/or Corporation

description:
  - Integration with Alliance Auth's State System, creates and maintains an Alumni State for past members of an Alliance and/or Corporation.





  Remove/Promote any state with a priority of `1`, Alumni is considered slightly better than the built in Guest State.



  ```shell
  pip install aa-alumni
  ```



  Configure your Auth settings (`local.py`) as follows:

  - Add `'alumni'` to `INSTALLED_APPS`
  - Add below lines to your settings file:

  ```python


  CELERYBEAT_SCHEDULE['alumni_run_alumni_check_all'] = {
      'task': 'alumni.tasks.run_alumni_check_all',
      'schedule': crontab(minute=0, hour=0, day_of_week=4),
  }
  CELERYBEAT_SCHEDULE['alumni_run_update_all_models'] = {
      'task': 'alumni.tasks.update_all_models',
      'schedule': crontab(minute=0, hour=0, day_of_week=3),
  }
  ```



  ```shell
  python myauth/manage.py alumni_state
  ```



  - Run migrations `python manage.py migrate`
  - Gather your staticfiles `python manage.py collectstatic`
  - Restart your project `supervisorctl restart myauth:`



  In the Admin interface, visit `alumni > config > add` or `<AUTH-URL>/admin/alumni/config/add/`
  Select the Alliances and/or Corporations for which characters with historical membership are Alumni



  Make sure you have signed the [License Agreement](https://developers.eveonline.com/resource/license-agreement) by logging in at <https://developers.eveonline.com> before submitting any pull requests. All bug fixes or features must not include extra superfluous formatting changes.


pkgId: 435937bcd030d226086b4ab37203fe20cca65a48e1457f5fc0fe951002d3b2a8
name: python-aa-alumni
arch: src
version: 0.3.0
epoch: 0
release: 1
url: https://gitlab.com/tactical-supremacy/aa-alumni
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aa-alumni-0.3.0-1.src.rpm
checksum_type: sha256
summary:
  Integration with Alliance Auths State System, creates and maintains an Alumni State for past members of an Alliance and/or Corporation

description:
  - Integration with Alliance Auth's State System, creates and maintains an Alumni State for past members of an Alliance and/or Corporation.





  Remove/Promote any state with a priority of `1`, Alumni is considered slightly better than the built in Guest State.



  ```shell
  pip install aa-alumni
  ```



  Configure your Auth settings (`local.py`) as follows:

  - Add `'alumni'` to `INSTALLED_APPS`
  - Add below lines to your settings file:

  ```python


  CELERYBEAT_SCHEDULE['alumni_run_alumni_check_all'] = {
      'task': 'alumni.tasks.run_alumni_check_all',
      'schedule': crontab(minute=37, hour=3, day_of_week=4),
  }
  CELERYBEAT_SCHEDULE['alumni_run_update_all_models'] = {
      'task': 'alumni.tasks.update_all_models',
      'schedule': crontab(minute=37, hour=3, day_of_week=3),
  }
  ```



  ```shell
  python myauth/manage.py alumni_state
  ```



  - Run migrations `python manage.py migrate`
  - Gather your staticfiles `python manage.py collectstatic`
  - Restart your project `supervisorctl restart myauth:`



  In the Admin interface, visit `alumni > config > add` or `<AUTH-URL>/admin/alumni/config/add/`
  Select the Alliances and/or Corporations for which characters with historical membership are Alumni



  | Name | Description | Default |
  | --- | --- | --- |
  |`ALUMNI_CHARACTERCORPORATION_RATELIMIT`| Celery Rate Limit _per worker_, 10 tasks * 10 Workers = 100 tasks/min | '10/m' |



  Make sure you have signed the [License Agreement](https://developers.eveonline.com/resource/license-agreement) by logging in at <https://developers.eveonline.com> before submitting any pull requests. All bug fixes or features must not include extra superfluous formatting changes.


pkgId: 82f48c4946369f916e18b52c6eaff4ca0bc1981f12fda3c2049347ec0d326474
name: python-aa-blueprints
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Blueprint Library plugin for Alliance Auth.
url: https://gitlab.com/eclipse-expeditions/aa-blueprints
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aa-blueprints-1.7.0-1.src.rpm
checksum_type: sha256
description:
  This is an blueprints library app for [Alliance Auth](https://gitlab.com/allianceauth/allianceauth) (AA) that can be used to list blueprints for your corporation or alliance.

  ![release](https://img.shields.io/pypi/v/aa-blueprints?label=release)
  ![License](https://img.shields.io/badge/license-GPL-green)
  ![python](https://img.shields.io/pypi/pyversions/aa-blueprints)
  ![django](https://img.shields.io/pypi/djversions/aa-blueprints?label=django)
  ![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)
  ![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)





  - Lists all blueprints owned by corporation or alliance (configurable with permissions)
  - Manage user requests for making copies of blueprints

  >**Hint**<br>Blueprints sends Auth notifications to inform users about blueprint requests. If you like to get those as direct messages on Discord please consider also installing [Discord Notify](https://gitlab.com/ErikKalkoken/aa-discordnotify).





  ![library](https://i.imgur.com/62eUbB8.png)



  ![view-blueprint](https://i.imgur.com/g8ge0gA.png)



  ![create-request](https://i.imgur.com/MSt7mZg.png)



  ![my-requests](https://i.imgur.com/0Tj5jo6.png)



  ![open-requests](https://i.imgur.com/pQMuLEQ.png)



  ![manage-blueprints](https://i.imgur.com/ap1vc4h.png)





  AA Blueprints needs the app [django-eveuniverse](https://gitlab.com/ErikKalkoken/django-eveuniverse) to function. Please make sure it is installed before before continuing.





  Make sure you are in the virtual environment (venv) of your Alliance Auth installation. Then install the newest release from PyPI:

  `pip install aa-blueprints`



  - Add 'blueprints' to `INSTALLED_APPS` in `settings/local.py`.
  - Add the following automated task definition:

  ```python
  CELERYBEAT_SCHEDULE['blueprints_update_all_blueprints'] = {
      'task': 'blueprints.tasks.update_all_blueprints',
      'schedule': crontab(minute=0, hour='*/3'),
  }
  CELERYBEAT_SCHEDULE['blueprints_update_all_industry_jobs'] = {
      'task': 'blueprints.tasks.update_all_industry_jobs',
      'schedule': crontab(minute=0, hour='*'),
  }
  CELERYBEAT_SCHEDULE['blueprints_update_all_locations'] = {
      'task': 'blueprints.tasks.update_all_locations',
      'schedule': crontab(minute=0, hour='*/12'),
  }
  ```



  Run migrations & copy static files:

  ```bash
  python manage.py migrate
  python manage.py collectstatic
  ```

  Restart your supervisor services for Auth



  Update the Eve Online API app used for authentication in your AA installation to include the following scopes:

  - `esi-assets.read_assets.v1`
  - `esi-assets.read_corporation_assets.v1`
  - `esi-characters.read_blueprints.v1`
  - `esi-corporations.read_blueprints.v1`
  - `esi-industry.read_character_jobs.v1`
  - `esi-industry.read_corporation_jobs.v1`
  - `esi-universe.read_structures.v1`



  Load EVE Online type data from ESI:

  ```bash
  python manage.py blueprints_load_types
  ```



  | ID                               | Description                                  | Notes                                                                          |
  |----------------------------------|----------------------------------------------|--------------------------------------------------------------------------------|
  | `basic_access`                   | Can access this app                          |                                                                                |
  | `request_blueprints`             | Can request blueprints                       |                                                                                |
  | `manage_requests`                | Can review and accept blueprint requests     |                                                                                |
  | `add_personal_blueprint_owner`   | Can add personal blueprint owners            |                                                                                |
  | `add_corporate_blueprint_owner`  | Can add corporate blueprint owners           | :warning: Should only be given to directors or the CEO.                        |
  | `view_alliance_blueprints`       | Can view alliance's blueprints               |                                                                                |
  | `view_industry_jobs`             | Can view details about running industry jobs | :warning: This permission will let someone see _all_ industry job information. |



  See [UPGRADING.md](UPGRADING.md).



  The main authors (in alphabetical order):

  - [Erik Kalkoken](https://gitlab.com/ErikKalkoken)
  - [Rebecca Claire Murphy](https://gitlab.com/rcmurphy), aka Myrhea
  - [Peter Pfeufer](https://gitlab.com/ppfeufer), aka Rounon Dax


pkgId: a16923782aa24d104e31de235f055dd6f3e97cf6f06ac90bba5980025795b34f
name: python-aa-bulletin-board
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: A simple bulletin board for Alliance Auth
url: https://github.com/ppfeufer/aa-bulletin-board
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aa-bulletin-board-2.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Version](https://img.shields.io/pypi/v/aa-bulletin-board?label=release)](https://pypi.org/project/aa-bulletin-board/)
  [![License](https://img.shields.io/github/license/ppfeufer/aa-bulletin-board)](https://github.com/ppfeufer/aa-bulletin-board/blob/master/LICENSE)
  [![Python](https://img.shields.io/pypi/pyversions/aa-bulletin-board)](https://pypi.org/project/aa-bulletin-board/)
  [![Django](https://img.shields.io/pypi/djversions/aa-bulletin-board?label=django)](https://pypi.org/project/aa-bulletin-board/)
  ![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/ppfeufer/aa-bulletin-board/master.svg)](https://results.pre-commit.ci/latest/github/ppfeufer/aa-bulletin-board/master)
  [![Code Style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](http://black.readthedocs.io/en/latest/)
  [![Discord](https://img.shields.io/discord/790364535294132234?label=discord)](https://discord.gg/zmh52wnfvM)
  [![Automated Checks](https://github.com/ppfeufer/aa-bulletin-board/actions/workflows/automated-checks.yml/badge.svg)](https://github.com/ppfeufer/aa-bulletin-board/actions/workflows/automated-checks.yml)
  [![codecov](https://codecov.io/gh/ppfeufer/aa-bulletin-board/branch/master/graph/badge.svg?token=UCXABR42QC)](https://codecov.io/gh/ppfeufer/aa-bulletin-board)
  [![Translation status](https://weblate.ppfeufer.de/widget/alliance-auth-apps/aa-bulletin-board/svg-badge.svg)](https://weblate.ppfeufer.de/engage/alliance-auth-apps/)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](https://github.com/ppfeufer/aa-forum/blob/master/CODE_OF_CONDUCT.md)

  [![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/N4N8CL1BY)

  Simple bulletin board for [Alliance Auth](https://gitlab.com/allianceauth/allianceauth)

  ______________________________________________________________________

  <!-- mdformat-toc start --slug=github --maxlevel=6 --minlevel=1 -->

  - [AA Bulletin Board](#aa-bulletin-board)
    - [Before You Install This Module](#before-you-install-this-module)
    - [Installation](#installation)
      - [Step 1: Install the Package](#step-1-install-the-package)
      - [Step 2: Configure Alliance Auth](#step-2-configure-alliance-auth)
        - [Settings in `/home/allianceserver/myauth/myauth/settings/local.py`](#settings-in-homeallianceservermyauthmyauthsettingslocalpy)
        - [Settings in `/home/allianceserver/myauth/myauth/urls.py`](#settings-in-homeallianceservermyauthmyauthurlspy)
      - [Step 3: Configure Your Webserver](#step-3-configure-your-webserver)
        - [Apache](#apache)
        - [Nginx](#nginx)
      - [Step 4: Finalizing the Installation](#step-4-finalizing-the-installation)
      - [Step 5: Set Up Permissions](#step-5-set-up-permissions)
    - [Permissions](#permissions)
    - [Changelog](#changelog)
    - [Translation Status](#translation-status)
    - [Contributing](#contributing)

  <!-- mdformat-toc end -->

  ______________________________________________________________________

  ![AA Bulletin Board](https://raw.githubusercontent.com/ppfeufer/aa-bulletin-board/master/docs/images/presentation/aa-bulletin-board.jpg "AA Bulletin Board")



  This app needs quite some configuration done before working properly. You need to
  modify your Apache/Nginx configuration as well as the global URL config of Alliance
  Auth. So please only install if you know what you're doing/feel comfortable to make
  these kinds of changes. For your own sanity, and mine :-)



  > \[!NOTE\]
  >
  > **AA Bulletin Board >=2.0.0 needs at least Alliance Auth v4.0.0!**
  >
  > Please make sure to update your Alliance Auth instance _before_ you install this
  > module or update to the latest version, otherwise an update to Alliance Auth will
  > be pulled in unsupervised.
  >
  > The last version compatible with Alliance Auth v3 is `1.13.2`.

  **Important**: Please make sure you meet all preconditions before you proceed:

  - AA Bulletin Board is a plugin for Alliance Auth. If you don't have Alliance Auth
    running already, please install it first before proceeding. (see the official
    [AA installation guide](https://allianceauth.readthedocs.io/en/latest/installation/allianceauth.html)
    or details)
  - Aa Bulletin Board needs a couple of changes made to your Webserver and Alliance
    Auth configuration. So make sure you know how to do so. The steps needed will be
    described in this document, but you need to understand what will be changed.



  Make sure you're in the virtual environment (venv) of your Alliance Auth
  installation Then install the latest release directly from PyPi.

  ```shell
  pip install aa-bulletin-board
  ```





  This is fairly simple, configure your AA settings (`local.py`) as follows:

  ```python

  INSTALLED_APPS += [
      "django_ckeditor_5",  # https://github.com/hvlads/django-ckeditor-5
      "aa_bulletin_board",  # https://github.com/ppfeufer/aa-bulletin-board
  ]


  if "django_ckeditor_5" in INSTALLED_APPS:
      
      CKEDITOR_5_FILE_UPLOAD_PERMISSION = (
          "authenticated"  # Possible values: "staff", "authenticated", "any"
      )

      MEDIA_URL = "/media/uploads/"
      MEDIA_ROOT = "/var/www/myauth/media/uploads"

      customColorPalette = [
          {"color": "hsl(4, 90%, 58%)", "label": "Red"},
          {"color": "hsl(340, 82%, 52%)", "label": "Pink"},
          {"color": "hsl(291, 64%, 42%)", "label": "Purple"},
          {"color": "hsl(262, 52%, 47%)", "label": "Deep Purple"},
          {"color": "hsl(231, 48%, 48%)", "label": "Indigo"},
          {"color": "hsl(207, 90%, 54%)", "label": "Blue"},
      ]

      CKEDITOR_5_CONFIGS = {
          "default": {
              "toolbar": [
                  "heading",
                  "|",
                  "bold",
                  "italic",
                  "link",
                  "bulletedList",
                  "numberedList",
                  "blockQuote",
              ],
          },
          "extends": {
              "blockToolbar": [
                  "paragraph",
                  "heading1",
                  "heading2",
                  "heading3",
                  "|",
                  "bulletedList",
                  "numberedList",
                  "|",
                  "blockQuote",
              ],
              "toolbar": [
                  "heading",
                  "|",
                  "outdent",
                  "indent",
                  "|",
                  "bold",
                  "italic",
                  "link",
                  "underline",
                  "strikethrough",
                  "subscript",
                  "superscript",
                  "highlight",
                  "|",
                  "insertImage",
                  "mediaEmbed",
                  "|",
                  "bulletedList",
                  "numberedList",
                  "todoList",
                  "insertTable",
                  "|",
                  "blockQuote",
                  "codeBlock",
                  "|",
                  "fontSize",
                  "fontFamily",
                  "fontColor",
                  "fontBackgroundColor",
                  "removeFormat",
                  "|",
                  "sourceEditing",
              ],
              "image": {
                  "toolbar": [
                      "imageTextAlternative",
                      "|",
                      "imageStyle:alignLeft",
                      "imageStyle:alignRight",
                      "imageStyle:alignCenter",
                      "imageStyle:side",
                      "|",
                  ],
                  "styles": [
                      "full",
                      "side",
                      "alignLeft",
                      "alignRight",
                      "alignCenter",
                  ],
              },
              "table": {
                  "contentToolbar": [
                      "tableColumn",
                      "tableRow",
                      "mergeTableCells",
                      "tableProperties",
                      "tableCellProperties",
                  ],
                  "tableProperties": {
                      "borderColors": customColorPalette,
                      "backgroundColors": customColorPalette,
                  },
                  "tableCellProperties": {
                      "borderColors": customColorPalette,
                      "backgroundColors": customColorPalette,
                  },
              },
              "heading": {
                  "options": [
                      {
                          "model": "paragraph",
                          "title": "Paragraph",
                          "class": "ck-heading_paragraph",
                      },
                      {
                          "model": "heading1",
                          "view": "h1",
                          "title": "Heading 1",
                          "class": "ck-heading_heading1",
                      },
                      {
                          "model": "heading2",
                          "view": "h2",
                          "title": "Heading 2",
                          "class": "ck-heading_heading2",
                      },
                      {
                          "model": "heading3",
                          "view": "h3",
                          "title": "Heading 3",
                          "class": "ck-heading_heading3",
                      },
                  ]
              },
          },
          "list": {
              "properties": {
                  "styles": "true",
                  "startIndex": "true",
                  "reversed": "true",
              }
          },
      }
  ```



  Now let's move on to editing the global URL configuration of Alliance Auth. To do so,
  you need to open `/home/allianceserver/myauth/myauth/urls.py` and change the
  following block right before the `handler` definitions:

  ```python
  from django.apps import apps  # Only if not already imported earlier
  from django.conf import settings  # Only if not already imported earlier
  from django.conf.urls.static import static  # Only if not already imported earlier
  from django.urls import path  # Only if not already imported earlier


  if apps.is_installed("django_ckeditor_5"):
      
      urlpatterns = (
          [
              path("ckeditor5/", include("django_ckeditor_5.urls")),
          ]
          + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
          + urlpatterns
      )
  ```

  After this, your `urls.py` should look similar to this:

  ```python
  from django.apps import apps
  from django.conf import settings
  from django.conf.urls.static import static
  from django.urls import include, path, re_path

  from allianceauth import urls


  urlpatterns = [
      path(r"", include(urls)),
  ]


  if apps.is_installed("django_ckeditor_5"):
      
      urlpatterns = (
          [
              path("ckeditor5/", include("django_ckeditor_5.urls")),
          ]
          + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
          + urlpatterns
      )

  handler500 = "allianceauth.views.Generic500Redirect"
  handler404 = "allianceauth.views.Generic404Redirect"
  handler403 = "allianceauth.views.Generic403Redirect"
  handler400 = "allianceauth.views.Generic400Redirect"
  ```



  Your webserver needs to know from where to serve the uploaded images, of course, so we
  have to tell it.



  In your vhost configuration you have a line `ProxyPassMatch ^/static !`, which tells
  the server where to find all the static files. We're adding a similar line for the
  media, right below that one.

  Add the following right below the static proxy match:

  ```apache
  ProxyPassMatch ^/media !
  ```

  Now we also need to let the server know where to find the media directory we just
  configured the proxy for. To do so, add a new Alias to your configuration. This can
  be done right below the already existing Alias for `/static`:

  ```apache
  Alias "/media" "/var/www/myauth/media/"
  ```

  At last, a Directory rule is needed as well. Add the following code below to the
  already existing Directory rule for the static files:

  ```apache
  <Directory "/var/www/myauth/media/">
      Require all granted
  </Directory>
  ```

  So the whole block should now look like this:

  ```apache
  ProxyPassMatch ^/static !
  ProxyPassMatch ^/media !  # *** NEW proxy rule
  ProxyPass / http://127.0.0.1:8000/
  ProxyPassReverse / http://127.0.0.1:8000/
  ProxyPreserveHost On

  Alias "/static" "/var/www/myauth/static/"
  Alias "/media" "/var/www/myauth/media/"

  <Directory "/var/www/myauth/static/">
      Require all granted
  </Directory>

  <Directory "/var/www/myauth/media/">
      Require all granted
  </Directory>
  ```

  Restart your Apache webserver.



  In order to let Nginx know where to find the uploaded files, you need to add a new
  location rule to the configuration.

  ```nginx
  location /media {
      alias /var/www/myauth/media;
      autoindex off;
  }
  ```

  Restart your Nginx webserver.



  Run static files collection and migrations

  ```shell
  python manage.py collectstatic
  python manage.py migrate
  ```

  Restart your supervisor services for Auth



  Now it's time to set up access permissions for your new module. You can do so in
  your admin backend. Read the [Permissions](#permissions) section for more information
  about the available permissions.



  | ID                 | Description                   | Notes                                                                           |
  | :----------------- | :---------------------------- | :------------------------------------------------------------------------------ |
  | `basic_access`     | Can access the Bulletin Board | Grants read access to the bulletin board                                        |
  | `manage_bulletins` | Can manage bulletins          | Grants the right to edit and delete existing bulletins and create new bulletins |



  See [CHANGELOG.md](https://github.com/ppfeufer/aa-bulletin-board/blob/master/CHANGELOG.md)



  [![Translation status](https://weblate.ppfeufer.de/widget/alliance-auth-apps/aa-bulletin-board/multi-auto.svg)](https://weblate.ppfeufer.de/engage/alliance-auth-apps/)

  Do you want to help translate this app into your language or improve the existing
  translation? - [Join our team of translators][weblate engage]!



  Do you want to contribute to this project? That's cool!

  Please make sure to read the [Contribution Guidelines].\
  (I promise, it's not much, just some basics)

  <!-- Links -->

  [contribution guidelines]: https://github.com/ppfeufer/aa-bulletin-board/blob/master/CONTRIBUTING.md "Contribution Guidelines"
  [weblate engage]: https://weblate.ppfeufer.de/engage/alliance-auth-apps/ "Weblate Translations"

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  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 state 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 3 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, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) <year>  <name of author> This program 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, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU 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.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


