# packages

pkgId: 55b333a3a379ab423dbef3c484d6ccc55c01fec643e4f6b124ed28bd01f87030
name: python-2captcha-python
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Python module for easy integration with 2Captcha API
url: https://github.com/2captcha/2captcha-python/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-54b72e9b-ca82-4779-ac71-53de330e2432
location_href: 00009594-python-2captcha-python/python-2captcha-python-1.2.0-1.src.rpm
checksum_type: sha256
description:
  The easiest way to quickly integrate [2Captcha] captcha solving service into your code to automate solving of any types of captcha.

  - [Python Module for 2Captcha API](#python-module-for-2captcha-api)
    - [Installation](#installation)
    - [Configuration](#configuration)
      - [TwoCaptcha instance options](#twocaptcha-instance-options)
    - [Solve captcha](#solve-captcha)
      - [Captcha options](#captcha-options)
      - [Normal Captcha](#normal-captcha)
      - [Text Captcha](#text-captcha)
      - [ReCaptcha v2](#recaptcha-v2)
      - [ReCaptcha v3](#recaptcha-v3)
      - [FunCaptcha](#funcaptcha)
      - [GeeTest](#geetest)
      - [hCaptcha](#hcaptcha)
      - [GeeTest v4](#geetest-v4)
      - [Lemin Cropped Captcha](#lemin-cropped-captcha)
      - [Cloudflare Turnstile](#cloudflare-turnstile)
      - [Amazon WAF](#amazon-waf)
      - [KeyCaptcha](#keycaptcha)
      - [Capy](#capy)
      - [Grid](#grid)
      - [Canvas](#canvas)
      - [ClickCaptcha](#clickcaptcha)
      - [Rotate](#rotate)
    - [Other methods](#other-methods)
      - [send / getResult](#send--getresult)
      - [balance](#balance)
      - [report](#report)
      - [Error handling](#error-handling)
      - [Proxies](#proxies)
      - [Async calls](#async-calls)



  This package can be installed with Pip:

  ```pip3 install 2captcha-python```




  TwoCaptcha instance can be created like this:

  ```python
  from twocaptcha import TwoCaptcha

  solver = TwoCaptcha('YOUR_API_KEY')
  ```
  Also there are few options that can be configured:

  ```python
  config = {
              'server':           '2captcha.com',
              'apiKey':           'YOUR_API_KEY',
              'softId':            123,
              'callback':         'https://your.site/result-receiver',
              'defaultTimeout':    120,
              'recaptchaTimeout':  600,
              'pollingInterval':   10,
          }
  solver = TwoCaptcha(**config)
  ```



  | Option           | Default value  | Description                                                                                                                                        |
  | ---------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
  | server           | `2captcha.com` | API server. You can set it to `rucaptcha.com` if your account is registered there                                                                  |
  | softId           | -              | your software ID obtained after publishing in [2captcha sofware catalog]                                                                           |
  | callback         | -              | URL of your web-sever that receives the captcha recognition result. The URl should be first registered in [pingback settings] of your account      |
  | defaultTimeout   | 120            | Polling timeout in seconds for all captcha types except ReCaptcha. Defines how long the module tries to get the answer from `res.php` API endpoint |
  | recaptchaTimeout | 600            | Polling timeout for ReCaptcha in seconds. Defines how long the module tries to get the answer from `res.php` API endpoint                          |
  | pollingInterval  | 10             | Interval in seconds between requests to `res.php` API endpoint, setting values less than 5 seconds is not recommended                              |

  >  **IMPORTANT:** once `callback` is defined for `TwoCaptcha` instance, all methods return only the captcha ID and DO NOT poll the API to get the result. The result will be sent to the callback URL.
  To get the answer manually use [getResult method](#send--getresult)


  When you submit any image-based captcha use can provide additional options to help 2captcha workers to solve it properly.


  | Option        | Default Value | Description                                                                                        |
  | ------------- | ------------- | -------------------------------------------------------------------------------------------------- |
  | numeric       | 0             | Defines if captcha contains numeric or other symbols [see more info in the API docs][post options] |
  | minLength     | 0             | minimal answer lenght                                                                              |
  | maxLength     | 0             | maximum answer length                                                                              |
  | phrase        | 0             | defines if the answer contains multiple words or not                                               |
  | caseSensitive | 0             | defines if the answer is case sensitive                                                            |
  | calc          | 0             | defines captcha requires calculation                                                               |
  | lang          | -             | defines the captcha language, see the [list of supported languages]                                |
  | hintImg       | -             | an image with hint shown to workers with the captcha                                               |
  | hintText      | -             | hint or task text shown to workers with the captcha                                                |

  Below you can find basic examples for every captcha type. Check out [examples directory] to find more examples with all available options.


  To bypass a normal captcha (distorted text on image) use the following method. This method also can be used to recognize any text on the image.
  ```python
  result = solver.normal('path/to/captcha.jpg', param1=..., ...)

  result = solver.normal('https://site-with-captcha.com/path/to/captcha.jpg', param1=..., ...)
  ```


  This method can be used to bypass a captcha that requires to answer a question provided in clear text.
  ```python
  result = solver.text('If tomorrow is Saturday, what day is today?', param1=..., ...)
  ```


  Use this method to solve ReCaptcha V2 and obtain a token to bypass the protection.
  ```python
  result = solver.recaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
                            url='https://mysite.com/page/with/recaptcha',
                            param1=..., ...)
  ```


  This method provides ReCaptcha V3 solver and returns a token.
  ```python
  result = solver.recaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
                              url='https://mysite.com/page/with/recaptcha',
                              version='v3',
                              param1=..., ...)
  ```


  FunCaptcha (Arkoselabs) solving method. Returns a token.
  ```python
  result = solver.funcaptcha(sitekey='6Le-wvkSVVABCPBMRTvw0Q4Muexq1bi0DJwx_mJ-',
                              url='https://mysite.com/page/with/funcaptcha',
                              param1=..., ...)

  ```



  Method to solve GeeTest puzzle captcha. Returns a set of tokens as JSON.
  ```python
  result = solver.geetest(gt='f1ab2cdefa3456789012345b6c78d90e',
                          challenge='12345678abc90123d45678ef90123a456b',
                          url='https://www.site.com/page/',
                          param1=..., ...)

  ```



  Use this method to solve hCaptcha challenge. Returns a token to bypass captcha.
  ```python
  result = solver.hcaptcha(sitekey='10000000-ffff-ffff-ffff-000000000001',
                              url='https://www.site.com/page/',
                              param1=..., ...)

  ```


  Use this method to solve GeeTest v4. Returns the response in JSON.
  ```python
  result = solver.geetest_v4(captcha_id='e392e1d7fd421dc63325744d5a2b9c73',
                              url='https://www.site.com/page/',
                              param1=..., ...)

  ```



  Use this method to solve hCaptcha challenge. Returns JSON with answer containing the following values: answer, challenge_id.
  ```python
  result = solver.lemin(captcha_id='CROPPED_1abcd2f_a1234b567c890d12ef3a456bc78d901d',
                              div_id='lemin-cropped-captcha',
                              url='https://www.site.com/page/',
                              param1=..., ...)

  ```



  Use this method to solve Cloudflare Turnstile. Returns JSON with the token.
  ```python
  result = solver.turnstile(sitekey='0x1AAAAAAAAkg0s2VIOD34y5',
                              url='http://mysite.com/',
                              param1=..., ...)

  ```


  Use this method to solve Amazon WAF Captcha also known as AWS WAF Captcha is a part of Intelligent threat mitigation for Amazon AWS. Returns JSON with the token.
  ```python
  result = solver.amazon_waf(sitekey='0x1AAAAAAAAkg0s2VIOD34y5',
                              iv='CgAHbCe2GgAAAAAj',
                              context='9BUgmlm48F92WUoqv97a49ZuEJJ50TCk9MVr3C7WMtQ0X6flVbufM4n8mjFLmbLVAPgaQ1Jydeaja94iAS49ljb+sUNLoukWedAQZKrlY4RdbOOzvcFqmD/ZepQFS9N5w15Exr4VwnVq+HIxTsDJwRviElWCdzKDebN/mk8/eX2n7qJi5G3Riq0tdQw9+C4diFZU5E97RSeahejOAAJTDqduqW6uLw9NsjJBkDRBlRjxjn5CaMMo5pYOxYbGrM8Un1JH5DMOLeXbq1xWbC17YSEoM1cRFfTgOoc+VpCe36Ai9Kc='
                              url='https://non-existent-example.execute-api.us-east-1.amazonaws.com/latest'
                              param1=..., ...)

  ```



  Token-based method to solve KeyCaptcha.
  ```python
  result = solver.keycaptcha(s_s_c_user_id=10,
      				   s_s_c_session_id='493e52c37c10c2bcdf4a00cbc9ccd1e8',
      				   s_s_c_web_server_sign='9006dc725760858e4c0715b835472f22-pz-',
      				   s_s_c_web_server_sign2='2ca3abe86d90c6142d5571db98af6714',
      				   url='https://www.keycaptcha.ru/demo-magnetic/',
      				   param1=..., ...)

  ```


  Token-based method to bypass Capy puzzle captcha.
  ```python
  result = solver.capy(sitekey='PUZZLE_Abc1dEFghIJKLM2no34P56q7rStu8v',
                       url='http://mysite.com/',
                       api_server='https://jp.api.capy.me/',
                       param1=..., ...)
  ```

  Grid method is originally called Old ReCaptcha V2 method. The method can be used to bypass any type of captcha where you can apply a grid on image and need to click specific grid boxes. Returns numbers of boxes.
  ```python
  result = solver.grid('path/to/captcha.jpg', param1=..., ...)
  ```

  Canvas method can be used when you need to draw a line around an object on image. Returns a set of points' coordinates to draw a polygon.
  ```python
  result = solver.canvas('path/to/captcha.jpg', param1=..., ...)
  ```

  ClickCaptcha method returns coordinates of points on captcha image. Can be used if you need to click on particular points on the image.
  ```python
  result = solver.coordinates('path/to/captcha.jpg', param1=..., ...)
  ```


  This method can be used to solve a captcha that asks to rotate an object. Mostly used to bypass FunCaptcha. Returns the rotation angle.
  ```python
  result = solver.rotate('path/to/captcha.jpg', param1=..., ...)
  ```




  These methods can be used for manual captcha submission and answer polling.
  ```python
  import time
  . . . . .


  id = solver.send(file='path/to/captcha.jpg')
  time.sleep(20)

  code = solver.get_result(id)
  ```


  Use this method to get your account's balance
  ```python
  balance = solver.balance()
  ```


  Use this method to report good or bad captcha answer.
  ```python
  solver.report(id, True) # captcha solved correctly
  solver.report(id, False) # captcha solved incorrectly
  ```


  In case of an error, the captcha solver throws an exception. It's important to properly handle these cases. We recommend using `try except` to handle exceptions.
  ```python
  try:
      result = solver.text('If tomorrow is Saturday, what day is today?')
  except ValidationException as e:
      
  	print(e)
  except NetworkException as e:
  	
  	print(e)
  except ApiException as e:
      
  	print(e)
  except TimeoutException as e:
      
  	print(e)
  ```




  You can pass your proxy as an additional argument for methods: recaptcha, funcaptcha and geetest. The proxy will be forwarded to the API to solve the captcha.

  ```python
  proxy={
      'type': 'HTTPS',
      'uri': 'login:password@IP_address:PORT'
  }
  ```


  You can also make async calls with [asyncio], for example:

  ```python
  import asyncio
  import concurrent.futures
  from twocaptcha import TwoCaptcha

  captcha_result = await captchaSolver(image)

  async def captchaSolver(image):
      loop = asyncio.get_running_loop()
      with concurrent.future.ThreadPoolExecutor() as pool:
          result = await loop.run_in_executor(pool, lambda: TwoCaptcha(API_KEY).normal(image))
          return result
  ```


  [2Captcha]: https://2captcha.com/
  [2captcha sofware catalog]: https://2captcha.com/software
  [pingback settings]: https://2captcha.com/setting/pingback
  [post options]: https://2captcha.com/2captcha-api#normal_post
  [list of supported languages]: https://2captcha.com/2captcha-api#language
  [examples directory]: /examples
  [asyncio]: https://docs.python.org/3/library/asyncio.html


pkgId: 53069ced7172affe35ede49c4a36429917aa5e8ef4481458fd72c18ac4140b1b
name: python-ATpy
arch: src
version: 0.9.7
epoch: 0
release: 1
summary: Astronomical Tables in Python
url: http://atpy.readthedocs.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bbeb4ac5-d71a-45c1-9063-e1603e16d583
location_href: 00002836-python-ATpy/python-ATpy-0.9.7-1.src.rpm
checksum_type: sha256
description:
  ATpy is a high-level package providing a way to manipulate tables of
  astronomical data in a uniform way.
  Documentation is available from [http://atpy.readthedocs.org/]
  ATpy is released under an MIT open-source license


pkgId: 392555deca3a6bbec5a7db34ba3f5b643fce731d56de657ccdc20c19332954c9
name: python-AccessControl-debuginfo
arch: aarch64
version: 6.0
epoch: 0
release: 1
summary: Debug information for package python-AccessControl
url: https://github.com/zopefoundation/AccessControl
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5c98dfeb-9cab-4e25-879e-115a31293bd6
rpm_sourcerpm: python-AccessControl-6.0-1.src.rpm
location_href: 00012023-python-accesscontrol/python-AccessControl-debuginfo-6.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-AccessControl.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1aca82e4bc95ff517214ba7e19a3e928b2174c9db35f768b0214f13617f62917
name: python-AccessControl-debugsource
arch: aarch64
version: 6.0
epoch: 0
release: 1
summary: Debug sources for package python-AccessControl
url: https://github.com/zopefoundation/AccessControl
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-5c98dfeb-9cab-4e25-879e-115a31293bd6
rpm_sourcerpm: python-AccessControl-6.0-1.src.rpm
location_href: 00012023-python-accesscontrol/python-AccessControl-debugsource-6.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-AccessControl.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: fceb0020dcdbaf6cea05f9cbaa36d04dabdd6fc4df396bba3382fba4e340a8f4
name: python-Acquisition
arch: src
version: 5.0
epoch: 0
release: 1
url: https://github.com/zopefoundation/Acquisition
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-986bff79-baf1-41fd-8044-41d4609bccec
location_href: 00011997-python-acquisition/python-Acquisition-5.0-1.src.rpm
checksum_type: sha256
summary:
  Acquisition is a mechanism that allows objects to obtain attributes from the containment hierarchy they're in.

description:
  This package implements "environmental acquisiton" for Python, as
  proposed in the OOPSLA96_ paper by Joseph Gil and David H. Lorenz:
      We propose a new programming paradigm, environmental acquisition in
      the context of object aggregation, in which objects acquire
      behaviour from their current containers at runtime. The key idea is
      that the behaviour of a component may depend upon its enclosing
      composite(s). In particular, we propose a form of feature sharing in
      which an object "inherits" features from the classes of objects in
      its environment.  By examining the declaration of classes, it is
      possible to determine which kinds of classes may contain a
      component, and which components must be contained in a given kind of
      composite. These relationships are the basis for language constructs
      that supports acquisition.


pkgId: 8e624432587f9fb873df36ab96a8df12ecd3cc91e5cb50d9809daf1891892694
name: python-Acquisition-debuginfo
arch: aarch64
version: 5.0
epoch: 0
release: 1
summary: Debug information for package python-Acquisition
url: https://github.com/zopefoundation/Acquisition
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-986bff79-baf1-41fd-8044-41d4609bccec
rpm_sourcerpm: python-Acquisition-5.0-1.src.rpm
location_href: 00011997-python-acquisition/python-Acquisition-debuginfo-5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Acquisition.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: e4a40691d577e015fcbde2b437d78ea9cc8c73501e9473ff635611aa9f4ec53c
name: python-Acquisition-debugsource
arch: aarch64
version: 5.0
epoch: 0
release: 1
summary: Debug sources for package python-Acquisition
url: https://github.com/zopefoundation/Acquisition
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-986bff79-baf1-41fd-8044-41d4609bccec
rpm_sourcerpm: python-Acquisition-5.0-1.src.rpm
location_href: 00011997-python-acquisition/python-Acquisition-debugsource-5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Acquisition.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: c8e52dbf6639303fa9c9fd139cae39eaeaa9d3178d65c3bbd09de404a7d9a8c5
name: python-Adafruit-PlatformDetect
arch: src
version: 3.40.3
epoch: 0
release: 1
summary: Platform detection for use by libraries like Adafruit-Blinka.
url: https://github.com/adafruit/Adafruit_Python_PlatformDetect
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ec74c19-0d6a-46a6-9bc3-2e4108bc391d
location_href: 00002949-python-adafruit-platformdetect/python-Adafruit-PlatformDetect-3.40.3-1.src.rpm
checksum_type: sha256
description:
  This library provides best-guess platform detection for a range of single-board
  computers and (potentially) other platforms.  It was written primarily for use
  in `Adafruit_Blinka <https://github.com/adafruit/Adafruit_Blinka>`_, but may be
  useful in other contexts.
  Platform detection is divided into "chip" and "board" detection, with the latter
  generally dependent on the former.  Platform info is gathered from:
    - Python's `sys.platform`
    - Various files on Linux systems:
      - /proc/cpuinfo (for processor info, Raspberry Pi hardware revisions, etc.)
      - /proc/device-tree/compatible (for 96Boards info)
    - Beaglebone EEPROM board IDs
    - Distribution-specific files such as /etc/armbian-release.


pkgId: 3eeecd76d936a03539c262e2c1699d16221215ef0e4d62afe9a30e0df334f91c
name: python-Adafruit-PureIO
arch: src
version: 1.1.10
epoch: 0
release: 1
url: https://github.com/adafruit/Adafruit_Python_PureIO
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3deb42b1-9862-494a-b261-31c0227e0e3d
location_href: 00002950-python-adafruit-pureio/python-Adafruit-PureIO-1.1.10-1.src.rpm
checksum_type: sha256
summary:
  Pure python (i.e. no native extensions) access to Linux IO    including I2C and SPI. Drop in replacement for smbus and spidev modules.

description:
  Pure python (i.e. no native extensions) access to Linux IO including I2C and SPI. Drop in replacement for smbus and spidev modules.


pkgId: 7d4607196122b0bb0e83362c41ca363e9180cb889a11028445f5fb96fa7facbc
name: python-Amino.py
arch: src
version: 3.0.10
epoch: 0
release: 1
summary: A library to create Amino bots.
url: https://github.com/Slimakoi/Amino.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c17577aa-cba8-4a5f-9c2b-9283c5977d48
location_href: 00011359-python-amino-py/python-Amino.py-3.0.10-1.src.rpm
checksum_type: sha256
description:
  [//]: # (**README Improved By ODYSS3EUS**)
  [//]: # (Never Underestimate Presentation)
  [//]: # (Mae: Professionals have standards)
  [//]: # (Koi: Indeed...)
  <h1 align="center">
    <br>
    <a href="https://github.com/Slimakoi/Amino.py"><img src="https://cdn.discordapp.com/icons/715911730550800514/8b577d0f9d38614422601a71e91b866d.png?size=512" alt="Amino.py" width="200"></a>
    <br>
    Amino.py
    <br>
  </h1>

  <p align="center">
    <a href="https://discord.gg/68wchgsKdX"><img src="https://bit.ly/32neyjM"></a>
    <p align="center"> If you have any questions, join us on Discord! </p>
  </p>


  Amino.py is a Python API for communicating with Amino's Servers while pretending that you're an App User. This is mostly accomplished by spoofing Device Configuration Headers, while objectifying and organizing Amino Response Data, so that actually doing anything is easier.



  Python 3.8 is the recommended version for Amino.py, only supports Python 3.x.

  To install Amino.py, run `python3 -m pip install amino.py` or `pip install amino.py`.
  - **NOTE:** MAKE SURE YOU TYPE `amino.py` **NOT** `amino` AS IT WILL INSTALL THE **WRONG** PACKAGE!



  [Read the Docs Link](https://aminopy.readthedocs.io/en/latest/)


  0. Make sure pip is installed and added to PATH, see: [How to setup pip](https://nitratine.net/blog/post/how-to-setup-pythons-pip/)
  1. Alternatively download the API from GitHub [here](https://github.com/Slimakoi/Amino.py/archive/refs/heads/master.zip)
  2. Extract the .zip file either with [WinRAR](https://www.win-rar.com/download.html?&L=0) or [7-Zip](https://www.7-zip.org/download.html)
  3. Open the extracted folder in an IDE of your choice, and navigate to the folder named `Amino.py-master`
  4. Select the Python Interpreter
  5. Make a new `*.py` file and start coding

  [//]: # (*Verbose Instructions For Those Who Want To Start Programming But Don't Know How.)
  [//]: # (Mae: Who knows their stuff will do how to do this and who doesn't won't need this. Consider replacing this section entirely.)

  [//]: # (PS: This additionally adds more confusion for users, which already created reports of circular imports and more headaches. Pip installs are easier to understand for end users. Pip simplifies everything when dealing with dependencies, updates, installs and removals. Windows Python's default install installs Pip, MOST [not looking at you arch] Distros package python with Pip alongside Python. Who "starting programming" will ever use this?)


pkgId: d7c0b2958004cb60dcb17cc57af141dfcefd34389963996c89a5850bca148b50
name: python-Arpeggio
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Packrat parser interpreter
url: https://github.com/textX/Arpeggio
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cd74c39f-5032-4d25-8d8b-d8a569619083
location_href: 00003049-python-arpeggio/python-Arpeggio-2.0.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://raw.githubusercontent.com/textX/Arpeggio/master/art/arpeggio-logo.png)

  [![PyPI Version](https://img.shields.io/pypi/v/Arpeggio.svg)](https://pypi.python.org/pypi/Arpeggio)
  ![](https://img.shields.io/pypi/l/Arpeggio.svg)
  [![Build status](https://github.com/textx/Arpeggio/actions/workflows/ci-linux-ubuntu.yml/badge.svg)](https://github.com/textx/Arpeggio/actions)
  [![Coverage Status](https://coveralls.io/repos/github/textX/Arpeggio/badge.svg)](https://coveralls.io/github/textX/Arpeggio)
  [![Documentation](https://img.shields.io/badge/docs-latest-green.svg)](http://textx.github.io/Arpeggio/latest/)

  Arpeggio is a recursive descent parser with memoization based on PEG grammars
  (aka Packrat parser).

  Documentation with tutorials is available [here](http://textx.github.io/Arpeggio/).

  **Note:** for a higher level parsing/language tool (i.e., a nicer interface to
  Arpeggio) see [textX](https://github.com/textX/textX).


pkgId: 5c0e84133b6a9c270141f9eb1ba0e0bba6a34d46556f9d143a0c4d76c418349c
name: python-AuthEncoding
arch: src
version: 5.0
epoch: 0
release: 1
summary: Framework for handling LDAP style password hashes.
url: https://github.com/zopefoundation/AuthEncoding
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e337eb4e-de26-42a8-a1db-435915ff6881
location_href: 00013604-python-authencoding/python-AuthEncoding-5.0-1.src.rpm
checksum_type: sha256
description:
  AuthEncoding is a framework for handling LDAP style password hashes.
  It is used in Zope but does not depend on any other Zope package.


pkgId: 3a4e595bbbec69a5ec5ebefad63ecc0dc58cf9788131af243581b93ced5069c0
name: python-Authlib
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: The ultimate Python library in building OAuth and OpenID Connect servers and clients.
url: https://authlib.org/
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a24fd35d-9993-4687-a2b7-e8dc4cec30d8
location_href: 00003080-python-authlib/python-Authlib-1.2.0-1.src.rpm
checksum_type: sha256
description:
  The ultimate Python library in building OAuth and OpenID Connect servers.
  JWS, JWK, JWA, JWT are included.


pkgId: 9512848c3004afef8532ec78cd30397bf03bb9a3ac8ac38100b9a6565b298aa4
name: python-Autologging
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Autologging makes logging and tracing Python classes easy.
url: http://ninthtest.info/python-autologging/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dfa80bd0-0cd3-42d3-8d3a-f02cd29fab94
location_href: 00013850-python-autologging/python-Autologging-1.3.2-1.src.rpm
checksum_type: sha256
description:
  http://ninthtest.info/python-autologging/

  [![PyPI version](https://img.shields.io/pypi/v/Autologging.svg)](https://pypi.python.org/pypi/Autologging)
  [![Python version](https://img.shields.io/pypi/pyversions/Autologging.svg)](https://pypi.python.org/pypi/Autologging)
  [![Python implementation](https://img.shields.io/pypi/implementation/Autologging.svg)](https://pypi.python.org/pypi/Autologging)
  [![License](https://img.shields.io/pypi/l/Autologging.svg)](https://github.com/mzipay/Autologging/blob/master/LICENSE.txt)
  [![Wheel availability](https://img.shields.io/pypi/wheel/Autologging.svg)](https://pypi.python.org/pypi/Autologging)



  Autologging eliminates boilerplate logging setup code and tracing code,
  and provides a means to separate application logging from program flow
  and data tracing.

  Python modules that make use of Autologging are cleaner, leaner, and
  more resilient to changes that would otherwise require updating tracing
  statements.

  Autologging allows for tracing to be configured (and controlled)
  independently from application logging. Toggle tracing on/off, write
  trace log records to a separate log, and use different formatting for
  trace log entries - all via standard Python logging facilities, and
  without affecting your application logging.



  Autologging exposes two decorators and a custom log level:

  **`logged`**
  Decorate a class to create a `__log` member. The logger is named by
  default to match the dotted-name of the containing class. A function
  may also be decorated, creating a `_log` attribute on the function
  object whose default name matches the containing module.
  A specifically-named logger may also be passed to the decorator (i.e.
  `logged(my_logger)`).

  **`traced`**
  Decorate a class to provide **automatic** method call/return tracing. By
  default, all class, static, and instance methods are traced (excluding
  "__special__" methods, with the exception of `__init__` and `__call__`).
  As with the `logged` decorator, the default name of the tracing logger
  matches the dotted-name of the containing class and may be overridden by
  passing a specifically-named logger to the decorator.
  Additionally, this decorator accepts multiple string arguments that
  explicitly name the methods to be traced (and may even name
  "__special__" methods).

  Module-level functions may also be traced using this decorator.

  *New in version 1.2.0:* automatic yield/stop tracing of Python
  [generator iterators](https://docs.python.org/3/glossary.html#term-generator-iterator)
  (if the [generator](https://docs.python.org/3/glossary.html#term-generator)
  function is traced).

  **`TRACE`**
  The `autologging.TRACE` (level 1) log level is registered with the
  Python `logging` module when Autologging is imported so that tracing
  can be configured and controlled independently of application logging.

  Tracing may be disabled entirely by setting the
  `AUTOLOGGING_TRACED_NOOP` environment variable or by calling the
  `autologging.install_traced_noop()` function.



  A simple logged and traced class:

  ```python
   1 import logging
   2 import sys
   3
   4 from autologging import logged, TRACE, traced
   5
   6 @traced
   7 @logged
   8 class Example:
   9
  10     def __init__(self):
  11         self.__log.info("initialized")
  12
  13     def backwards(self, *words):
  14         for word in words:
  15             yield "".join(reversed(word))
  16
  17
  18 if __name__ == "__main__":
  19     logging.basicConfig(
  20             level=TRACE, stream=sys.stderr,
  21             format="s:s,d:s.s:s")
  22     example = Example()
  23     for result in example.backwards("spam", "eggs"):
  24         print(result)
  ```

  Logging and tracing output:

  ```bash
  $ python example.py
  TRACE:example.py,10:__main__.Example.__init__:CALL *() **{}
  INFO:example.py,11:__main__.Example.__init__:initialized
  TRACE:example.py,11:__main__.Example.__init__:RETURN None
  TRACE:example.py,13:__main__.Example.backwards:CALL *('spam', 'eggs') **{}
  TRACE:example.py,15:__main__.Example.backwards:RETURN <generator object backwards at 0x7fa534d61eb0>
  TRACE:example.py,15:__main__.Example.backwards:YIELD 'maps'
  maps
  TRACE:example.py,15:__main__.Example.backwards:YIELD 'sgge'
  sgge
  TRACE:example.py,15:__main__.Example.backwards:STOP
  ```



  The easiest way to install Autologging is to use
  [pip](https://pip.pypa.io/):

  ```bash
  $ pip install Autologging
  ```



  Clone or fork the repository:

  ```bash
  $ git clone https://github.com/mzipay/Autologging.git
  ```

  Alternatively, download and extract a source .zip or .tar.gz archive
  from https://github.com/mzipay/Autologging/releases,
  https://pypi.python.org/pypi/Autologging or
  https://sourceforge.net/projects/autologging/files/.

  Run the test suite and install the `autologging` module: (make sure you
  have [setuptools](https://pypi.python.org/pypi/setuptools) installed!)

  ```bash
  $ cd Autologging
  $ python setup.py test
  $ python setup.py install
  ```



  Download the Python wheel (.whl) or a Windows installer from
  https://pypi.python.org/pypi/Autologging or
  https://sourceforge.net/projects/autologging/files/.

  (Use [pip](https://pip.pypa.io/) or
  [wheel](https://pypi.python.org/pypi/wheel) to install the .whl.)


pkgId: aba10ad53300b4c030ea5a2ebf0a6cc9e3fda479a011d728bff6711983e4bfe7
name: python-BTrees-debuginfo
arch: aarch64
version: 5.0
epoch: 0
release: 1
summary: Debug information for package python-BTrees
url: https://github.com/zopefoundation/BTrees
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-7f36110e-8bbc-4409-bfdb-bd263f357ae4
rpm_sourcerpm: python-BTrees-5.0-1.src.rpm
location_href: 00005889-python-BTrees/python-BTrees-debuginfo-5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-BTrees.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 68f5e13e64a4c3670527f3c45a51c2fada1927fcdb3b44e329010abf8356ae4e
name: python-BTrees-debugsource
arch: aarch64
version: 5.0
epoch: 0
release: 1
summary: Debug sources for package python-BTrees
url: https://github.com/zopefoundation/BTrees
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-7f36110e-8bbc-4409-bfdb-bd263f357ae4
rpm_sourcerpm: python-BTrees-5.0-1.src.rpm
location_href: 00005889-python-BTrees/python-BTrees-debugsource-5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-BTrees.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: b8c1b2af89a8c1d8dc77642431d9e08948950b3dfcc4826180f543bf034cb351
name: python-BenBotAsync
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Asynchronous Python wrapper for BenBot API.
url: https://github.com/xMistt/BenBot
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe18bfb0-a7eb-41ab-af36-40623b76c730
location_href: 00009346-python-benbotasync/python-BenBotAsync-3.0.2-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for the BenBot API.

  [![Downloads](https://pepy.tech/badge/benbotasync)](https://pepy.tech/project/benbotasync)
  [![Requires: Python 3.x](https://img.shields.io/pypi/pyversions/BenBotAsync.svg)](https://pypi.org/project/BenBotAsync/)
  [![BenBot Version: 1.0.1](https://img.shields.io/pypi/v/BenBotAsync.svg)](https://pypi.org/project/BenBotAsync/)



  ~~Windows:~~ ``py -3 -m pip install BenBot``<br>
  ~~Linux/macOS:~~ ``python3 -m pip install BenBot``


  Windows: ``py -3 -m pip install BenBotAsync``<br>
  Linux/macOS: ``python3 -m pip install BenBotAsync``


  ```py
  import BenBotAsync
  import asyncio


  async def ben_search():
      result = await BenBotAsync.get_cosmetic(
          lang="en",
          searchLang="en",
          matchMethod="full",
          name="Ghoul Trooper"
      )

      print(result.id)

  loop = asyncio.get_event_loop()
  loop.run_until_complete(ben_search())

  ```

  This would output:<br>
  ```CID_029_Athena_Commando_F_Halloween```

  fortnitepy example:
  ```py
  import fortnitepy
  import BenBotAsync


  client = fortnitepy.Client(
      auth=fortnitepy.EmailAndPasswordAuth(
          email='example@email.com',
          password='password123'
      )
  )


  @client.event
  async def event_friend_message(message: fortnitepy.FriendMessage) -> None:
      args = message.content.split()
      split = args[1:]
      content = " ".join(split)

      if args[0] == '!skin':
          skin = await BenBotAsync.get_cosmetic(
              lang="en",
              searchLang="en",
              matchMethod="contains",
              name=content,
              backendType="AthenaCharacter"
          )

          await client.user.party.me.set_outfit(asset=skin.id)


  client.run()

  ```

  You can check out the documentation for BenBotAsync [here](https://stoplight.io/p/docs/gh/xMistt/BenBotAsync).


pkgId: d6e78c7f9b8cda636539ae36bb94e06c47a1a75f904b376169d84c01f4b9af48
name: python-Boruta
arch: src
version: 0.3
epoch: 0
release: 1
summary: Python Implementation of Boruta Feature Selection
url: https://github.com/danielhomola/boruta_py
rpm_license: BSD 3 clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2b64020c-8401-4c25-a005-da2c5f093515
location_href: 00010088-python-boruta/python-Boruta-0.3-1.src.rpm
checksum_type: sha256
description:
  This project hosts Python implementations of the [Boruta all-relevant feature selection method](https://m2.icm.edu.pl/boruta/).

  [Related blog post] (http://danielhomola.com/2015/05/08/borutapy-an-all-relevant-feature-selection-method/)



  * numpy
  * scipy
  * scikit-learn


  Download, import and do as you would with any other scikit-learn method:
  * fit(X, y)
  * transform(X)
  * fit_transform(X, y)



  Python implementations of the Boruta R package.

  This implementation tries to mimic the scikit-learn interface, so use fit,
  transform or fit_transform, to run the feature selection.

  For more, see the docs of these functions, and the examples below.

  Original code and method by: Miron B Kursa, https://m2.icm.edu.pl/boruta/

  Boruta is an all relevant feature selection method, while most other are
  minimal optimal; this means it tries to find all features carrying
  information usable for prediction, rather than finding a possibly compact
  subset of features on which some classifier has a minimal error.

  Why bother with all relevant feature selection?
  When you try to understand the phenomenon that made your data, you should
  care about all factors that contribute to it, not just the bluntest signs
  of it in context of your methodology (yes, minimal optimal set of features
  by definition depends on your classifier choice).




  It is the original R package recoded in Python with a few added extra features.
  Some improvements include:

  * Faster run times, thanks to scikit-learn

  * Scikit-learn like interface

  * Compatible with any ensemble method from scikit-learn

  * Automatic n_estimator selection

  * Ranking of features

  For more details, please check the top of the docstring.

  We highly recommend using pruned trees with a depth between 3-7.

  Also, after playing around a lot with the original code I identified a few areas
  where the core algorithm could be improved/altered to make it less strict and
  more applicable to biological data, where the Bonferroni correction might be
  overly harsh.

  __Percentile as threshold__
  The original method uses the maximum of the shadow features as a threshold in
  deciding which real feature is doing better than the shadow ones. This could be
  overly harsh.

  To control this, I added the perc parameter, which sets the
  percentile of the shadow features' importances, the algorithm uses as the
  threshold. The default of 100 which is equivalent to taking the maximum as the
  R version of Boruta does, but it could be relaxed. Note, since this is the
  percentile, it changes with the size of the dataset. With several thousands of
  features it isn't as stringent as with a few dozens at the end of a Boruta run.


  __Two step correction for multiple testing__
  The correction for multiple testing was relaxed by making it a two step
  process, rather than a harsh one step Bonferroni correction.

  We need to correct firstly because in each iteration we test a number of
  features against the null hypothesis (does a feature perform better than
  expected by random). For this the Bonferroni correction is used in the original
  code which is known to be too stringent in such scenarios (at least for
  biological data), and also the original code corrects for n features, even if
  we are in the 50th iteration where we only have k<<n features left. For this
  reason the first step of correction is the widely used Benjamini Hochberg FDR.

  Following that however we also need to account for the fact that we have been
  testing the same features over and over again in each iteration with the
  same test. For this scenario the Bonferroni is perfect, so it is applied by
  deviding the p-value threshold with the current iteration index.

  If this two step correction is not required, the two_step parameter has to be
  set to False, then (with perc=100) BorutaPy behaves exactly as the R version.



  __estimator__ : object
     > A supervised learning estimator, with a 'fit' method that returns the
     > feature_importances_ attribute. Important features must correspond to
     > high absolute values in the feature_importances_.

  __n_estimators__ : int or string, default = 1000
     > If int sets the number of estimators in the chosen ensemble method.
     > If 'auto' this is determined automatically based on the size of the
     > dataset. The other parameters of the used estimators need to be set
     > with initialisation.

  __perc__ : int, default = 100
     > Instead of the max we use the percentile defined by the user, to pick
     > our threshold for comparison between shadow and real features. The max
     > tend to be too stringent. This provides a finer control over this. The
     > lower perc is the more false positives will be picked as relevant but
     > also the less relevant features will be left out. The usual trade-off.
     > The default is essentially the vanilla Boruta corresponding to the max.

  __alpha__ : float, default = 0.05
     > Level at which the corrected p-values will get rejected in both correction
     steps.

  __two_step__ : Boolean, default = True
    > If you want to use the original implementation of Boruta with Bonferroni
    > correction only set this to False.

  __max_iter__ : int, default = 100
     > The number of maximum iterations to perform.

  __verbose__ : int, default=0
     > Controls verbosity of output.




  **n_features_** : int
     > The number of selected features.

  **support_** : array of shape [n_features]
     > The mask of selected features - only confirmed ones are True.

  **support_weak_** : array of shape [n_features]
    >  The mask of selected tentative features, which haven't gained enough
    >  support during the max_iter number of iterations..

  **ranking_** : array of shape [n_features]
    >  The feature ranking, such that ``ranking_[i]`` corresponds to the
    >  ranking position of the i-th feature. Selected (i.e., estimated
    >  best) features are assigned rank 1 and tentative features are assigned
    >  rank 2.




      import pandas as pd
      from sklearn.ensemble import RandomForestClassifier
      from boruta import BorutaPy

      
      
      X = pd.read_csv('examples/test_X.csv', index_col=0).values
      y = pd.read_csv('examples/test_y.csv', header=None, index_col=0).values
      y = y.ravel()

      
      
      rf = RandomForestClassifier(n_jobs=-1, class_weight='balanced', max_depth=5)

      
      feat_selector = BorutaPy(rf, n_estimators='auto', verbose=2, random_state=1)

      
      feat_selector.fit(X, y)

      
      feat_selector.support_

      
      feat_selector.ranking_

      
      X_filtered = feat_selector.transform(X)



  1. Kursa M., Rudnicki W., "Feature Selection with the Boruta Package" Journal of Statistical Software, Vol. 36, Issue 11, Sep 2010


pkgId: 661ee0ca425765a879affb43352caa92d3a5ddbaa5dadc305405acc49e88331d
name: python-BorutaShap
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: A feature selection algorithm.
url: https://github.com/Ekeany/Boruta-Shap
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f553098e-c2b3-449c-90ec-ac1c09912a8a
location_href: 00010800-python-borutashap/python-BorutaShap-1.0.16-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/255354538.svg)](https://zenodo.org/badge/latestdoi/255354538)
  <a href="https://badge.fury.io/py/BorutaShap"><img src="https://badge.fury.io/py/BorutaShap.svg" alt="PyPI version" height="18"></a>


  BorutaShap is a wrapper feature selection method which combines both the Boruta feature selection algorithm with shapley values. This combination has proven to out perform the original Permutation Importance method in both speed, and the quality of the feature subset produced. Not only does this algorithm provide a better subset of features, but it can also simultaneously provide the most accurate and consistent global feature rankings which can be used for model inference too. Unlike the orginal R package, which limits the user to a Random Forest model, BorutaShap allows the user to choose any Tree Based learner as the base model in the feature selection process.

  Despite BorutaShap's runtime improvments the SHAP TreeExplainer scales linearly with the number of observations making it's use cumbersome for large datasets. To combat this, BorutaShap includes a sampling procedure which uses the smallest possible subsample of the data availble at each iteration of the algorithm. It finds this sample by comparing the distributions produced by an isolation forest of the sample and the data using ks-test. From experiments, this procedure can reduce the run time up to 80% while still creating a valid approximation of the entire data set. Even with these improvments the user still might want a faster solution so BorutaShap has included an option to use the mean decrease in gini impurity. This importance measure is independent of the size dataset as it uses the tree's structure to compute a global feature ranking making it much faster than SHAP at larger datasets. Although this metric returns somewhat comparable feature subsets, it is not a reliable measure of global feature importance in spite of it's wide spread use. Thus, I would recommend to using the SHAP metric whenever possible.



  1. Start by creating new copies of all the features in the data set and name them shadow + feature_name, shuffle these newly added features to remove their correlations with the response variable.

  2. Run a classifier on the extended data with the random shadow features included. Then rank the features using a feature importance metric the original algorithm used permutation importance as it's metric of choice.

  3. Create a threshold using the maximum importance score from the shadow features. Then assign a hit to any feature that had exceeded this threshold.

  4. For every unassigned feature preform a two sided T-test of equality.

  5. Attributes which have an importance significantly lower than the threshold are deemed 'unimportant' and are removed them from process. Deem the attributes which have importance significantly higher than than the threshold as 'important'.

  6. Remove all shadow attributes and repeat the procedure until an importance has been assigned for each feature, or the algorithm has reached the previously set limit of runs.

  If the algorithm has reached its set limit of runs and an importance has not been assigned to each feature the user has two choices. Either increase the number of runs or use the tentative rough fix function which compares the median importance values between unassigned features and the maximum shadow feature to make the decision.





  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

  ```bash
  pip install BorutaShap
  ```



  For more use cases such as alternative models, sampling or changing the importance metric please view the notebooks [here](https://github.com/Ekeany/Boruta-Shap/tree/master/Examples).


  ```python
  from BorutaShap import BorutaShap, load_data

  X, y = load_data(data_type='regression')
  X.head()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonHead.PNG?raw=true" height="203" width="722">

  ```python

  Feature_Selector = BorutaShap(importance_measure='shap',
                                classification=False)

  '''
  Sample: Boolean
  	if true then a rowise sample of the data will be used to calculate the feature importance values

  sample_fraction: float
  	The sample fraction of the original data used in calculating the feature importance values only
          used if Sample==True.

  train_or_test: string
  	Decides whether the feature improtance should be calculated on out of sample data see the dicussion here.
          https://compstat-lmu.github.io/iml_methods_limitations/pfi-data.html#introduction-to-test-vs.training-data

  normalize: boolean
              if true the importance values will be normalized using the z-score formula

  verbose: Boolean
  	a flag indicator to print out all the rejected or accepted features.
  '''
  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonOutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/Bostonplot.PNG?raw=true" height="530" width="699">

  ```python

  subset = Feature_Selector.Subset()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/bostonsubset.PNG?raw=true" height="194" width="465">




  ```python
  from BorutaShap import BorutaShap, load_data
  from xgboost import XGBClassifier

  X, y = load_data(data_type='classification')
  X.head()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryhead.PNG?raw=true">

  ```python
  model = XGBClassifier()


  Feature_Selector = BorutaShap(model=model,
                                importance_measure='shap',
                                classification=True)

  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryoutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryplot.PNG?raw=true" height="565" width="671">

  ```python

  subset = Feature_Selector.Subset()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binarysubset.PNG?raw=true">


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  If you wish to cite this work please click on the zenodo badge at the top of this READme file
  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 8606d644464ae40b2f5453391e759e1eecc363f71f6684be1188e834be3b5d14
name: python-Bottleneck
arch: src
version: 1.3.6
epoch: 0
release: 1
summary: Fast NumPy array functions written in C
url: https://github.com/pydata/bottleneck
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-04455269-c67a-4efa-a91a-5e48fe51d9a7
location_href: 00002839-python-Bottleneck/python-Bottleneck-1.3.6-1.src.rpm
checksum_type: sha256
description:
  Bottleneck comes with a benchmark suite::
      >>> bn.bench()
      Bottleneck performance benchmark
          Bottleneck 1.3.0.dev0+122.gb1615d7; Numpy 1.16.4
          Speed is NumPy time divided by Bottleneck time
          NaN means approx one-fifth NaNs; float64 used
                    no NaN     no NaN      NaN       no NaN      NaN
                     (100,)  (1000,1000)(1000,1000)(1000,1000)(1000,1000)
                     axis=0     axis=0     axis=0     axis=1     axis=1
      nansum         29.7        1.4        1.6        2.0        2.1
      nanmean        99.0        2.0        1.8        3.2        2.5
      nanstd        145.6        1.8        1.8        2.7        2.5
      nanvar        138.4        1.8        1.8        2.8        2.5
      nanmin         27.6        0.5        1.7        0.7        2.4
      nanmax         26.6        0.6        1.6        0.7        2.5
      median        120.6        1.3        4.9        1.1        5.7
      nanmedian     117.8        5.0        5.7        4.8        5.5
      ss             13.2        1.2        1.3        1.5        1.5
      nanargmin      66.8        5.5        4.8        3.5        7.1
      nanargmax      57.6        2.9        5.1        2.5        5.3
      anynan         10.2        0.3       52.3        0.8       41.6
      allnan         15.1      196.0      156.3      135.8      111.2
      rankdata       45.9        1.2        1.2        2.1        2.1
      nanrankdata    50.5        1.4        1.3        2.4        2.3
      partition       3.3        1.1        1.6        1.0        1.5
      argpartition    3.4        1.2        1.5        1.1        1.6
      replace         9.0        1.5        1.5        1.5        1.5
      push         1565.6        5.9        7.0       13.0       10.9
      move_sum     2159.3       31.1       83.6      186.9      182.5
      move_mean    6264.3       66.2      111.9      361.1      246.5
      move_std     8653.6       86.5      163.7      232.0      317.7
      move_var     8856.0       96.3      171.6      267.9      332.9
      move_min     1186.6       13.4       30.9       23.5       45.0
      move_max     1188.0       14.6       29.9       23.5       46.0
      move_argmin  2568.3       33.3       61.0       49.2       86.8
      move_argmax  2475.8       30.9       58.6       45.0       82.8
      move_median  2236.9      153.9      151.4      171.3      166.9
      move_rank     847.1        1.2        1.4        2.3        2.6
  You can also run a detailed benchmark for a single function using, for
  example, the command::
      >>> bn.bench_detailed("move_median", fraction_nan=0.3)
  Only arrays with data type (dtype) int32, int64, float32, and float64 are
  accelerated. All other dtypes result in calls to slower, unaccelerated
  functions. In the rare case of a byte-swapped input array (e.g. a big-endian
  array on a little-endian operating system) the function will not be
  accelerated regardless of dtype.


pkgId: 5a16dbbe61965c3756f93aeeb24c587d852cfe7427c288d3bf553187bf6cfe46
name: python-Bottleneck-debuginfo
arch: aarch64
version: 1.3.7
epoch: 0
release: 1
summary: Debug information for package python-Bottleneck
url: https://github.com/pydata/bottleneck
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8f20f314-f0bb-4af5-898b-1b8f06369288
rpm_sourcerpm: python-Bottleneck-1.3.7-1.src.rpm
location_href: 00010033-python-bottleneck/python-Bottleneck-debuginfo-1.3.7-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Bottleneck.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: b0d27dc682831b47659e9bd684a66874695901adb499dc3936f9eaac755e56cf
name: python-Bottleneck-debugsource
arch: aarch64
version: 1.3.7
epoch: 0
release: 1
summary: Debug sources for package python-Bottleneck
url: https://github.com/pydata/bottleneck
rpm_license: Simplified BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-8f20f314-f0bb-4af5-898b-1b8f06369288
rpm_sourcerpm: python-Bottleneck-1.3.7-1.src.rpm
location_href: 00010033-python-bottleneck/python-Bottleneck-debugsource-1.3.7-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Bottleneck.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 3ad07966f08cd14c5a6a427cdc6a14b5839e042ebd8747577eebfd5be8cfe86e
name: python-Brian2
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: A clock-driven simulator for spiking neural networks
url: http://www.briansimulator.org/
rpm_license: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f46e7919-f5d8-4e66-a494-8c39dbf53e67
location_href: 00003156-python-brian2/python-Brian2-2.5.1-1.src.rpm
checksum_type: sha256
description:
  *A clock-driven simulator for spiking neural networks*
  Brian is a free, open source simulator for spiking neural networks. It is written in the Python programming language and is available on almost all platforms. We believe that a simulator should not only save the time of processors, but also the time of scientists. Brian is therefore designed to be easy to learn and use, highly flexible and easily extensible.
  Please report issues at the github issue tracker (https://github.com/brian-team/brian2/issues) or in the Brian forum (https://brian.discourse.group).
  Documentation for Brian2 can be found at http://brian2.readthedocs.org
  Brian2 is released under the terms of the `CeCILL 2.1 license <https://opensource.org/licenses/CECILL-2.1>`_.
  If you use Brian for your published research, we kindly ask you to cite our article:
  Stimberg, M, Brette, R, Goodman, DFM. “Brian 2, an Intuitive and Efficient Neural Simulator.” eLife 8 (2019): e47314. `doi: 10.7554/eLife.47314 <https://doi.org/10.7554/eLife.47314>`_.


pkgId: a836886799d2837f5c8d9f38dda0689a13c149ee4477d4a9ef8cbc7bc1b7e5be
name: python-Brian2-debuginfo
arch: aarch64
version: 2.5.1
epoch: 0
release: 1
summary: Debug information for package python-Brian2
url: http://www.briansimulator.org/
rpm_license: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f46e7919-f5d8-4e66-a494-8c39dbf53e67
rpm_sourcerpm: python-Brian2-2.5.1-1.src.rpm
location_href: 00003156-python-brian2/python-Brian2-debuginfo-2.5.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Brian2.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 12a8d9a0c7d5d3bcb5ad9386694cf9095261bbe011e3fcef8c87dc181d2f8a04
name: python-Brian2-debugsource
arch: aarch64
version: 2.5.1
epoch: 0
release: 1
summary: Debug sources for package python-Brian2
url: http://www.briansimulator.org/
rpm_license: CEA CNRS Inria Logiciel Libre License, version 2.1 (CeCILL-2.1)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-f46e7919-f5d8-4e66-a494-8c39dbf53e67
rpm_sourcerpm: python-Brian2-2.5.1-1.src.rpm
location_href: 00003156-python-brian2/python-Brian2-debugsource-2.5.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Brian2.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: ae4477eb2fc3afedf0abccee22819aef558f290f7490ac98ed93ec0aca46fad9
name: python-Brotli-debuginfo
arch: aarch64
version: 1.0.9
epoch: 0
release: 1
summary: Debug information for package python-Brotli
url: https://github.com/google/brotli
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a6b348e8-c14b-42de-a3dd-0b666b68f5c3
rpm_sourcerpm: python-Brotli-1.0.9-1.src.rpm
location_href: 00009295-python-brotli/python-Brotli-debuginfo-1.0.9-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-Brotli.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: da3a72c572c4ac2b085c438121b7fbad475ed355f32a2785d524bd1b86e1bde5
name: python-Brotli-debugsource
arch: aarch64
version: 1.0.9
epoch: 0
release: 1
summary: Debug sources for package python-Brotli
url: https://github.com/google/brotli
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a6b348e8-c14b-42de-a3dd-0b666b68f5c3
rpm_sourcerpm: python-Brotli-1.0.9-1.src.rpm
location_href: 00009295-python-brotli/python-Brotli-debugsource-1.0.9-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-Brotli.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 5e2c88133f879811e6ad00d1d396f22aa4b8392d24b0e8147faef2bd52e881eb
name: python-CairoSVG
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: A Simple SVG Converter based on Cairo
url: https://courtbouillon.org/cairosvg
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26933a77-8d25-4202-af59-4f96e0c474a9
location_href: 00003172-python-cairosvg/python-CairoSVG-2.6.0-1.src.rpm
checksum_type: sha256
description:
  CairoSVG is an SVG converter based on Cairo. It can export SVG files to PDF,
  EPS, PS, and PNG files.

  * Free software: LGPL license
  * For Python 3.7+, tested on CPython and PyPy
  * Documentation: https://cairosvg.org/documentation/
  * Changelog: https://github.com/Kozea/CairoSVG/releases
  * Code, issues, tests: https://github.com/Kozea/CairoSVG
  * Code of conduct: https://www.courtbouillon.org/code-of-conduct
  * Professional support: https://www.courtbouillon.org
  * Donation: https://opencollective.com/courtbouillon

  CairoSVG has been created and developed by Kozea (https://kozea.fr).
  Professional support, maintenance and community management is provided by
  CourtBouillon (https://www.courtbouillon.org).

  Copyrights are retained by their contributors, no copyright assignment is
  required to contribute to CairoSVG. Unless explicitly stated otherwise, any
  contribution intentionally submitted for inclusion is licensed under the LGPL
  license, without any additional terms or conditions. For full
  authorship information, see the version control history.


pkgId: f3fca7505178ad05d862ba62a93d2eb3e1959468abadd4697392a7aeabf453d8
name: python-Cartopy
arch: src
version: 0.21.1
epoch: 0
release: 1
summary: A cartographic python library with Matplotlib support for visualisation
url: https://scitools.org.uk/cartopy/docs/latest/
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-87f3ec84-dcb2-467b-bf5e-5920d8524732
location_href: 00003184-python-cartopy/python-Cartopy-0.21.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center" style="margin:1em;">
    <a href="https://scitools.org.uk/cartopy/docs/latest/">
      <img src="https://scitools.org.uk/cartopy/docs/latest/_static/cartopy.png"
           alt="Cartopy"></a>
  </h1>

  <h4 align="center">
      Cartopy is a Python package designed to make drawing maps for
      data analysis and visualisation easy.
  </h4>

  <p align="center">
  <!-- https://shields.io/ is a good source of these -->
  <a href="https://anaconda.org/conda-forge/cartopy">
  <img src="https://img.shields.io/conda/dn/conda-forge/cartopy.svg"
   alt="conda-forge downloads" /></a>
  <a href="https://github.com/SciTools/cartopy/releases">
  <img src="https://img.shields.io/github/tag/SciTools/cartopy.svg"
   alt="Latest version" /></a>
  <a href="https://github.com/SciTools/cartopy/commits/main">
  <img src="https://img.shields.io/github/commits-since/SciTools/cartopy/latest.svg"
   alt="Commits since last release" /></a>
  <a href="https://github.com/SciTools/cartopy/graphs/contributors">
  <img src="https://img.shields.io/github/contributors/SciTools/cartopy.svg"
   alt="# contributors" /></a>
  <a href="https://travis-ci.org/SciTools/cartopy/branches">
  <img src="https://api.travis-ci.org/repositories/SciTools/cartopy.svg?branch=main"
   alt="Travis-CI" /></a>
  <a href="https://zenodo.org/badge/latestdoi/5282596">
  <img src="https://zenodo.org/badge/5282596.svg"
   alt="zenodo" /></a>
  <a href="https://gitter.im/SciTools/cartopy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge">
  <img src="https://badges.gitter.im/SciTools/cartopy.svg" alt="Gitter Chat" /></a>
  </p>
  <br>



  <!--
  NOTE: toc auto-generated with https://github.com/jonschlinkert/markdown-toc
      $> markdown-toc -i --bullets='-' README.md

  NOTE: This entire README can be markdown linted with
      https://github.com/igorshubovych/markdownlint-cli
      $ echo '{"no-inline-html": false}' > .markdownrc
      $ markdownlint README.md
  -->

  <!-- toc -->

  - [Overview](#overview)
  - [Get in touch](#get-in-touch)
  - [License and copyright](#license-and-copyright)

  <!-- tocstop -->



  Cartopy is a Python package designed to make drawing maps for data
  analysis and visualisation easy.

  It features:

  - object oriented projection definitions
  - point, line, polygon and image transformations between projections
  - integration to expose advanced mapping in Matplotlib with a simple and
    intuitive interface
  - powerful vector data handling by integrating shapefile reading with Shapely
    capabilities

  Documentation can be found at <https://scitools.org.uk/cartopy/docs/latest/>.



  - Ask usage questions on
    [StackOverflow](https://stackoverflow.com/questions/tagged/cartopy).
  - For less well defined questions, ideas, general discussion or announcements
    of related projects use the
    [Google Group](https://groups.google.com/forum/#!forum/scitools-iris).
  - Report bugs, suggest features or view the source code on
    [GitHub](https://github.com/SciTools/cartopy).
  - To chat with developers and other users you can use the
    [Gitter Chat](https://gitter.im/SciTools/cartopy)




  Cartopy is developed collaboratively under the SciTools umberella.

  A full list of codecontributors ("Cartopy contributors") can be found at
  https://github.com/SciTools/cartopy/graphs/contributors.

  Code is just one of many ways of positively contributing to Cartopy, please see
  our [contributing guide](.github/CONTRIBUTING.md) for more details on how
  you can get involved.

  Cartopy is released under a LGPL license with a shared copyright model.
  See [COPYING](COPYING) and [COPYING.LESSER](COPYING.LESSER) for full terms.

  The [Met Office](https://metoffice.gov.uk) has made a significant
  contribution to the development, maintenance and support of this library.
  All Met Office contributions are copyright on behalf of the British Crown.


pkgId: 704dc698528b102d04615badb65733dfd12e5c1eaad22636d9575cd846d0e562
name: python-Cerberus
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Lightweight, extensible schema and data validation tool for Python dictionaries.
url: http://docs.python-cerberus.org
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c5582b0-734f-4cea-b75a-fad8967a7c64
location_href: 00003196-python-cerberus/python-Cerberus-1.3.4-1.src.rpm
checksum_type: sha256
description:
  |build-status| |python-support| |black|
  Cerberus is a lightweight and extensible data validation library for Python.
      >>> v = Validator({'name': {'type': 'string'}})
      >>> v.validate({'name': 'john doe'})
      True


pkgId: 4a83b6210816b3d5b77a563acc2927bbb1254411630b576c0ceb6cfb0ad1c575
name: python-Cerealizer
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: A secure pickle-like module
url: http://www.lesfleursdunormal.fr/static/informatique/cerealizer/index_en.html
rpm_license: Python licence
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0b5aa99b-04a3-4f83-b197-8bb5a39aaf82
location_href: 00003197-python-cerealizer/python-Cerealizer-0.8.3-1.src.rpm
checksum_type: sha256
description:
  A secure pickle-like module.
  It support basic types (int, string, unicode, tuple, list, dict, set,...),
  old and new-style classes (you need to register the class for security), object cycles,
  and it can be extended to support C-defined type.


pkgId: 42eef6c5872d91ac95d49bdcf9c8335bf40011f6729ff5d8bffdfefe37382790
name: python-Chameleon
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Fast HTML/XML Template Compiler.
url: https://chameleon.readthedocs.io
rpm_license: BSD-like (http://repoze.org/license.html)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-77c30938-7a6f-4885-a6ac-3148d28a9f25
location_href: 00003218-python-chameleon/python-Chameleon-4.0.0-1.src.rpm
checksum_type: sha256
description:
  Chameleon is an HTML/XML template engine for `Python
  <http://www.python.org>`_. It uses the *page templates* language.
  You can use it in any Python web application with just about any
  version of Python (2.7 and up, including 3.4+ and `pypy
  <http://pypy.org>`_).
  Visit the `documentation <https://chameleon.readthedocs.io/en/latest/>`_
  for more information.


pkgId: 29d08dac1128b915ada937a776c9522c6f141feb08841977c21b26605aa4fb17
name: python-ChatterBot
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: ChatterBot is a machine learning, conversational dialog engine.
url: https://github.com/gunthercox/ChatterBot
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-af30adbe-229c-4586-8d67-c1b1299f7857
location_href: 00012801-python-chatterbot/python-ChatterBot-1.0.8-1.src.rpm
checksum_type: sha256
description:
  ![ChatterBot: Machine learning in Python](https://i.imgur.com/b3SCmGT.png)



  ChatterBot is a machine-learning based conversational dialog engine build in
  Python which makes it possible to generate responses based on collections of
  known conversations. The language independent design of ChatterBot allows it
  to be trained to speak any language.

  [![Package Version](https://img.shields.io/pypi/v/chatterbot.svg)](https://pypi.python.org/pypi/chatterbot/)
  [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/)
  [![Django 2.0](https://img.shields.io/badge/Django-2.0-blue.svg)](https://docs.djangoproject.com/en/2.1/releases/2.0/)
  [![Requirements Status](https://requires.io/github/gunthercox/ChatterBot/requirements.svg?branch=master)](https://requires.io/github/gunthercox/ChatterBot/requirements/?branch=master)
  [![Build Status](https://travis-ci.org/gunthercox/ChatterBot.svg?branch=master)](https://travis-ci.org/gunthercox/ChatterBot)
  [![Documentation Status](https://readthedocs.org/projects/chatterbot/badge/?version=stable)](http://chatterbot.readthedocs.io/en/stable/?badge=stable)
  [![Coverage Status](https://img.shields.io/coveralls/gunthercox/ChatterBot.svg)](https://coveralls.io/r/gunthercox/ChatterBot)
  [![Code Climate](https://codeclimate.com/github/gunthercox/ChatterBot/badges/gpa.svg)](https://codeclimate.com/github/gunthercox/ChatterBot)
  [![Join the chat at https://gitter.im/chatterbot/Lobby](https://badges.gitter.im/chatterbot/Lobby.svg)](https://gitter.im/chatterbot/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)

  An example of typical input would be something like this:

  > **user:** Good morning! How are you doing?
  > **bot:**  I am doing very well, thank you for asking.
  > **user:** You're welcome.
  > **bot:** Do you like hats?



  An untrained instance of ChatterBot starts off with no knowledge of how to communicate. Each time a user enters a statement, the library saves the text that they entered and the text that the statement was in response to. As ChatterBot receives more input the number of responses that it can reply and the accuracy of each response in relation to the input statement increase. The program selects the closest matching response by searching for the closest matching known statement that matches the input, it then returns the most likely response to that statement based on how frequently each response is issued by the people the bot communicates with.



  This package can be installed from [PyPi](https://pypi.python.org/pypi/ChatterBot) by running:

  ```
  pip install chatterbot
  ```



  ```
  from chatterbot import ChatBot
  from chatterbot.trainers import ChatterBotCorpusTrainer

  chatbot = ChatBot('Ron Obvious')


  trainer = ChatterBotCorpusTrainer(chatbot)


  trainer.train("chatterbot.corpus.english")


  chatbot.get_response("Hello, how are you today?")
  ```



  ChatterBot comes with a data utility module that can be used to train chat bots.
  At the moment there is training data for over a dozen languages in this module.
  Contributions of additional training data or training data
  in other languages would be greatly appreciated. Take a look at the data files
  in the [chatterbot-corpus](https://github.com/gunthercox/chatterbot-corpus)
  package if you are interested in contributing.

  ```
  from chatterbot.trainers import ChatterBotCorpusTrainer


  trainer = ChatterBotCorpusTrainer(chatbot)


  trainer.train("chatterbot.corpus.english")


  trainer.train("chatterbot.corpus.english.greetings")


  trainer.train("chatterbot.corpus.english.conversations")
  ```

  **Corpus contributions are welcome! Please make a pull request.**



  View the [documentation](https://chatterbot.readthedocs.io/)
  for ChatterBot on Read the Docs.

  To build the documentation yourself using [Sphinx](http://www.sphinx-doc.org/), run:

  ```
  sphinx-build -b html docs/ build/
  ```



  For examples, see the [examples](https://github.com/gunthercox/ChatterBot/tree/master/examples)
  directory in this project's git repository.

  There is also an example [Django project using ChatterBot](https://github.com/gunthercox/ChatterBot/tree/master/examples), as well as an example [Flask project using ChatterBot](https://github.com/chamkank/flask-chatterbot).



  See release notes for changes https://github.com/gunthercox/ChatterBot/releases



  1. [Create a fork](https://help.github.com/articles/fork-a-repo/) of
     the [main ChatterBot repository](https://github.com/gunthercox/ChatterBot) on GitHub.
  2. Make your changes in a branch named something different from `master`, e.g. create
     a new branch `my-pull-request`.
  3. [Create a pull request](https://help.github.com/articles/creating-a-pull-request/).
  4. Please follow the [Python style guide for PEP-8](https://www.python.org/dev/peps/pep-0008/).
  5. Use the projects [built-in automated testing](https://chatterbot.readthedocs.io/en/latest/testing.html).
     to help make sure that your contribution is free from errors.



  ChatterBot is licensed under the [BSD 3-clause license](https://opensource.org/licenses/BSD-3-Clause).


pkgId: 295250e3d53207bd6ed2710c9c35920db3c9056a52331a51a4cbf8fe9cfdcaac
name: python-ClusterShell
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: ClusterShell library and tools
url: https://clustershell.readthedocs.io/
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dcaba603-ff81-4c9a-88d4-edb48ba3ea75
location_href: 00003257-python-clustershell/python-ClusterShell-1.9.1-1.src.rpm
checksum_type: sha256
description:
  ClusterShell provides clush, clubak and cluset/nodeset, convenient command-line
  tools that allow traditional shell scripts to benefit from some of the
  library's features:
  - **clush**: issue commands to cluster nodes and format output
  Example of use:
    $ clush -abL uname -r
    node[32-49,51-71,80,82-150,156-159]: 2.6.18-164.11.1.el5
    node[3-7,72-79]: 2.6.18-164.11.1.el5_lustre1.10.0.36
    node[2,151-155]: 2.6.31.6-145.fc11.2.x86_64
  See *man clush* for more details.
  - **clubak**: improved dshbak to gather and sort dsh-like outputs
  See *man clubak* for more details.
  - **nodeset** (or **cluset**): compute advanced nodeset/nodegroup operations
  Examples of use:
    $ echo node160 node161 node162 node163 | nodeset -f
    node[160-163]
    $ nodeset -f node[0-7,32-159] node[160-163]
    node[0-7,32-163]
    $ nodeset -e node[160-163]
    node160 node161 node162 node163
    $ nodeset -f node[32-159] -x node33
    node[32,34-159]
    $ nodeset -f node[32-159] -i node[0-7,20-21,32,156-159]
    node[32,156-159]
    $ nodeset -f node[33-159] --xor node[32-33,156-159]
    node[32,34-155]
    $ nodeset -l
    @oss
    @mds
    @io
    @compute
    $ nodeset -e @mds
    node6 node7
  See *man nodeset* (or *man cluset*) for more details.
  Please visit the ClusterShell website_.


pkgId: c563e672d5f47c123bfb1de7a56623f39bf7831b904da237236ec9db536543e8
name: python-Collectfast
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: A Faster Collectstatic
url: https://github.com/antonagestam/collectfast/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-87247324-bd3f-4446-8e65-a3a7b634d4ae
location_href: 00012072-python-collectfast/python-Collectfast-2.2.0-1.src.rpm
checksum_type: sha256
description:
  collectfast.strategies.boto3.Boto3Strategy|storages.backends.s3boto3.S3Boto3Storage
  collectfast.strategies.gcloud.GoogleCloudStrategy|storages.backends.gcloud.GoogleCloudStorage
  collectfast.strategies.filesystem.FileSystemStrategy|django.core.files.storage.FileSystemStorage
  Custom strategies can also be made for backends not listed above by
  implementing the `collectfast.strategies.Strategy` ABC.

  Collectfast overrides Django's builtin `collectstatic` command so just run
  `python manage.py collectstatic` as normal.
  You can disable Collectfast by using the `--disable-collectfast` option or by
  setting `COLLECTFAST_ENABLED = False` in your settings file.

  It's recommended to setup a dedicated cache backend for Collectfast. Every time
  Collectfast does not find a lookup for a file in the cache it will trigger a
  lookup to the storage backend, so it's recommended to have a fairly high
  `TIMEOUT` setting.
  Configure your dedicated cache with the `COLLECTFAST_CACHE` setting:
  ```python
  CACHES = {
      'default': {
          
      },
      'collectfast': {
          
      },
  }
  COLLECTFAST_CACHE = 'collectfast'
  ```
  If `COLLECTFAST_CACHE` isn't set, the `default` cache will be used.
  **Note:** Collectfast will never clean the cache of obsolete files. To clean
  out the entire cache, use `cache.clear()`. [See docs for Django's cache
  framework][django-cache].
  **Note:** We recommend you to set the `MAX_ENTRIES` setting if you have more
  than 300 static files, see [#47][issue-47].
  [django-cache]: https://docs.djangoproject.com/en/stable/topics/cache/
  [issue-47]: https://github.com/antonagestam/collectfast/issues/47

  The parallelization feature enables parallel file uploads using Python's
  `concurrent.futures` module. Enable it by setting the `COLLECTFAST_THREADS`
  setting.
  To enable parallel uploads, a dedicated cache backend must be setup and it must
  use a backend that is thread-safe, i.e. something other than Django's default
  LocMemCache.
  ```python
  COLLECTFAST_THREADS = 20
  ```

  By default, Collectfast will suppress any exceptions that happens when copying
  and let Django's `collectstatic` handle it. To debug those suppressed errors
  you can set `COLLECTFAST_DEBUG = True` in your Django settings file.

  Please feel free to contribute by using issues and pull requests. Discussion is
  open and welcome.

  The test suite is built to run against live S3 and GCloud buckets. You can
  disable live tests by setting `SKIP_LIVE_TESTS=true` or running `make
  test-skip-live`. To run live tests locally you need to provide API credentials
  to test against. Add the credentials to a file named `storage-credentials` in
  the root of the project directory:
  ```bash
  export AWS_ACCESS_KEY_ID='...'
  export AWS_SECRET_ACCESS_KEY='...'
  export GCLOUD_CREDENTIALS='{...}'  # Google Cloud credentials as JSON
  ```
  Install test dependencies and target Django version:
  ```bash
  python3 -m pip install -r test-requirements.txt
  python3 -m pip install django==2.2
  ```
  Run test suite:
  ```bash
  make test
  ```
  Code quality tools are broken out from test requirements because some of them
  only install on Python >= 3.7.
  ```bash
  python3 -m pip install -r lint-requirements.txt
  ```
  Run linters and static type check:
  ```bash
  make lint
  ```

  Collectfast is licensed under the MIT License, see LICENSE file for more
  information.


pkgId: fbde05b8585f81438afd486c83d22a774d446ed102f48b5735904336518c41e9
name: python-Command
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Command runner with debug capabilities
url: http://github.com/helgi/python-command
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-52d14730-6070-47a9-9c40-8d54bda95ba2
location_href: 00011027-python-command/python-Command-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Wrapper around subprocess.popen with on the fly debug / logging
  capabilities and timeout handling.
  Uses tempfiles for stdout/stderr to get past the 64kb subprocess.PIPE
  bug/limitation in python.
  Normal command run
      import command
      response = command.run(['ls'])
      print response.output
      print response.exit
  Print the output as it happens
      import command
      def debug(text):
          print text
      response = command.run(['ls'], debug=debug)
      print response.output
      print response.exit


pkgId: cbd6a052ec15e852748077835ec6cca6fe5dad85a2418c67b0a6bb5dec1dafd1
name: python-ConcurrentLogHandler
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Concurrent logging handler (drop-in replacement for RotatingFileHandler) Python 2.6+
url: http://launchpad.net/python-concurrent-log-handler
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a995514b-c014-4972-af36-b58894de789b
location_href: 00003315-python-concurrentloghandler/python-ConcurrentLogHandler-0.9.1-1.src.rpm
checksum_type: sha256
description:
  This module provides an additional log handler for Python's standard logging
  package (PEP 282). This handler will write log events to log file which is
  rotated when the log file reaches a certain size.  Multiple processes can
  safely write to the same log file concurrently.


pkgId: dd5296417821f00db5576fbea7f62a6784345df879b2f3dc917eb9b2f70d7e33
name: python-ConfigArgParse
arch: src
version: 1.5.3
epoch: 0
release: 1
url: https://github.com/bw2/ConfigArgParse
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5026c0ff-e09d-454b-9c4f-0daefd3f4774
location_href: 00003319-python-configargparse/python-ConfigArgParse-1.5.3-1.src.rpm
checksum_type: sha256
summary:
  A drop-in replacement for argparse that allows options to also be set via config files and/or environment variables.

description:
  Overview
  ~~~~~~~~
  Applications with more than a handful of user-settable options are best
  configured through a combination of command line args, config files,
  hard-coded defaults, and in some cases, environment variables.
  Python's command line parsing modules such as argparse have very limited
  support for config files and environment variables, so this module
  extends argparse to add these features.
  Available on PyPI: http://pypi.python.org/pypi/ConfigArgParse
  Features
  ~~~~~~~~
  -  command-line, config file, env var, and default settings can now be
     defined, documented, and parsed in one go using a single API (if a
     value is specified in more than one way then: command line >
     environment variables > config file values > defaults)
  -  config files can have .ini or .yaml style syntax (eg. key=value or
     key: value)
  -  user can provide a config file via a normal-looking command line arg
     (eg. -c path/to/config.txt) rather than the argparse-style @config.txt
  -  one or more default config file paths can be specified
     (eg. ['/etc/bla.conf', '~/.my_config'] )
  -  all argparse functionality is fully supported, so this module can
     serve as a drop-in replacement (verified by argparse unittests).
  -  env vars and config file keys & syntax are automatically documented
     in the -h help message
  -  new method :code:`print_values()` can report keys & values and where
     they were set (eg. command line, env var, config file, or default).
  -  lite-weight (no 3rd-party library dependencies except (optionally) PyYAML)
  -  extensible (:code:`ConfigFileParser` can be subclassed to define a new
     config file format)
  -  unittested by running the unittests that came with argparse but on
     configargparse, and using tox to test with Python 2.7 and Python 3+
  Example
  ~~~~~~~
  *config_test.py*:
  Script that defines 4 options and a positional arg and then parses and prints the values. Also,
  it prints out the help message as well as the string produced by :code:`format_values()` to show
  what they look like.
     import configargparse
     p = configargparse.ArgParser(default_config_files=['/etc/app/conf.d/*.conf', '~/.my_settings'])
     p.add('-c', '--my-config', required=True, is_config_file=True, help='config file path')
     p.add('--genome', required=True, help='path to genome file')  # this option can be set in a config file because it starts with '--'
     p.add('-v', help='verbose', action='store_true')
     p.add('-d', '--dbsnp', help='known variants .vcf', env_var='DBSNP_PATH')  # this option can be set in a config file because it starts with '--'
     p.add('vcf', nargs='+', help='variant file(s)')
     options = p.parse_args()
     print(options)
     print("----------")
     print(p.format_help())
     print("----------")
     print(p.format_values())    # useful for logging where different settings came from
  *config.txt:*
  Since the script above set the config file as required=True, lets create a config file to give it:
      
      genome = HCMV     # cytomegalovirus genome
      dbsnp = /data/dbsnp/variants.vcf
  *command line:*
  Now run the script and pass it the config file:
      DBSNP_PATH=/data/dbsnp/variants_v2.vcf python config_test.py --my-config config.txt f1.vcf f2.vcf
  *output:*
  Here is the result:


pkgId: a597785f9c2288c8174a902212beed3ae4b5b8751b6842d727ad091e3701ce8e
name: python-CouchDB
arch: src
version: 1.2
epoch: 0
release: 1
summary: Python library for working with CouchDB
url: https://github.com/djc/couchdb-python/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e4771f4-e1f0-400f-b050-a9b93f075eed
location_href: 00013438-python-couchdb/python-CouchDB-1.2-1.src.rpm
checksum_type: sha256
description:
  This is a Python library for CouchDB. It provides a convenient high level
  interface for the CouchDB server.


pkgId: bc74fcc68a58de0fae73e2169cf4e2d23821ba34724e24e3b4863bbca35eefdc
name: python-CredSLayer
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Extract credentials and other useful info from network captures
url: https://github.com/ShellCode33/CredSLayer
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d426db5-e8fb-4c35-84c0-91e601613a22
location_href: 00003353-python-credslayer/python-CredSLayer-0.1.3-1.src.rpm
checksum_type: sha256
description:
  ![alt python_version](https://img.shields.io/badge/python-3.5+-informational.svg?style=for-the-badge)
  ![alt tests_coverage](https://img.shields.io/badge/tests%20coverage-94%25-success.svg?style=for-the-badge)
  [![alt documentation](https://img.shields.io/badge/documentation-critical.svg?style=for-the-badge)](https://shellcode33.github.io/CredSLayer/)

  CredSLayer goal is to look for credentials and other useful stuff in network captures. Two modes are available, pcap scanning and active processing. The latest listens for packets on a chosen interface and dynamically extracts everything it can.

  This tool has been heavily inspired by [Pcredz](https://github.com/lgandx/PCredz) and [net-creds](https://github.com/DanMcInerney/net-creds) but is built with extensibility in mind.
  Pcredz and net-creds are great, but they are really hard to maintain and improve.
  Unlike these tools which are using regex and raw bytes parsing, CredSLayer takes advantage of Wireshark dissectors which have proven over time to be pretty accurate and reliable.
  It makes it really easy to add support for new protocols.


  This tool can be really helpful if you're doing IT security or if you want to scan your own network to see if anything critical is transmitted.

  ![alt credslayer_output_example](https://github.com/ShellCode33/CredSLayer/raw/master/docs/example.png)



  CredSLayer doesn't waste your time with invalid credentials, it makes sure credentials are valid.
  Yet if it's not able to tell whether they're valid or not, what has been found will be printed out anyway.

  Right now, CredSLayer supports the following protocols:
  * FTP
  * SMTP / IMAP / POP3
  * Telnet
  * HTTP
  * LDAP
  * SNMP
  * MySQL / PostgreSQL
  * NTLMSSP
  * Kerberos coming soon...

  It is also able to look for email addresses and credit card numbers.

  **Note:** To prevent false positives and performance issues, tshark (the Wireshark underlying engine) identifies protocols based on port numbers to know which dissector to use on which packets. A few protocols however have heuristic analysis to guess the protocol on different ports than the usual ones (such as HTTP). See the [limitation chapter](https://shellcode33.github.io/CredSLayer/getting-started/limitations.html) in the documentation. To address this issue, CredSLayer has a `--map` parameter, it enables you to map a (range of) port(s) to a specific protocol. This way you will be able to sniff credentials going to a specific service on a specific port you are aware of.



  You need `tshark` installed and Python >= 3.5. On some distribution tshark in shipped within the `wireshark` package.

  Then simply install using :

  ```
  $ pip install credslayer
  ```

  I recommend you use a [virtualenv](https://docs.python.org/3/library/venv.html) to prevent conflicts.



  ```
  $ credslayer -h
  usage: credslayer [-h] [-l INTERFACE] [-s {enable,disable}] [-f IP]
                       [-m PORT:PROTOCOL] [--debug]
                       [pcapfiles [pcapfiles ...]]

  Helps you find credentials and other interesting stuff in network captures

  positional arguments:
    pcapfiles             pcap files you want to analyse.

  optional arguments:
    -h, --help            show this help message and exit
    -l INTERFACE, --listen INTERFACE
                          start active processing on specified interface
    -s {enable,disable}, --string-inspection {enable,disable}
                          let you specify if you want to look for interesting
                          strings (email addresses, credit cards, ...) in
                          network captures. Pretty heavy on the CPU. Enabled by
                          default on pcap files, disabled on live captures.
    -f IP, --filter IP    only show packets involving the specified IP.
    -m PORT:PROTOCOL, --map PORT:PROTOCOL
                          map a port to a protocol
    --debug               put CredSLayer and pyshark in debug mode.
  ```



  Thanks to Wireshark dissectors, it's really easy to write new protocols support, you're welcome to contribute !

  Contributing doesn't necessarily mean writing code. You can simply contribute by opening new issues on Github if you spot any bug or if you would like to see something added to the tool.

  To learn how to create support for a new protocol, head over to the [documentation](https://shellcode33.github.io/CredSLayer/contribute/create-parser.html).



  * CredSLayer is based on [pyshark](https://github.com/KimiNewt/pyshark), a tshark Python wrapper

  * Wireshark for their [pcaps](https://wiki.wireshark.org/SampleCaptures)

  * [moloch](https://github.com/aol/moloch) for their [pcaps](https://github.com/aol/moloch/tree/master/tests/pcap)

  * [asecuritysite](https://asecuritysite.com) for their [pcaps](https://asecuritysite.com/forensics/pcap)


pkgId: 1c2ee3a909b47a70366d7940baa2bd77365c6bcd335121f0e30438eda4d4a3a1
name: python-Cython
arch: src
version: 0.29.33
epoch: 0
release: 1
summary: The Cython compiler for writing C extensions for the Python language.
url: http://cython.org/
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d85249e-e41a-4b1a-96a6-5141dcdb6a8e
location_href: 00002845-python-Cython/python-Cython-0.29.33-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: http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/


pkgId: c29e929466cb2bd46cf90fee8aeb1cc5e859e350dc61edcdd2672e181f3c2b6f
name: python-DAWG-Python
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Pure-python reader for DAWGs (DAFSAs) created by dawgdic C++ library or DAWG Python extension.
url: https://github.com/kmike/DAWG-Python/
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ce5c407-458b-414a-bd0c-2f19d957cb92
location_href: 00011527-python-dawg-python/python-DAWG-Python-0.7.2-1.src.rpm
checksum_type: sha256
description:
  This pure-python package provides read-only access for files
  created by `dawgdic`_ C++ library and `DAWG`_ python package.
  This package is not capable of creating DAWGs. It works with DAWGs built by
  `dawgdic`_ C++ library or `DAWG`_ Python extension module. The main purpose
  of DAWG-Python is to provide an access to DAWGs without requiring compiled
  extensions. It is also quite fast under PyPy (see benchmarks).


pkgId: 78f9dfeea9b8ab41efe556ee80837a6bc3653312323a9a5d0dba31309cf72610
name: python-DBUtils
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Database connections for multi-threaded environments.
url: https://webwareforpython.github.io/DBUtils/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dab3c53a-1d37-48ed-be06-cfc0dd4b3c60
location_href: 00010377-python-dbutils/python-DBUtils-3.0.2-1.src.rpm
checksum_type: sha256
description:
  DBUtils is a suite of tools providing solid, persistent and pooled connections
  to a database that can be used in all kinds of multi-threaded environments.
  The suite supports DB-API 2 compliant database interfaces
  and the classic PyGreSQL interface.
  The current version 3.0.2 of DBUtils supports Python versions 3.6 to 3.10.
  **Please have a look at the [changelog](https://webwareforpython.github.io/DBUtils/changelog.html), because there were some breaking changes in version 2.0.**
  The DBUtils home page can be found at https://webwareforpython.github.io/DBUtils/


pkgId: aefca97056bc6624d60a3f6e70a328a91ea15843cc9dde1e05779a713b76d425
name: python-Delorean
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: library for manipulating datetimes with ease and clarity
url: https://github.com/myusuf3/delorean
rpm_license: MIT license
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1124e542-77c1-4959-aa8b-14e067a2fa12
location_href: 00012559-python-delorean/python-Delorean-1.0.0-1.src.rpm
checksum_type: sha256
description:
  `Delorean` is a library for clearing up the inconvenient truths that arise dealing with datetimes in Python. Understanding that timing is a delicate enough of a problem `delorean` hopes to provide a cleaner less troublesome solution to shifting, manipulating, and generating `datetimes`.
  Delorean stands on the shoulders of giants `pytz <http://pytz.sourceforge.net/>`_ and `dateutil <http://labix.org/python-dateutil>`_
  `Delorean` will provide natural language improvements for manipulating time, as well as datetime abstractions for ease of use. The overall goal is to improve datetime manipulations, with a little bit of software and philosophy.
  Pretty much make you a badass time traveller.
  Getting Started
  ^^^^^^^^^^^^^^^
  Here is the world without a flux capacitor at your side:
      from datetime import datetime
      import pytz
      est = pytz.timezone('US/Eastern')
      d = datetime.now(pytz.utc)
      d = est.normalize(d.astimezone(est))
      return d
  Now lets warm up the `delorean`:
      from delorean import Delorean
      d = Delorean()
      d = d.shift('US/Eastern')
      return d
  Look at you looking all fly. This was just a test drive: check out out what else
  `delorean` can help with in the `documentation <http://delorean.readthedocs.org/en/latest/>`_.


pkgId: cefd01d7153cf95a40d0ceaa0bc5ecd9d1915aa1fa37a1ea82931d39cd9b867e
name: python-Deprecated
arch: src
version: 1.2.13
epoch: 0
release: 1
summary: Python @deprecated decorator to deprecate old python classes, functions or methods.
url: https://github.com/tantale/deprecated
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3db74b4b-1dba-40c7-b2c4-dc5ff5de227c
location_href: 00009056-python-deprecated/python-Deprecated-1.2.13-1.src.rpm
checksum_type: sha256
description:
  Deprecated is Easy to Use
  `````````````````````````
  If you need to mark a function or a method as deprecated,
  you can use the ``@deprecated`` decorator:
  Save in a hello.py:
      from deprecated import deprecated
      @deprecated(version='1.2.1', reason="You should use another function")
      def some_old_function(x, y):
          return x + y
      class SomeClass(object):
          @deprecated(version='1.3.0', reason="This method is deprecated")
          def some_old_method(self, x, y):
              return x + y
      some_old_function(12, 34)
      obj = SomeClass()
      obj.some_old_method(5, 8)
  And Easy to Setup
  `````````````````
  And run it:
      $ pip install Deprecated
      $ python hello.py
      hello.py:15: DeprecationWarning: Call to deprecated function (or staticmethod) some_old_function.
      (You should use another function) -- Deprecated since version 1.2.0.
        some_old_function(12, 34)
      hello.py:17: DeprecationWarning: Call to deprecated method some_old_method.
      (This method is deprecated) -- Deprecated since version 1.3.0.
        obj.some_old_method(5, 8)
  You can document your code
  ``````````````````````````
  Have you ever wonder how to document that some functions, classes, methods, etc. are deprecated?
  This is now possible with the integrated Sphinx directives:
  For instance, in hello_sphinx.py:
      from deprecated.sphinx import deprecated
      from deprecated.sphinx import versionadded
      from deprecated.sphinx import versionchanged
      @versionadded(version='1.0', reason="This function is new")
      def function_one():
          '''This is the function one'''
      @versionchanged(version='1.0', reason="This function is modified")
      def function_two():
          '''This is the function two'''
      @deprecated(version='1.0', reason="This function will be removed soon")
      def function_three():
          '''This is the function three'''
      function_one()
      function_two()
      function_three()  # warns
      help(function_one)
      help(function_two)
      help(function_three)
  The result it immediate
  ```````````````````````
  Run it:
      $ python hello_sphinx.py
      hello_sphinx.py:23: DeprecationWarning: Call to deprecated function (or staticmethod) function_three.
      (This function will be removed soon) -- Deprecated since version 1.0.
        function_three()  # warns
      Help on function function_one in module __main__:
      function_one()
          This is the function one
             This function is new
      Help on function function_two in module __main__:
      function_two()
          This is the function two
             This function is modified
      Help on function function_three in module __main__:
      function_three()
          This is the function three
             This function will be removed soon
  Links
  `````
  * `Python package index (PyPi) <https://pypi.python.org/pypi/deprecated>`_
  * `GitHub website <https://github.com/tantale/deprecated>`_
  * `Read The Docs <https://readthedocs.org/projects/deprecated>`_
  * `EBook on Lulu.com <http://www.lulu.com/commerce/index.php?fBuyContent=21305117>`_
  * `StackOverFlow Q&A <https://stackoverflow.com/a/40301488/1513933>`_
  * `Development version
    <https://github.com/tantale/deprecated/zipball/master#egg=Deprecated-dev>`_


pkgId: 66caf71e375db89db20ccd6cd5daf5e4380b67c6925bca15bf3bee8618890dbf
name: python-Dozer
arch: src
version: 0.8
epoch: 0
release: 1
summary: WSGI Middleware version of the CherryPy memory leak debugger
url: https://github.com/mgedmin/dozer
rpm_license: Public Domain
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0230184-c76b-44e0-b18f-0d5cc12711d2
location_href: 00013564-python-dozer/python-Dozer-0.8-1.src.rpm
checksum_type: sha256
description:
  Dozer was originally a WSGI middleware version of Robert Brewer's
  `Dowser CherryPy tool <http://www.aminus.net/wiki/Dowser>`_ that
  displays information as collected by the gc module to assist in
  tracking down memory leaks.  It now also has middleware for profiling
  and for looking at logged messages.


pkgId: a2563f6ecfb3d452b0be73eea5f9e6e4fbf1068a527d8734d74abc23574b162e
name: python-ECPy
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: Pure Pyhton Elliptic Curve Library
url: https://github.com/cslashm/ECPy
rpm_license: Apache License - Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-100ed1e9-1a02-4465-9f24-ac2c08464260
location_href: 00002846-python-ECPy/python-ECPy-1.2.5-1.src.rpm
checksum_type: sha256
description:
  ECPy (pronounced ekpy), is a pure python Elliptic Curve library
  providing ECDSA, EDDSA (Ed25519), ECSchnorr, Borromean signatures as well as Point
  operations.
  Full html documentation is available `here <https://cslashm.github.com/ECPy>`_.
  **ECDSA sample**
      from ecpy.curves     import Curve,Point
      from ecpy.keys       import ECPublicKey, ECPrivateKey
      from ecpy.ecdsa      import ECDSA
      cv   = Curve.get_curve('secp256k1')
      pu_key = ECPublicKey(Point(0x65d5b8bf9ab1801c9f168d4815994ad35f1dcb6ae6c7a1a303966b677b813b00,
                             0xe6b865e529b8ecbf71cf966e900477d49ced5846d7662dd2dd11ccd55c0aff7f,
                             cv))
      pv_key = ECPrivateKey(0xfb26a4e75eec75544c0f44e937dcf5ee6355c7176600b9688c667e5c283b43c5,
                        cv)
      signer = ECDSA()
      sig    = signer.sign(b'01234567890123456789012345678912',pv_key)
      assert(signer.verify(b'01234567890123456789012345678912',sig,pu_key))
  **Point sample**
      from ecpy.curves     import Curve,Point
      cv = Curve.get_curve('secp256k1')
      P  = Point(0x65d5b8bf9ab1801c9f168d4815994ad35f1dcb6ae6c7a1a303966b677b813b00,
                 0xe6b865e529b8ecbf71cf966e900477d49ced5846d7662dd2dd11ccd55c0aff7f,
                 cv)
      k  = 0xfb26a4e75eec75544c0f44e937dcf5ee6355c7176600b9688c667e5c283b43c5
      Q  = k*P
      R  = P+Q


pkgId: 7064ca38106ff81d8ce1c08da90c629574cea46f98040a1468bed2544773f26c
name: python-ERAlchemy
arch: src
version: 1.2.10
epoch: 0
release: 1
summary: Simple entity relation (ER) diagrams generation
url: https://github.com/Alexis-benoist/eralchemy
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f45138d-5d68-46ef-b8fd-f05bd8386969
location_href: 00003581-python-eralchemy/python-ERAlchemy-1.2.10-1.src.rpm
checksum_type: sha256
description:
  |Join the chat at https://gitter.im/Alexis-benoist/eralchemy|
  ERAlchemy generates Entity Relation (ER) diagram (like the one below)
  from databases or from SQLAlchemy models.


pkgId: 16488c30ed420ea7a60253512a449fd9fa061d3f15d5af133e4d0b57394339f5
name: python-EasyProcess
arch: src
version: 1.1
epoch: 0
release: 1
summary: Easy to use Python subprocess interface.
url: https://github.com/ponty/easyprocess
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7dbfd736-b6d8-4df4-b936-dc485e16f459
location_href: 00009695-python-easyprocess/python-EasyProcess-1.1-1.src.rpm
checksum_type: sha256
description:
  Easy to use Python subprocess interface.

  Documentation: https://github.com/ponty/easyprocess/tree/1.1


pkgId: 3f40c9ae4d2ad0c3ff53e109f6e099c3e5b1ffe627df02e3e57a800aee704b28
name: python-EbookLib
arch: src
version: 0.18
epoch: 0
release: 1
summary: Ebook library which can handle EPUB2/EPUB3 and Kindle format
url: https://github.com/aerkalov/ebooklib
rpm_license: GNU Affero General Public License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b947b271-950c-4d54-9d85-378245c54828
location_href: 00012253-python-ebooklib/python-EbookLib-0.18-1.src.rpm
checksum_type: sha256
description:
  EbookLib is a Python library for managing EPUB2/EPUB3 and Kindle files. It's capable of reading and writing EPUB files programmatically (Kindle support is under development).

  The API is designed to be as simple as possible, while at the same time making complex things possible too.  It has support for covers, table of contents, spine, guide, metadata and etc.

  EbookLib is used in `Booktype <https://github.com/sourcefabric/Booktype/>`_ from Sourcefabric, as well as `sprits-it! <https://github.com/the-happy-hippo/sprits-it>`_, `fanfiction2ebook <https://github.com/ltouroumov/fanfiction2ebook>`_, `viserlalune <https://github.com/vjousse/viserlalune>`_ and `Telemeta <https://github.com/Parisson/Telemeta>`_.

  Packages of EbookLib for GNU/Linux are available in `Debian <https://packages.debian.org/python-ebooklib>`_ and `Ubuntu <http://packages.ubuntu.com/python-ebooklib>`_.

  Sphinx documentation is generated from the templates in the docs/ directory and made available at http://ebooklib.readthedocs.io




  ```py
  import ebooklib
  from ebooklib import epub

  book = epub.read_epub('test.epub')

  for image in book.get_items_of_type(ebooklib.ITEM_IMAGE):
      print(image)
  ```



  ```py
  from ebooklib import epub

  book = epub.EpubBook()


  book.set_identifier("id123456")
  book.set_title("Sample book")
  book.set_language("en")

  book.add_author("Author Authorowski")
  book.add_author(
      "Danko Bananko",
      file_as="Gospodin Danko Bananko",
      role="ill",
      uid="coauthor",
  )


  c1 = epub.EpubHtml(title="Intro", file_name="chap_01.xhtml", lang="hr")
  c1.content = (
      "<h1>Intro heading</h1>"
      "<p>Zaba je skocila u baru.</p>"
      '<p><img alt="[ebook logo]" src="static/ebooklib.gif"/><br/></p>'
  )


  image_content = open("ebooklib.gif", "rb").read()
  img = epub.EpubImage(
      uid="image_1",
      file_name="static/ebooklib.gif",
      media_type="image/gif",
      content=image_content,
  )


  book.add_item(c1)

  book.add_item(img)


  book.toc = (
      epub.Link("chap_01.xhtml", "Introduction", "intro"),
      (epub.Section("Simple book"), (c1,)),
  )


  book.add_item(epub.EpubNcx())
  book.add_item(epub.EpubNav())


  style = "BODY {color: white;}"
  nav_css = epub.EpubItem(
      uid="style_nav",
      file_name="style/nav.css",
      media_type="text/css",
      content=style,
  )


  book.add_item(nav_css)


  book.spine = ["nav", c1]


  epub.write_epub("test.epub", book, {})
  ```



  EbookLib is licensed under the `AGPL license <LICENSE.txt>`_.



  Full list of authors is in `AUTHORS.txt <AUTHORS.txt>`_ file.


pkgId: 7ee063a8795585c4a221793a891225aa0da59ab32cac602c74323164efd94301
name: python-Eel
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: For little HTML GUI applications, with easy Python/JS interop
url: https://github.com/python-eel/Eel
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1dec375f-b707-4af3-9339-68115bec5629
location_href: 00013214-python-eel/python-Eel-0.16.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/Eel?style=for-the-badge)](https://pypi.org/project/Eel/)
  [![PyPi Downloads](https://img.shields.io/pypi/dm/Eel?style=for-the-badge)](https://pypistats.org/packages/eel)
  ![Python](https://img.shields.io/pypi/pyversions/Eel?style=for-the-badge)
  [![License](https://img.shields.io/pypi/l/Eel.svg?style=for-the-badge)](https://pypi.org/project/Eel/)


  [![Total alerts](https://img.shields.io/lgtm/alerts/g/samuelhwilliams/Eel.svg?logo=lgtm&style=for-the-badge)](https://lgtm.com/projects/g/samuelhwilliams/Eel/alerts/)
  [![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/samuelhwilliams/Eel.svg?logo=lgtm&style=for-the-badge)](https://lgtm.com/projects/g/samuelhwilliams/Eel/context:javascript)
  [![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/samuelhwilliams/Eel.svg?logo=lgtm&style=for-the-badge)](https://lgtm.com/projects/g/samuelhwilliams/Eel/context:python)


  Eel is a little Python library for making simple Electron-like offline HTML/JS GUI apps, with full access to Python capabilities and libraries.

  > **Eel hosts a local webserver, then lets you annotate functions in Python so that they can be called from Javascript, and vice versa.**

  Eel is designed to take the hassle out of writing short and simple GUI applications. If you are familiar with Python and web development, probably just jump to [this example](https://github.com/ChrisKnott/Eel/tree/master/examples/04%20-%20file_access) which picks random file names out of the given folder (something that is impossible from a browser).

  <p align="center"><img src="https://raw.githubusercontent.com/samuelhwilliams/Eel/master/examples/04%20-%20file_access/Screenshot.png" ></p>

  <!-- TOC -->

  - [Eel](#eel)
    - [Intro](#intro)
    - [Install](#install)
    - [Usage](#usage)
      - [Directory Structure](#directory-structure)
      - [Starting the app](#starting-the-app)
      - [App options](#app-options)
        - [Chrome/Chromium flags](#chromechromium-flags)
      - [Exposing functions](#exposing-functions)
      - [Eello, World!](#eello-world)
      - [Return values](#return-values)
        - [Callbacks](#callbacks)
        - [Synchronous returns](#synchronous-returns)
    - [Asynchronous Python](#asynchronous-python)
    - [Building distributable binary with PyInstaller](#building-distributable-binary-with-pyinstaller)
    - [Microsoft Edge](#microsoft-edge)

  <!-- /TOC -->



  There are several options for making GUI apps in Python, but if you want to use HTML/JS (in order to use jQueryUI or Bootstrap, for example) then you generally have to write a lot of boilerplate code to communicate from the Client (Javascript) side to the Server (Python) side.

  The closest Python equivalent to Electron (to my knowledge) is [cefpython](https://github.com/cztomczak/cefpython). It is a bit heavy weight for what I wanted.

  Eel is not as fully-fledged as Electron or cefpython - it is probably not suitable for making full blown applications like Atom - but it is very suitable for making the GUI equivalent of little utility scripts that you use internally in your team.

  For some reason many of the best-in-class number crunching and maths libraries are in Python (Tensorflow, Numpy, Scipy etc) but many of the best visualization libraries are in Javascript (D3, THREE.js etc). Hopefully Eel makes it easy to combine these into simple utility apps for assisting your development.

  Join Eel's users and maintainers on [Discord](https://discord.com/invite/3nqXPFX), if you like.



  Install from pypi with `pip`:

  ```shell
  pip install eel
  ```

  To include support for HTML templating, currently using [Jinja2](https://pypi.org/project/Jinja2/#description):

  ```shell
  pip install eel[jinja2]
  ```





  An Eel application will be split into a frontend consisting of various web-technology files (.html, .js, .css) and a backend consisting of various Python scripts.

  All the frontend files should be put in a single directory (they can be further divided into folders inside this if necessary).

  ```
  my_python_script.py     <-- Python scripts
  other_python_module.py
  static_web_folder/      <-- Web folder
    main_page.html
    css/
      style.css
    img/
      logo.png
  ```



  Suppose you put all the frontend files in a directory called `web`, including your start page `main.html`, then the app is started like this;

  ```python
  import eel
  eel.init('web')
  eel.start('main.html')
  ```

  This will start a webserver on the default settings (http://localhost:8000) and open a browser to http://localhost:8000/main.html.

  If Chrome or Chromium is installed then by default it will open in that in App Mode (with the `--app` cmdline flag), regardless of what the OS's default browser is set to (it is possible to override this behaviour).



  Additional options can be passed to `eel.start()` as keyword arguments.

  Some of the options include the mode the app is in (e.g. 'chrome'), the port the app runs on, the host name of the app, and adding additional command line flags.

  As of Eel v0.12.0, the following options are available to `start()`:
   - **mode**, a string specifying what browser to use (e.g. `'chrome'`, `'electron'`, `'edge'`, `'custom'`). Can also be `None` or `False` to not open a window. *Default: `'chrome'`*
   - **host**, a string specifying what hostname to use for the Bottle server. *Default: `'localhost'`)*
   - **port**, an int specifying what port to use for the Bottle server. Use `0` for port to be picked automatically. *Default: `8000`*.
   - **block**, a bool saying whether or not the call to `start()` should block the calling thread. *Default: `True`*
   - **jinja_templates**, a string specifying a folder to use for Jinja2 templates, e.g. `my_templates`. *Default:  `None`*
   - **cmdline_args**, a list of strings to pass to the command to start the browser. For example, we might add extra flags for Chrome; ```eel.start('main.html', mode='chrome-app', port=8080, cmdline_args=['--start-fullscreen', '--browser-startup-dialog'])```. *Default: `[]`*
   - **size**, a tuple of ints specifying the (width, height) of the main window in pixels *Default: `None`*
   - **position**, a tuple of ints specifying the (left, top) of the main window in pixels *Default: `None`*
   - **geometry**, a dictionary specifying the size and position for all windows. The keys should be the relative path of the page, and the values should be a dictionary of the form `{'size': (200, 100), 'position': (300, 50)}`. *Default: {}*
   - **close_callback**, a lambda or function that is called when a websocket to a window closes (i.e. when the user closes the window). It should take two arguments; a string which is the relative path of the page that just closed, and a list of other websockets that are still open. *Default: `None`*
   - **app**, an instance of Bottle which will be used rather than creating a fresh one. This can be used to install middleware on the instance before starting eel, e.g. for session management, authentication, etc. If your `app` is not a Bottle instance, you will need to call `eel.register_eel_routes(app)` on your custom app instance.
   - **shutdown_delay**, timer configurable for Eel's shutdown detection mechanism, whereby when any websocket closes, it waits `shutdown_delay` seconds, and then checks if there are now any websocket connections. If not, then Eel closes. In case the user has closed the browser and wants to exit the program. By default, the value of **shutdown_delay** is `1.0` second





  In addition to the files in the frontend folder, a Javascript library will be served at `/eel.js`. You should include this in any pages:

  ```html
  <script type="text/javascript" src="/eel.js"></script>
  ```

  Including this library creates an `eel` object which can be used to communicate with the Python side.

  Any functions in the Python code which are decorated with `@eel.expose` like this...

  ```python
  @eel.expose
  def my_python_function(a, b):
      print(a, b, a + b)
  ```

  ...will appear as methods on the `eel` object on the Javascript side, like this...

  ```javascript
  console.log("Calling Python...");
  eel.my_python_function(1, 2); // This calls the Python function that was decorated
  ```

  Similarly, any Javascript functions which are exposed like this...

  ```javascript
  eel.expose(my_javascript_function);
  function my_javascript_function(a, b, c, d) {
    if (a < b) {
      console.log(c * d);
    }
  }
  ```

  can be called from the Python side like this...

  ```python
  print('Calling Javascript...')
  eel.my_javascript_function(1, 2, 3, 4)  # This calls the Javascript function
  ```

  The exposed name can also be overridden by passing in a second argument. If your app minifies JavaScript during builds, this may be necessary to ensure that functions can be resolved on the Python side:

  ```javascript
  eel.expose(someFunction, "my_javascript_function");
  ```

  When passing complex objects as arguments, bear in mind that internally they are converted to JSON and sent down a websocket (a process that potentially loses information).



  > See full example in: [examples/01 - hello_world](https://github.com/ChrisKnott/Eel/tree/master/examples/01%20-%20hello_world)

  Putting this together into a **Hello, World!** example, we have a short HTML page, `web/hello.html`:

  ```html
  <!DOCTYPE html>
  <html>
    <head>
      <title>Hello, World!</title>

      <!-- Include eel.js - note this file doesn't exist in the 'web' directory -->
      <script type="text/javascript" src="/eel.js"></script>
      <script type="text/javascript">
        eel.expose(say_hello_js); // Expose this function to Python
        function say_hello_js(x) {
          console.log("Hello from " + x);
        }

        say_hello_js("Javascript World!");
        eel.say_hello_py("Javascript World!"); // Call a Python function
      </script>
    </head>

    <body>
      Hello, World!
    </body>
  </html>
  ```

  and a short Python script `hello.py`:

  ```python
  import eel



  eel.init('web', allowed_extensions=['.js', '.html'])

  @eel.expose                         # Expose this function to Javascript
  def say_hello_py(x):
      print('Hello from %s' % x)

  say_hello_py('Python World!')
  eel.say_hello_js('Python World!')   # Call a Javascript function

  eel.start('hello.html')             # Start (this blocks and enters loop)
  ```

  If we run the Python script (`python hello.py`), then a browser window will open displaying `hello.html`, and we will see...

  ```
  Hello from Python World!
  Hello from Javascript World!
  ```

  ...in the terminal, and...

  ```
  Hello from Javascript World!
  Hello from Python World!
  ```

  ...in the browser console (press F12 to open).

  You will notice that in the Python code, the Javascript function is called before the browser window is even started - any early calls like this are queued up and then sent once the websocket has been established.



  While we want to think of our code as comprising a single application, the Python interpreter and the browser window run in separate processes. This can make communicating back and forth between them a bit of a mess, especially if we always had to explicitly _send_ values from one side to the other.

  Eel supports two ways of retrieving _return values_ from the other side of the app, which helps keep the code concise.

  To prevent hanging forever on the Python side, a timeout has been put in place for trying to retrieve values from
  the JavaScript side, which defaults to 10000 milliseconds (10 seconds). This can be changed with the `_js_result_timeout` parameter to `eel.init`. There is no corresponding timeout on the JavaScript side.



  When you call an exposed function, you can immediately pass a callback function afterwards. This callback will automatically be called asynchronously with the return value when the function has finished executing on the other side.

  For example, if we have the following function defined and exposed in Javascript:

  ```javascript
  eel.expose(js_random);
  function js_random() {
    return Math.random();
  }
  ```

  Then in Python we can retrieve random values from the Javascript side like so:

  ```python
  def print_num(n):
      print('Got this from Javascript:', n)


  eel.js_random()(print_num)


  eel.js_random()(lambda n: print('Got this from Javascript:', n))
  ```

  (It works exactly the same the other way around).



  In most situations, the calls to the other side are to quickly retrieve some piece of data, such as the state of a widget or contents of an input field. In these cases it is more convenient to just synchronously wait a few milliseconds then continue with your code, rather than breaking the whole thing up into callbacks.

  To synchronously retrieve the return value, simply pass nothing to the second set of brackets. So in Python we would write:

  ```python
  n = eel.js_random()()  # This immediately returns the value
  print('Got this from Javascript:', n)
  ```

  You can only perform synchronous returns after the browser window has started (after calling `eel.start()`), otherwise obviously the call will hang.

  In Javascript, the language doesn't allow us to block while we wait for a callback, except by using `await` from inside an `async` function. So the equivalent code from the Javascript side would be:

  ```javascript
  async function run() {
    // Inside a function marked 'async' we can use the 'await' keyword.

    let n = await eel.py_random()(); // Must prefix call with 'await', otherwise it's the same syntax
    console.log("Got this from Python: " + n);
  }

  run();
  ```



  Eel is built on Bottle and Gevent, which provide an asynchronous event loop similar to Javascript. A lot of Python's standard library implicitly assumes there is a single execution thread - to deal with this, Gevent can "[monkey patch](https://en.wikipedia.org/wiki/Monkey_patch)" many of the standard modules such as `time`. ~~This monkey patching is done automatically when you call `import eel`~~. If you need monkey patching you should `import gevent.monkey` and call `gevent.monkey.patch_all()` _before_ you `import eel`. Monkey patching can interfere with things like debuggers so should be avoided unless necessary.

  For most cases you should be fine by avoiding using `time.sleep()` and instead using the versions provided by `gevent`. For convenience, the two most commonly needed gevent methods, `sleep()` and `spawn()` are provided directly from Eel (to save importing `time` and/or `gevent` as well).

  In this example...

  ```python
  import eel
  eel.init('web')

  def my_other_thread():
      while True:
          print("I'm a thread")
          eel.sleep(1.0)                  # Use eel.sleep(), not time.sleep()

  eel.spawn(my_other_thread)

  eel.start('main.html', block=False)     # Don't block on this call

  while True:
      print("I'm a main loop")
      eel.sleep(1.0)                      # Use eel.sleep(), not time.sleep()
  ```

  ...we would then have three "threads" (greenlets) running;

  1. Eel's internal thread for serving the web folder
  2. The `my_other_thread` method, repeatedly printing **"I'm a thread"**
  3. The main Python thread, which would be stuck in the final `while` loop, repeatedly printing **"I'm a main loop"**



  If you want to package your app into a program that can be run on a computer without a Python interpreter installed, you should use **PyInstaller**.

  1. Configure a virtualenv with desired Python version and minimum necessary Python packages
  2. Install PyInstaller `pip install PyInstaller`
  3. In your app's folder, run `python -m eel [your_main_script] [your_web_folder]` (for example, you might run `python -m eel hello.py web`)
  4. This will create a new folder `dist/`
  5. Valid PyInstaller flags can be passed through, such as excluding modules with the flag: `--exclude module_name`. For example, you might run `python -m eel file_access.py web --exclude win32com --exclude numpy --exclude cryptography`
  6. When happy that your app is working correctly, add `--onefile --noconsole` flags to build a single executable file

  Consult the [documentation for PyInstaller](http://PyInstaller.readthedocs.io/en/stable/) for more options.



  For Windows 10 users, Microsoft Edge (`eel.start(.., mode='edge')`) is installed by default and a useful fallback if a preferred browser is not installed. See the examples:

  - A Hello World example using Microsoft Edge: [examples/01 - hello_world-Edge/](https://github.com/ChrisKnott/Eel/tree/master/examples/01%20-%20hello_world-Edge)
  - Example implementing browser-fallbacks: [examples/07 - CreateReactApp/eel_CRA.py](https://github.com/ChrisKnott/Eel/tree/master/examples/07%20-%20CreateReactApp/eel_CRA.py)


pkgId: a1d79ea8147823a271c27332c4b9cd5d6c0142da738a906b7f6c96729a00c1b0
name: python-Events
arch: src
version: 0.4
epoch: 0
release: 1
summary: Bringing the elegance of C# EventHandler to Python
url: http://github.com/pyeve/events
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-18e7d33b-0677-4704-8738-a1c49f47ad08
location_href: 00003589-python-events/python-Events-0.4-1.src.rpm
checksum_type: sha256
description:
  The C# language provides a handy way to declare, subscribe to and fire events.
  Technically, an event is a "slot" where callback functions (event handlers) can
  be attached to - a process referred to as subscribing to an event. Here is
  a handy package that encapsulates the core to event subscription and event
  firing and feels like a "natural" part of the language.
      >>> def something_changed(reason):
      >>> from events import Events
      >>> events = Events()
      >>> events.on_change += something_changed
  Multiple callback functions can subscribe to the same event. When the event is
  fired, all attached event handlers are invoked in sequence. To fire the event,
  perform a call on the slot:
      >>> events.on_change('it had to happen')
      'something changed because it had to happen'
  By default, Events does not check if an event can be subscribed to and fired.
  You can predefine events by subclassing Events and listing them. Attempts to
  subscribe to or fire an undefined event will raise an EventsException.
      >>> class MyEvents(Events):
      >>> events = MyEvents()
      
      >>> events.on_change += something_changed
  You can also predefine events for a single Events instance by passing an
  iterator to the constructor.
      >>> events = Events(('on_this', 'on_that'))
      
      >>> events.on_change += something_changed


pkgId: 1056bf5eeabae48f4ff0e05361248f12bb4fc7d5f3381bd67ad9664c3e4b53de
name: python-ExifRead
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Read Exif metadata from tiff and jpeg files.
url: https://github.com/ianare/exif-py
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1a1b696-d4f6-47e2-8fd9-1d345f6c6b90
location_href: 00009657-python-exifread/python-ExifRead-3.0.0-1.src.rpm
checksum_type: sha256
description:
  The recommended process is to install the `PyPI package <https://pypi.python.org/pypi/ExifRead>`_,
  as it allows easily staying up to date::
      $ pip install exifread
  See the `pip documentation <https://pip.pypa.io/en/latest/user_guide.html>`_ for more info.
  EXIF.py is mature software and strives for stability.


pkgId: a368dd88fd1524e2fbdeb4c4b7692dac2d42ef1eb0abaddef992cd3ccb50dd42
name: python-ExtensionClass-debuginfo
arch: aarch64
version: 5.0
epoch: 0
release: 1
summary: Debug information for package python-ExtensionClass
url: https://github.com/zopefoundation/ExtensionClass
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-70ef8875-34ce-498b-987c-3267b108b809
rpm_sourcerpm: python-ExtensionClass-5.0-1.src.rpm
location_href: 00012895-python-extensionclass/python-ExtensionClass-debuginfo-5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-ExtensionClass.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 27eab8f73d4572d019dbfc4ea328772946f0e83b7006b4c8cf59e1a05ce6de7c
name: python-ExtensionClass-debugsource
arch: aarch64
version: 5.0
epoch: 0
release: 1
summary: Debug sources for package python-ExtensionClass
url: https://github.com/zopefoundation/ExtensionClass
rpm_license: ZPL 2.1
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-70ef8875-34ce-498b-987c-3267b108b809
rpm_sourcerpm: python-ExtensionClass-5.0-1.src.rpm
location_href: 00012895-python-extensionclass/python-ExtensionClass-debugsource-5.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-ExtensionClass.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 39179e10071a6236b2f09052e7cb5717b7ebba8d7f1529554e980aa0fb430066
name: python-FLAML
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A fast library for automated machine learning and tuning
url: https://github.com/microsoft/FLAML
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-59a477a0-0f3e-47cf-b805-81c7c73d1537
location_href: 00013155-python-flaml/python-FLAML-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/FLAML.svg)](https://badge.fury.io/py/FLAML)
  ![Conda version](https://img.shields.io/conda/vn/conda-forge/flaml)
  [![Build](https://github.com/microsoft/FLAML/actions/workflows/python-package.yml/badge.svg)](https://github.com/microsoft/FLAML/actions/workflows/python-package.yml)
  ![Python Version](https://img.shields.io/badge/3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10-blue)
  [![Downloads](https://pepy.tech/badge/flaml)](https://pepy.tech/project/flaml)
  [![Join the chat at https://gitter.im/FLAMLer/community](https://badges.gitter.im/FLAMLer/community.svg)](https://gitter.im/FLAMLer/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![](https://img.shields.io/discord/1025786666260111483?logo=discord&style=flat)](https://discord.gg/Cppx2vSPVP)




  <p align="center">
      <img src="https://github.com/microsoft/FLAML/blob/main/website/static/img/flaml.svg"  width=200>
      <br>
  </p>

  :fire: OpenAI GPT-3 models support in v1.1.3. ChatGPT and GPT-4 support will be added in v1.2.0.

  :fire: A [lab forum](https://github.com/microsoft/FLAML/tree/tutorial-aaai23/tutorial) on FLAML at AAAI 2023.

  :fire: A [hands-on tutorial](https://github.com/microsoft/FLAML/tree/tutorial/tutorial) on FLAML presented at KDD 2022


  FLAML is a lightweight Python library that finds accurate machine
  learning models automatically, efficiently and economically. It frees users from selecting
  models and hyperparameters for each model. It can also be used to tune generic hyperparameters for foundation models, MLOps/LMOps workflows, pipelines, mathematical/statistical models, algorithms, computing experiments, software configurations and so on.

  1. For common machine learning or AI tasks like classification, regression, and generation, it quickly finds quality models for user-provided data with low computational resources. It supports both classical machine learning models and deep neural networks, including foundation models such as the GPT series.
  1. It is easy to customize or extend. Users can find their desired customizability from a smooth range: minimal customization (computational resource budget), medium customization (e.g., scikit-style learner, search space and metric), or full customization (arbitrary training and evaluation code).
  1. It supports fast automatic tuning, capable of handling complex constraints/guidance/early stopping. FLAML is powered by a new, [cost-effective
  hyperparameter optimization](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function/#hyperparameter-optimization-algorithm)
  and model selection method invented by Microsoft Research, and many followup [research studies](https://microsoft.github.io/FLAML/docs/Research).

  FLAML has a .NET implementation in [ML.NET](http://dot.net/ml), an open-source, cross-platform machine learning framework for .NET. In ML.NET, you can use FLAML via low-code solutions like [Model Builder](https://dotnet.microsoft.com/apps/machinelearning-ai/ml-dotnet/model-builder) Visual Studio extension and the cross-platform [ML.NET CLI](https://docs.microsoft.com/dotnet/machine-learning/automate-training-with-cli). Alternatively, you can use the [ML.NET AutoML API](https://www.nuget.org/packages/Microsoft.ML.AutoML/#versions-body-tab) for a code-first experience.






  FLAML requires **Python version >= 3.7**. It can be installed from pip:

  ```bash
  pip install flaml
  ```

  To run the [`notebook examples`](https://github.com/microsoft/FLAML/tree/main/notebook),
  install flaml with the [notebook] option:

  ```bash
  pip install flaml[notebook]
  ```



  Use the following guides to get started with FLAML in .NET:

  - [Install Model Builder](https://docs.microsoft.com/dotnet/machine-learning/how-to-guides/install-model-builder?tabs=visual-studio-2022)
  - [Install ML.NET CLI](https://docs.microsoft.com/dotnet/machine-learning/how-to-guides/install-ml-net-cli?tabs=windows)
  - [Microsoft.AutoML](https://www.nuget.org/packages/Microsoft.ML.AutoML/0.20.0)



  * With three lines of code, you can start using this economical and fast
  AutoML engine as a [scikit-learn style estimator](https://microsoft.github.io/FLAML/docs/Use-Cases/Task-Oriented-AutoML).

  ```python
  from flaml import AutoML
  automl = AutoML()
  automl.fit(X_train, y_train, task="classification")
  ```

  * You can restrict the learners and use FLAML as a fast hyperparameter tuning
  tool for XGBoost, LightGBM, Random Forest etc. or a [customized learner](https://microsoft.github.io/FLAML/docs/Use-Cases/Task-Oriented-AutoML#estimator-and-search-space).

  ```python
  automl.fit(X_train, y_train, task="classification", estimator_list=["lgbm"])
  ```

  * You can also run generic hyperparameter tuning for a [custom function](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function).

  ```python
  from flaml import tune
  tune.run(evaluation_function, config={…}, low_cost_partial_config={…}, time_budget_s=3600)
  ```

  * [Zero-shot AutoML](https://microsoft.github.io/FLAML/docs/Use-Cases/Zero-Shot-AutoML) allows using the existing training API from lightgbm, xgboost etc. while getting the benefit of AutoML in choosing high-performance hyperparameter configurations per task.

  ```python
  from flaml.default import LGBMRegressor


  estimator = LGBMRegressor()

  estimator.fit(X_train, y_train)
  ```

  * (New) You can optimize [generations](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation) by ChatGPT or GPT-4 etc. with your own tuning data, success metrics and budgets.

  ```python
  from flaml import oai

  config, analysis = oai.Completion.tune(
      data=tune_data,
      metric="success",
      mode="max",
      eval_func=eval_func,
      inference_budget=0.05,
      optimization_budget=3,
      num_samples=-1,
  )
  ```



  You can find a detailed documentation about FLAML [here](https://microsoft.github.io/FLAML/) where you can find the API documentation, use cases and examples.

  In addition, you can find:

  - [Talks](https://www.youtube.com/channel/UCfU0zfFXHXdAd5x-WvFBk5A) and [tutorials](https://github.com/microsoft/FLAML/tree/tutorial/tutorial) about FLAML.

  - Research around FLAML [here](https://microsoft.github.io/FLAML/docs/Research).

  - FAQ [here](https://microsoft.github.io/FLAML/docs/FAQ).

  - Contributing guide [here](https://microsoft.github.io/FLAML/docs/Contribute).

  - ML.NET documentation and tutorials for [Model Builder](https://learn.microsoft.com/dotnet/machine-learning/tutorials/predict-prices-with-model-builder), [ML.NET CLI](https://learn.microsoft.com/dotnet/machine-learning/tutorials/sentiment-analysis-cli), and [AutoML API](https://learn.microsoft.com/dotnet/machine-learning/how-to-guides/how-to-use-the-automl-api).



  This project welcomes contributions and suggestions. Most contributions require you to agree to a
  Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us
  the rights to use your contribution. For details, visit <https://cla.opensource.microsoft.com>.

  If you are new to GitHub [here](https://help.github.com/categories/collaborating-with-issues-and-pull-requests/) is a detailed help source on getting involved with development on GitHub.

  When you submit a pull request, a CLA bot will automatically determine whether you need to provide
  a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions
  provided by the bot. You will only need to do this once across all repos using our CLA.

  This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.


pkgId: b683ecf5be5886a7bd46595012cb0f7519cd36f8237c8fbb3010c26a3aa05240
name: python-Fabric3
arch: src
version: 1.14.post1
epoch: 0
release: 1
url: https://github.com/mathiasertl/fabric/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6a8e8e92-e67b-43ce-a8f6-0b8b9c64b805
location_href: 00011144-python-fabric3/python-Fabric3-1.14.post1-1.src.rpm
checksum_type: sha256
summary:
  Fabric is a simple, Pythonic tool for remote execution and deployment (py2.7/py3.4+ compatible fork).

description:
  Fabric3 is a fork of `Fabric <http://fabfile.org>`_ to provide compatability
  with Python 3.4+. The port still works with Python 2.7.

  The goal is to stay 100% compatible with the original Fabric.  Any new releases
  of Fabric will also be released here.  Please file issues for any differences
  you find. Known differences are `documented on github
  <https://github.com/mathiasertl/fabric/>`.

  To find out what's new in this version of Fabric, please see `the changelog
  <http://fabfile.org/changelog.html>`_ of the original Fabric.

  For more information, please see the Fabric website or execute ``fab --help``.


pkgId: 461a5946cafa5d24764e9dc372802cbb0d0cb2b41f128561a6d900c62f3b22d7
name: python-Faker
arch: src
version: 17.6.0
epoch: 0
release: 1
summary: Faker is a Python package that generates fake data for you.
url: https://github.com/joke2k/faker
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-da292c2e-bb61-450c-a5bf-2b959c89be4d
location_href: 00003599-python-faker/python-Faker-17.6.0-1.src.rpm
checksum_type: sha256
description:
      _|_|_|_|          _|
      _|        _|_|_|  _|  _|      _|_|    _|  _|_|
      _|_|_|  _|    _|  _|_|      _|_|_|_|  _|_|
      _|      _|    _|  _|  _|    _|        _|
      _|        _|_|_|  _|    _|    _|_|_|  _|


pkgId: 920dd0fbed093f5ea25e27feeedc13442439044a1376dfb966def722c5553069
name: python-Flask
arch: src
version: 2.2.3
epoch: 0
release: 1
summary: A simple framework for building complex web applications.
url: https://palletsprojects.com/p/flask
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-008ee68e-257f-494d-9c59-1e84f748bffe
location_href: 00008918-python-flask/python-Flask-2.2.3-1.src.rpm
checksum_type: sha256
description:
  Flask is a lightweight `WSGI`_ web application framework. It is designed
  to make getting started quick and easy, with the ability to scale up to
  complex applications. It began as a simple wrapper around `Werkzeug`_
  and `Jinja`_ and has become one of the most popular Python web
  application frameworks.
  Flask offers suggestions, but doesn't enforce any dependencies or
  project layout. It is up to the developer to choose the tools and
  libraries they want to use. There are many extensions provided by the
  community that make adding new functionality easy.


pkgId: 5edbba3c4e3b08eb7b8e4c6a3d9b9f530cc25e30fcee0fa9863c1018e1bc33f4
name: python-Flask-Admin
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Simple and extensible admin interface framework for Flask
url: https://github.com/flask-admin/flask-admin/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-623e4d80-4444-4241-a0c5-b564e7ff1126
location_href: 00003644-python-flask-admin/python-Flask-Admin-1.6.1-1.src.rpm
checksum_type: sha256
description:
  The project was recently moved into its own organization. Please update your
  references to *git@github.com:flask-admin/flask-admin.git*.


pkgId: 37baa864f52775a8e2beb7090731a79dcff3e4f93103b1b95437881643e53242
name: python-Flask-AppBuilder
arch: src
version: 4.3.1
epoch: 0
release: 1
url: https://github.com/dpgaspar/flask-appbuilder/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ba7bd111-b887-4b01-977f-ae9b3124a4aa
location_href: 00009287-python-flask-appbuilder/python-Flask-AppBuilder-4.3.1-1.src.rpm
checksum_type: sha256
summary:
  Simple and rapid application development framework, built on top of Flask. includes detailed security, auto CRUD generation for your models, google charts and much more.

description:
  Simple and rapid application development framework, built on top of `Flask <http://flask.pocoo.org/>`_.
  includes detailed security, auto CRUD generation for your models, google charts and much more.
  Extensive configuration of all functionality, easily integrate with normal Flask/Jinja2 development.
  - Documentation: `Documentation <http://flask-appbuilder.readthedocs.org/en/latest/>`_
  - Mailing list: `Google group <https://groups.google.com/forum/#!forum/flask-appbuilder>`_
  - Chat: `Gitter <https://gitter.im/dpgaspar/Flask-AppBuilder>`_
  - Examples: `examples <https://github.com/dpgaspar/Flask-AppBuilder/tree/master/examples>`_
  Checkout installation video on `YouTube <http://youtu.be/xvum4vfwldg>`_
  Quick how to `Demo from the docs <http://flaskappbuilder.pythonanywhere.com/>`_ (login has guest/welcome).


pkgId: 833baecb3c481c47fc03b8e91fd573b0502624be1168ceb0b84705cb02084680
name: python-Flask-Assets
arch: src
version: 2.0
epoch: 0
release: 1
summary: Asset management for Flask, to compress and merge CSS and Javascript files.
url: http://github.com/miracle2k/flask-assets
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-46088124-cd7c-4a91-ae8d-5928f00a3d96
location_href: 00003645-python-flask-assets/python-Flask-Assets-2.0-1.src.rpm
checksum_type: sha256
description:
  Integrates the ``webassets`` library with Flask, adding support for
  merging, minifying and compiling CSS and Javascript files.


pkgId: d702ebfd80e334a4a26305988ca2ef7933ad88e5806f2df92f687754e6a2be00
name: python-Flask-AutoIndex
arch: src
version: 0.6.6
epoch: 0
release: 1
summary: The mod_autoindex for Flask
url: https://flask-autoindex.readthedocs.io
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0071e460-b273-4fe2-bcfe-a78f0ad9894c
location_href: 00003646-python-flask-autoindex/python-Flask-AutoIndex-0.6.6-1.src.rpm
checksum_type: sha256
description:
  Flask-AutoIndex generates an index page for your `Flask`_ application
  automatically. The result is similar to the one produced by the Apache
  module `mod_autoindex`_, but the look is more awesome!
  Links
  `````
  * `Documentation <https://flask-autoindex.readthedocs.io/>`_
  * `Code repository and issue tracker <https://github.com/general03/flask-autoindex>`_


pkgId: 2c277cecd6a1c3d262de1a01d5bb373c58defd5dcb1b5b990e6e251415919e62
name: python-Flask-BabelEx
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Adds i18n/l10n support to Flask applications
url: http://github.com/mrjoes/flask-babelex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0e48eb08-d1da-4d7f-8e61-c058d48e099a
location_href: 00003648-python-flask-babelex/python-Flask-BabelEx-0.9.4-1.src.rpm
checksum_type: sha256
description:
  Adds i18n/l10n support to Flask applications with the help of the
  `Babel`_ library.
  This is fork of official Flask-Babel extension with following features:
  1. It is possible to use multiple language catalogs in one Flask application;
  2. Localization domains: your extension can package localization file(s) and use them
     if necessary;
  3. Does not reload localizations for each request.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-BabelEx>`_
  * `development version
    <http://github.com/mrjoes/flask-babelex/zipball/master#egg=Flask-BabelEx-dev>`_
  * `original Flask-Babel extension <https://pypi.python.org/pypi/Flask-Babel>`_.


pkgId: 90086936d4a128e3623d8c5d273222bb1d1b23a0f2db73d8cfdf7a5cc37d3405
name: python-Flask-BasicAuth
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: HTTP basic access authentication for Flask.
url: https://github.com/jpvanhal/flask-basicauth
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1cdf1dfe-a544-4ec6-a137-cc4f4ed3626a
location_href: 00010129-python-flask-basicauth/python-Flask-BasicAuth-0.2.0-1.src.rpm
checksum_type: sha256
description:
  |build status|_
  Flask-BasicAuth is a Flask extension that provides an easy way to protect
  certain views or your whole application with HTTP `basic access
  authentication`_.


pkgId: f041e7dc8f28d74937f5f902063a5c2227f1894679e064ffc2aa5f86137d8c62
name: python-Flask-Bcrypt
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Brcrypt hashing for Flask.
url: https://github.com/maxcountryman/flask-bcrypt
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-aaeba7f3-c752-448b-9847-c5fe448bce05
location_href: 00009709-python-flask-bcrypt/python-Flask-Bcrypt-1.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://img.shields.io/github/workflow/status/maxcountryman/flask-bcrypt/Tests/master?label=tests)](https://github.com/maxcountryman/flask-bcrypt/actions)
  [![Version](https://img.shields.io/pypi/v/Flask-Bcrypt.svg)](https://pypi.python.org/pypi/Flask-Bcrypt)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/Flask-Bcrypt.svg)](https://pypi.python.org/pypi/Flask-Bcrypt)



  Flask-Bcrypt is a Flask extension that provides bcrypt hashing utilities for
  your application.

  Due to the recent increased prevalence of powerful hardware, such as modern
  GPUs, hashes have become increasingly easy to crack. A proactive solution to
  this is to use a hash that was designed to be "de-optimized". Bcrypt is such
  a hashing facility; unlike hashing algorithms such as MD5 and SHA1, which are
  optimized for speed, bcrypt is intentionally structured to be slow.

  For sensitive data that must be protected, such as passwords, bcrypt is an
  advisable choice.



  Install the extension with one of the following commands:

      $ easy_install flask-bcrypt

  or alternatively if you have pip installed:

      $ pip install flask-bcrypt



  To use the extension simply import the class wrapper and pass the Flask app
  object back to here. Do so like this:

      from flask import Flask
      from flask_bcrypt import Bcrypt

      app = Flask(__name__)
      bcrypt = Bcrypt(app)

  Two primary hashing methods are now exposed by way of the bcrypt object. Use
  them like so:

      pw_hash = bcrypt.generate_password_hash('hunter2')
      bcrypt.check_password_hash(pw_hash, 'hunter2') # returns True



  The Sphinx-compiled documentation is available here: https://flask-bcrypt.readthedocs.io/


pkgId: e32b616a99c176c039ee6c6f7449dabcce8c582cd25bc5afcc42b60bbfe5b8d6
name: python-Flask-CacheBuster
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/israel-fl/Flask-CacheBuster
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-638dc35b-4e33-409b-8f5b-832e8c9f92f3
location_href: 00013236-python-flask-cachebuster/python-Flask-CacheBuster-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Flask-CacheBuster is a lightweight Flask extension that adds a hash to the URL query parameters of each static file.

description:
  Flask-CacheBuster is a lightweight http://flask.pocoo.org/ extension that adds a hash to the URL query parameters of each static file. This lets you safely declare your static resources as indefinitely cacheable because they automatically get new URLs when their contents change.


pkgId: 0139fbdb3c3d3a43a78b5f20df48c23006a0ba0073062016e1c1a51f5660c06b
name: python-Flask-Cognito
arch: src
version: 1.18
epoch: 0
release: 1
summary: Authenticate users to Cognito user pool via JWT.
url: https://github.com/jetbridge/flask_cognito
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c478fe04-0a38-45c4-a3f7-ba91c7b3e432
location_href: 00011237-python-flask-cognito/python-Flask-Cognito-1.18-1.src.rpm
checksum_type: sha256
description:
  Authenticate users based on AWS Cognito JWT.

  ```python3

  app.config.extend({
      'COGNITO_REGION': 'eu-central-1',
      'COGNITO_USERPOOL_ID': 'eu-central-1c3fea2',
      
      'COGNITO_APP_CLIENT_ID': 'abcdef123456',  # client ID you wish to verify user is authenticated against
      'COGNITO_CHECK_TOKEN_EXPIRATION': False,  # disable token expiration checking for testing purposes
      'COGNITO_JWT_HEADER_NAME': 'X-MyApp-Authorization',
      'COGNITO_JWT_HEADER_PREFIX': 'Bearer',
  })

  from flask_cognito import CognitoAuth
  cogauth = CognitoAuth(app)
  @cogauth.identity_handler
  def lookup_cognito_user(payload):
      """Look up user in our database from Cognito JWT payload."""
      return User.query.filter(User.cognito_username == payload['username']).one_or_none()
  ```

  ```python3
  from flask_cognito import cognito_auth_required, current_user, current_cognito_jwt
  @route('/api/private')
  @cognito_auth_required
  def api_private():
      
      
      return jsonify({
          'cognito_username': current_cognito_jwt['username'],   # from cognito pool
          'user_id': current_user.id,   # from your database
      })
  ```

  ```python3
  from flask_cognito import cognito_auth_required, current_user, current_cognito_jwt
  @route('/api/foo')
  @cognito_auth_required
  @cognito_group_permissions(['admin','developer'])
  def api_private():
      
      return jsonify({
          'foo': "bar"
      })
  ```

  * Uses [cognitojwt](https://github.com/borisrozumnuk/cognitojwt) at its core.
  * Based on [flask-jwt](https://github.com/mattupstate/flask-jwt/).


pkgId: 06aa03525202bcc1a6976a0bd985671998bdc247af86c8b96cdbc318ad9a0998
name: python-Flask-Compress
arch: src
version: 1.13
epoch: 0
release: 1
summary: Compress responses in your Flask app with gzip, deflate or brotli.
url: https://github.com/colour-science/flask-compress
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d680b3e8-150a-4041-8fe0-f69e12260b29
location_href: 00003651-python-flask-compress/python-Flask-Compress-1.13-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/colour-science/flask-compress/actions/workflows/ci.yaml/badge.svg)](https://github.com/colour-science/flask-compress/actions/workflows/ci.yaml)
  [![Version](https://img.shields.io/pypi/v/flask-compress.svg)](https://pypi.python.org/pypi/Flask-Compress)
  [![Downloads](https://static.pepy.tech/badge/flask-compress)](https://pypi.python.org/pypi/Flask-Compress)

  Flask-Compress allows you to easily compress your [Flask](http://flask.pocoo.org/) application's responses with gzip, deflate or brotli. It originally started as a fork of [Flask-gzip](https://github.com/closeio/Flask-gzip).

  The preferred solution is to have a server (like [Nginx](http://wiki.nginx.org/Main)) automatically compress the static files for you. If you don't have that option Flask-Compress will solve the problem for you.




  Flask-Compress both adds the various headers required for a compressed response and compresses the response data.
  This makes serving compressed static files extremely easy.

  Internally, every time a request is made the extension will check if it matches one of the compressible MIME types
  and whether the client and the server use some common compression algorithm, and will automatically attach the
  appropriate headers.

  To determine the compression algorithm, the `Accept-Encoding` request header is inspected, respecting the
  quality factor as described in [MDN docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding).
  If no requested compression algorithm is supported by the server, we don't compress the response. If, on the other
  hand, multiple suitable algorithms are found and are requested with the same quality factor, we choose the first one
  defined in the `COMPRESS_ALGORITHM` option (see below).




  If you use pip then installation is simply:

  ```shell
  $ pip install --user flask-compress
  ```

  or, if you want the latest github version:

  ```shell
  $ pip install --user git+git://github.com/colour-science/flask-compress.git
  ```

  You can also install Flask-Compress via Easy Install:

  ```shell
  $ easy_install flask-compress
  ```






  Flask-Compress is incredibly simple to use. In order to start compressing your Flask application's assets, the first thing to do is let Flask-Compress know about your [`flask.Flask`](http://flask.pocoo.org/docs/latest/api/#flask.Flask) application object.

  ```python
  from flask import Flask
  from flask_compress import Compress

  app = Flask(__name__)
  Compress(app)
  ```

  In many cases, however, one cannot expect a Flask instance to be ready at import time, and a common pattern is to return a Flask instance from within a function only after other configuration details have been taken care of. In these cases, Flask-Compress provides a simple function, `flask_compress.Compress.init_app`, which takes your application as an argument.

  ```python
  from flask import Flask
  from flask_compress import Compress

  compress = Compress()

  def start_app():
      app = Flask(__name__)
      compress.init_app(app)
      return app
  ```

  In terms of automatically compressing your assets, passing your [`flask.Flask`](http://flask.pocoo.org/docs/latest/api/#flask.Flask) object to the `flask_compress.Compress` object is all that needs to be done.



  Compression is possible per view using the `@compress.compressed()` decorator. Make sure to disable global compression first.

  ```python
  from flask import Flask
  from flask_compress import Compress

  app = Flask(__name__)
  app.config["COMPRESS_REGISTER"] = False  # disable default compression of all eligible requests
  compress = Compress()
  compress.init_app(app)


  @app.route("/test")
  @compress.compressed()
  def view():
     pass
  ```



  Within your Flask application's settings you can provide the following settings to control the behavior of Flask-Compress. None of the settings are required.

  | Option | Description | Default |
  | ------ | ----------- | ------- |
  | `COMPRESS_MIMETYPES` | Set the list of mimetypes to compress here. | `[`<br>`'text/html',`<br>`'text/css',`<br>`'text/xml',`<br>`'application/json',`<br>`'application/javascript'`<br>`]` |
  | `COMPRESS_LEVEL` | Specifies the gzip compression level. | `6` |
  | `COMPRESS_BR_LEVEL` | Specifies the Brotli compression level. Ranges from 0 to 11. | `4` |
  | `COMPRESS_BR_MODE` | For Brotli, the compression mode. The options are 0, 1, or 2. These correspond to "generic", "text" (for UTF-8 input), and "font" (for WOFF 2.0). | `0` |
  | `COMPRESS_BR_WINDOW` | For Brotli, this specifies the base-2 logarithm of the sliding window size. Ranges from 10 to 24. | `22` |
  | `COMPRESS_BR_BLOCK` | For Brotli, this provides the base-2 logarithm of the maximum input block size. If zero is provided, value will be determined based on the quality. Ranges from 16 to 24. | `0` |
  | `COMPRESS_DEFLATE_LEVEL` | Specifies the deflate compression level. | `-1` |
  | `COMPRESS_MIN_SIZE` | Specifies the minimum file size threshold for compressing files. | `500` |
  | `COMPRESS_CACHE_KEY` | Specifies the cache key method for lookup/storage of response data. | `None` |
  | `COMPRESS_CACHE_BACKEND` | Specified the backend for storing the cached response data. | `None` |
  | `COMPRESS_REGISTER` | Specifies if compression should be automatically registered. | `True` |
  | `COMPRESS_ALGORITHM` | Supported compression algorithms. | `['br', 'gzip', 'deflate']` |
  | `COMPRESS_STREAMS` | Compress content streams. | `True` |


pkgId: 86d2cbbbce9c7afc6e70582152dbd63c6726dad05e069c4b667fdf7da9ce0eea
name: python-Flask-Cors
arch: src
version: 3.0.10
epoch: 0
release: 1
summary: A Flask extension adding a decorator for CORS support
url: https://github.com/corydolphin/flask-cors
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5672f6c6-e0c8-4e51-925b-0b8ca2c68b75
location_href: 00003652-python-flask-cors/python-Flask-Cors-3.0.10-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Latest Version| |Supported Python versions|
  |License|
  A Flask extension for handling Cross Origin Resource Sharing (CORS), making cross-origin AJAX possible.
  This package has a simple philosophy: when you want to enable CORS, you wish to enable it for all use cases on a domain.
  This means no mucking around with different allowed headers, methods, etc.
  By default, submission of cookies across domains is disabled due to the security implications.
  Please see the documentation for how to enable credential'ed requests, and please make sure you add some sort of `CSRF <http://en.wikipedia.org/wiki/Cross-site_request_forgery>`__ protection before doing so!


pkgId: 11d848e8578cee9366240d01b6468fc9d305fa2c00ba09e8d062962d08057e74
name: python-Flask-DebugToolbar
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: A toolbar overlay for debugging Flask applications.
url: https://github.com/flask-debugtoolbar/flask-debugtoolbar
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-788e75d1-af57-43ff-bac9-60cb7933246b
location_href: 00011694-python-flask-debugtoolbar/python-Flask-DebugToolbar-0.13.1-1.src.rpm
checksum_type: sha256
description:
  This is a port of the excellent `django-debug-toolbar <https://github.com/django-debug-toolbar/django-debug-toolbar>`_
  for Flask applications.


pkgId: 95a7e910024ca075cc0b8aa60f673de845e95a4cd0d72e969f9cd355ef8aee72
name: python-Flask-Executor
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: An easy to use Flask wrapper for concurrent.futures
url: https://github.com/dchevell/flask-executor
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b6bbf7d-e860-4b10-99f6-0b251c8822e0
location_href: 00011814-python-flask-executor/python-Flask-Executor-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/dchevell/flask-executor/actions/workflows/tests.yml/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/dchevell/flask-executor/badge.svg)](https://coveralls.io/github/dchevell/flask-executor)
  [![PyPI Version](https://img.shields.io/pypi/v/Flask-Executor.svg)](https://pypi.python.org/pypi/Flask-Executor)
  [![GitHub license](https://img.shields.io/github/license/dchevell/flask-executor.svg)](https://github.com/dchevell/flask-executor/blob/master/LICENSE)
  Sometimes you need a simple task queue without the overhead of separate worker processes or powerful-but-complex libraries beyond your requirements. Flask-Executor is an easy to use wrapper for the `concurrent.futures` module that lets you initialise and configure executors via common Flask application patterns. It's a great way to get up and running fast with a lightweight in-process task queue.


pkgId: 8aa50ca525da078cc477bd439951002eabf3ca038afaa995e4092c0f76662ff6
name: python-Flask-HTMLmin
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Minify flask text/html mime type responses
url: https://github.com/hamidfzm/Flask-HTMLmin
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1860d4d7-004e-4cda-83ad-69ad9dc6e2d8
location_href: 00003655-python-flask-htmlmin/python-Flask-HTMLmin-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/Flask-HTMLmin.svg)](https://badge.fury.io/py/Flask-HTMLmin)
  ![Supported Python Versions](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9-blue.svg)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](LICENSE)
  ![tests](https://github.com/hamidfzm/Flask-HTMLmin/workflows/tests/badge.svg)
  [![codecov](https://codecov.io/gh/hamidfzm/Flask-HTMLmin/branch/master/graph/badge.svg)](https://codecov.io/gh/hamidfzm/Flask-HTMLmin)
  Minify flask `text/html` mime type responses.
  Just add `MINIFY_HTML = True` to your deployment config to minify HTML and text responses of your flask application.


pkgId: 4b4c8ddfe077a0d943b59a555db0b9a9b39d6e1e3de046c1a797362fb33c47d1
name: python-Flask-HTTPAuth
arch: src
version: 4.7.0
epoch: 0
release: 1
summary: HTTP authentication for Flask routes
url: https://github.com/miguelgrinberg/flask-httpauth
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4cce47a4-c1d9-43dc-8309-a1808fd95d90
location_href: 00003656-python-flask-httpauth/python-Flask-HTTPAuth-4.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/Flask-HTTPAuth/workflows/build/badge.svg)](https://github.com/miguelgrinberg/Flask-HTTPAuth/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/Flask-HTTPAuth/branch/master/graph/badge.svg?token=KeU2002DHo)](https://codecov.io/gh/miguelgrinberg/Flask-HTTPAuth)
  Simple extension that provides Basic and Digest HTTP authentication for Flask routes.


pkgId: 083dfc56d687ad6d089b005c0c58c1f943090b6e1c7023a0863feb706f62fdd0
name: python-Flask-Injector
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Adds Injector, a Dependency Injection framework, support to Flask.
url: https://github.com/alecthomas/flask_injector
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4364aeaa-dee8-4f3c-8ca5-7b3ef871474d
location_href: 00013890-python-flask-injector/python-Flask-Injector-0.14.0-1.src.rpm
checksum_type: sha256
description:
  Adds `Injector <https://github.com/alecthomas/injector>`_ support to Flask,
  this way there's no need to use global Flask objects, which makes testing simpler.
  Injector is a dependency-injection framework for Python, inspired by Guice. You
  can `find Injector on PyPI <https://pypi.org/project/injector/>`_ and `Injector
  documentation on Read the Docs <https://injector.readthedocs.io/en/latest/>`_.
  `Flask-Injector` is compatible with CPython 3.7+.
  As of version 0.14.0 it requires Injector version 0.20.0 or greater and Flask
  2.1.2 or greater.
  GitHub project page: https://github.com/alecthomas/flask_injector
  PyPI package page: https://pypi.org/project/Flask-Injector/
  Changelog: https://github.com/alecthomas/flask_injector/blob/master/CHANGELOG.rst


pkgId: 2a58d6a526cce6921c7295ca861208e66ad0b2eaa303d41c243fca5bca5738f5
name: python-Flask-JSON
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: Better JSON support for Flask
url: https://github.com/skozlovf/flask-json
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45dbbbe1-e4d8-4480-b27c-ec45033cbbbf
location_href: 00011340-python-flask-json/python-Flask-JSON-0.3.5-1.src.rpm
checksum_type: sha256
description:
  Flask-JSON is a simple extension that adds better JSON support to Flask
  application.
  Features:
  * Works on python 2.6, 2.7, 3.3+ and Flask 0.10+.
  * More ways to generate JSON responses (comparing to plain Flask).
  * Extended JSON encoding support.


pkgId: 6c8151c565cb56e12f691537fcf8d42496f2d8f6c4bb0446c5157450b1983793
name: python-Flask-JWT-Extended
arch: src
version: 4.4.4
epoch: 0
release: 1
summary: Extended JWT integration with Flask
url: https://github.com/vimalloc/flask-jwt-extended
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1bbdb878-5fee-4b83-a119-e98a4a50931f
location_href: 00009286-python-flask-jwt-extended/python-Flask-JWT-Extended-4.4.4-1.src.rpm
checksum_type: sha256
description:
  Flask-JWT-Extended not only adds support for using JSON Web Tokens (JWT) to Flask for protecting routes,
  but also many helpful (and **optional**) features built in to make working with JSON Web Tokens
  easier. These include:

  -   Adding custom claims to JSON Web Tokens
  -   Automatic user loading (`current_user`).
  -   Custom claims validation on received tokens
  -   [Refresh tokens](https://auth0.com/blog/refresh-tokens-what-are-they-and-when-to-use-them/)
  -   First class support for fresh tokens for making sensitive changes.
  -   Token revoking/blocklisting
  -   Storing tokens in cookies and CSRF protection



  [View the documentation online](https://flask-jwt-extended.readthedocs.io/en/stable/)



  [View the changes](https://flask-jwt-extended.readthedocs.io/en/stable/v4_upgrade_guide/)



  You can view the changelog [here](https://github.com/vimalloc/flask-jwt-extended/releases).
  This project follows [semantic versioning](https://semver.org/).



  Come chat with the community or ask questions at https://discord.gg/EJBsbFd



  Before making any changes, make sure to install the development requirements
  and setup the git hooks which will automatically lint and format your changes.

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

  We require 100% code coverage in our unit tests. You can run the tests locally
  with `tox` which ensures that all tests pass, tests provide complete code coverage,
  documentation builds, and style guide are adhered to

  ```bash
  tox
  ```

  A subset of checks can also be ran by adding an argument to tox. The available
  arguments are:

  -   py37, py38, py39, py310, pypy3
      -   Run unit tests on the given python version
  -   mypy
      -   Run mypy type checking
  -   coverage
      -   Run a code coverage check
  -   docs
      -   Ensure documentation builds and there are no broken links
  -   style
      -   Ensure style guide is adhered to

  ```bash
  tox -e py38
  ```

  We also require features to be well documented. You can generate a local copy
  of the documentation by going to the `docs` directory and running:

  ```bash
  make clean && make html && open _build/html/index.html
  ```


pkgId: 434fbeebae88e3001e164952a2af34c10576c7792df4ec4e2cea7ce115971a43
name: python-Flask-Limiter
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Rate limiting for flask applications
url: https://flask-limiter.readthedocs.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e76cde0-6447-4ece-a10f-98079395aea7
location_href: 00010869-python-flask-limiter/python-Flask-Limiter-3.3.0-1.src.rpm
checksum_type: sha256
description:
  Sponsored by `Zuplo <https://zuplo.link/3NuX0co>`_ a fully-managed API Gateway for developers.
  Add `dynamic rate-limiting <https://zuplo.link/flask-dynamic-rate-limit>`_ authentication and more to any API in minutes.


pkgId: c64016239df5728690bec64a774e6151787a98e3ed1a1ba70ea3a4ec3696e6dd
name: python-Flask-Log-Request-ID
arch: src
version: 0.10.1
epoch: 0
release: 1
url: http://github.com/Workable/flask-log-request-id
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1b01379-1069-4b07-9a91-f4fc1b7f6129
location_href: 00012345-python-flask-log-request-id/python-Flask-Log-Request-ID-0.10.1-1.src.rpm
checksum_type: sha256
summary:
  Flask extension that can parse and handle multiple types of request-id sent by request processors like Amazon ELB, Heroku or any multi-tier infrastructure as the one used for microservices.

description:
  |CircleCI|
  **Flask-Log-Request-Id** is an extension for `Flask`_ that can parse and handle
  the request-id sent by request processors like `Amazon ELB`_, `Heroku Request-ID`_
  or any multi-tier infrastructure as the one used at microservices. A common
  usage scenario is to inject the request\_id in the logging system so that all
  log records, even those emitted by third party libraries, have attached the
  request\_id that initiated their call. This can greatly improve tracing and debugging of problems.


pkgId: 4ab378b516b370d36a537c6ec326948096b0c0a864c87f42333bf81545b5555a
name: python-Flask-Login
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: User authentication and session management for Flask.
url: https://github.com/maxcountryman/flask-login
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6f9cf08-c3e3-4b2a-9483-24f8b65a8074
location_href: 00003657-python-flask-login/python-Flask-Login-0.6.2-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/maxcountryman/flask-login/workflows/Tests/badge.svg)
  [![coverage](https://coveralls.io/repos/maxcountryman/flask-login/badge.svg?branch=main&service=github)](https://coveralls.io/github/maxcountryman/flask-login?branch=main)
  [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)

  Flask-Login provides user session management for Flask. It handles the common
  tasks of logging in, logging out, and remembering your users' sessions over
  extended periods of time.

  Flask-Login is not bound to any particular database system or permissions
  model. The only requirement is that your user objects implement a few methods,
  and that you provide a callback to the extension capable of loading users from
  their ID.



  Install the extension with pip:

  ```sh
  $ pip install flask-login
  ```



  Once installed, the Flask-Login is easy to use. Let's walk through setting up
  a basic application. Also please note that this is a very basic guide: we will
  be taking shortcuts here that you should never take in a real application.

  To begin we'll set up a Flask app:

  ```python
  import flask

  app = flask.Flask(__name__)
  app.secret_key = 'super secret string'  # Change this!
  ```

  Flask-Login works via a login manager. To kick things off, we'll set up the
  login manager by instantiating it and telling it about our Flask app:

  ```python
  import flask_login

  login_manager = flask_login.LoginManager()

  login_manager.init_app(app)
  ```

  To keep things simple we're going to use a dictionary to represent a database
  of users. In a real application, this would be an actual persistence layer.
  However it's important to point out this is a feature of Flask-Login: it
  doesn't care how your data is stored so long as you tell it how to retrieve it!

  ```python

  users = {'foo@bar.tld': {'password': 'secret'}}
  ```

  We also need to tell Flask-Login how to load a user from a Flask request and
  from its session. To do this we need to define our user object, a
  `user_loader` callback, and a `request_loader` callback.

  ```python
  class User(flask_login.UserMixin):
      pass


  @login_manager.user_loader
  def user_loader(email):
      if email not in users:
          return

      user = User()
      user.id = email
      return user


  @login_manager.request_loader
  def request_loader(request):
      email = request.form.get('email')
      if email not in users:
          return

      user = User()
      user.id = email
      return user
  ```

  Now we're ready to define our views. We can start with a login view, which will
  populate the session with authentication bits. After that we can define a view
  that requires authentication.

  ```python
  @app.route('/login', methods=['GET', 'POST'])
  def login():
      if flask.request.method == 'GET':
          return '''
                 <form action='login' method='POST'>
                  <input type='text' name='email' id='email' placeholder='email'/>
                  <input type='password' name='password' id='password' placeholder='password'/>
                  <input type='submit' name='submit'/>
                 </form>
                 '''

      email = flask.request.form['email']
      if email in users and flask.request.form['password'] == users[email]['password']:
          user = User()
          user.id = email
          flask_login.login_user(user)
          return flask.redirect(flask.url_for('protected'))

      return 'Bad login'


  @app.route('/protected')
  @flask_login.login_required
  def protected():
      return 'Logged in as: ' + flask_login.current_user.id
  ```

  Finally we can define a view to clear the session and log users out:

  ```python
  @app.route('/logout')
  def logout():
      flask_login.logout_user()
      return 'Logged out'
  ```

  We now have a basic working application that makes use of session-based
  authentication. To round things off, we should provide a callback for login
  failures:

  ```python
  @login_manager.unauthorized_handler
  def unauthorized_handler():
      return 'Unauthorized', 401
  ```

  Documentation for Flask-Login is available on [ReadTheDocs](https://flask-login.readthedocs.io/en/latest/).
  For complete understanding of available configuration, please refer to the [source code](https://github.com/maxcountryman/flask-login).




  We welcome contributions! If you would like to hack on Flask-Login, please
  follow these steps:

  1. Fork this repository
  2. Make your changes
  3. Install the dev requirements with `pip install -r requirements/dev.txt`
  4. Submit a pull request after running `tox` (ensure it does not error!)

  Please give us adequate time to review your submission. Thanks!


pkgId: e3170e19d2f6af86d334af82883e89fbb543184f6cd871c6dfd2399b2294433d
name: python-Flask-Mail
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Flask extension for sending email
url: https://github.com/rduplain/flask-mail
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e86f21b5-9939-4d18-a90c-9c6aa4000298
location_href: 00003658-python-flask-mail/python-Flask-Mail-0.9.1-1.src.rpm
checksum_type: sha256
description:
  A Flask extension for sending email messages.
  Please refer to the online documentation for details.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Mail>`_


pkgId: ff6af862ad8dd022bc2b3271b58ac985a5cdf236365061908d81a3437ab17cf6
name: python-Flask-Mako
arch: src
version: 0.4
epoch: 0
release: 1
summary: Mako templating support for Flask applications.
url: https://github.com/benselme/flask-mako
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d77a1ffd-8f64-4e7f-b63d-dafd650b33fb
location_href: 00003659-python-flask-mako/python-Flask-Mako-0.4-1.src.rpm
checksum_type: sha256
description:
  This extension for the `Flask <http://flask.pocoo.org/>`_ micro web framework
  allows developers to use  `Mako Templates
  <http://http://www.makotemplates.org/>`_ instead of the default Jinja2
  templating engine.


pkgId: 3733f2b54e918b469a0e27af26325faa2a64dfe5c39712de443e24b5c0f56a75
name: python-Flask-Migrate
arch: src
version: 4.0.4
epoch: 0
release: 1
summary: SQLAlchemy database migrations for Flask applications using Alembic.
url: https://github.com/miguelgrinberg/flask-migrate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c03207e-684f-46f8-9328-56a6cb6052bf
location_href: 00003660-python-flask-migrate/python-Flask-Migrate-4.0.4-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-migrate/workflows/build/badge.svg)](https://github.com/miguelgrinberg/flask-migrate/actions)
  Flask-Migrate is an extension that handles SQLAlchemy database migrations for Flask applications using Alembic. The database operations are provided as command-line arguments under the `flask db` command.


pkgId: 93883da103fa2d3dcc8add399c061b8a4b1675233ed3f5720c0741bd7de66de9
name: python-Flask-Moment
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Formatting of dates and times in Flask templates using moment.js.
url: https://github.com/miguelgrinberg/flask-moment
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47ed1d01-bf94-440f-acd8-a56514efacfc
location_href: 00014194-python-flask-moment/python-Flask-Moment-1.0.5-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-moment/workflows/build/badge.svg)](https://github.com/miguelgrinberg/flask-moment/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-moment/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-moment)
  This extension enhances Jinja2 templates with formatting of dates and times
  using [moment.js](https://momentjs.com/).


pkgId: f6108ad12ad4f009c0cbf55e912a48ea1d76c37eccfb02b25d4ad5c9fec51be6
name: python-Flask-OAuth
arch: src
version: 0.12
epoch: 0
release: 1
summary: Adds OAuth support to Flask
url: http://github.com/mitsuhiko/flask-oauth
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-00b71e6a-c3e7-430e-a34c-a3094c2a3c78
location_href: 00003662-python-flask-oauth/python-Flask-OAuth-0.12-1.src.rpm
checksum_type: sha256
description:
  Adds OAuth support to Flask.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-OAuth>`_
  * `development version
    <http://github.com/mitsuhiko/flask-oauth/zipball/master#egg=Flask-OAuth-dev>`_


pkgId: f3cc1bbcdedccdad2c2a886d60edec19697ae145d9e7caa059530776628e5b42
name: python-Flask-OpenID
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: OpenID support for Flask
url: http://github.com/mitsuhiko/flask-openid/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f309faf-e135-49d5-8fd3-1148db00b892
location_href: 00003664-python-flask-openid/python-Flask-OpenID-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Adds support for OpenID to flask applications.  Check out the
  example for more information.
  Documentation: http://packages.python.org/Flask-OpenID/


pkgId: a434de3af946a77756c4ef5dcbc8de54e3aecba83fbc4af92defa2c41210fc36
name: python-Flask-Paranoid
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Simple user session protection
url: https://github.com/miguelgrinberg/flask-paranoid
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9cdd0235-c27a-44b7-880b-e829c6021799
location_href: 00003665-python-flask-paranoid/python-Flask-Paranoid-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-paranoid/workflows/build/badge.svg)](https://github.com/miguelgrinberg/flask-paranoid/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-paranoid/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-paranoid)
  Simple user session protection.


pkgId: 3d3616396939b89b0078cc0606579dbdd71840c602182c1b1f0307d91ff51047
name: python-Flask-Plugins
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Create plugins for your Flask application
url: https://github.com/sh4nks/flask-plugins
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd06419a-a2e1-4275-8013-ae69630dd9b2
location_href: 00009548-python-flask-plugins/python-Flask-Plugins-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Flask-Plugins makes it possible, to create plugins for your
  application. In addition to the plugin system, it also provides a simple
  event system which can be used by plugins to extend your application without
  the need to modify your core code.
  And Easy to Setup
  `````````````````
  First of all, you have to install it:
      $ pip install flask-plugins
  and then you need to initialize it somewhere in your code.
      from flask_plugins import PluginManager
      plugin_manager = PluginManager(app)
  Want to use the factory pattern? No problem!
      from flask_plugins import PluginManager
      plugin_manager = PluginManager()
      plugin_manager.init_app(app)
  Resources
  `````````
  * `source <https://github.com/sh4nks/flask-plugins>`_
  * `docs <https://flask-plugins.readthedocs.org/en/latest>`_
  * `issues <https://github.com/sh4nks/flask-plugins/issues>`_


pkgId: 7d5b56e4bf8a84115d44b9da0843f25b8ab9c672e0a9265d0509f7e62765a513
name: python-Flask-Principal
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Identity management for flask
url: http://packages.python.org/Flask-Principal/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-09aca0b4-2465-4534-85ec-8a3a4d3dc71a
location_href: 00003666-python-flask-principal/python-Flask-Principal-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Identity management for Flask.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Principal/>`_
  * `source <https://github.com/mattupstate/flask-principal>`_
  * `development version
    <https://github.com/mattupstate/flask-principal/raw/master#egg=Flask-Principal-dev>`_


pkgId: 88ccb8ed8348027fc0ef157553887271c24ba086ed9c93cae32cdf2a1a08c068
name: python-Flask-PyMongo
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: PyMongo support for Flask applications
url: http://flask-pymongo.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d43ff62c-8330-4d12-b675-01ae2f8f99c6
location_href: 00003667-python-flask-pymongo/python-Flask-PyMongo-2.3.0-1.src.rpm
checksum_type: sha256
description:
  MongoDB support for Flask applications.
  Flask-PyMongo is pip-installable:
      $ pip install Flask-PyMongo
  Documentation for Flask-PyMongo is available on `ReadTheDocs
  <http://flask-pymongo.readthedocs.io/en/latest/>`_.
  Source code is hosted on `GitHub <https://github.com/dcrosta/flask-pymongo>`_.
  Contributions are welcome!


pkgId: 6f838887b3abd66437e3829b71555f18194eee88c4a5c14f28aaa81deca1589d
name: python-Flask-RSTPages
arch: src
version: 0.3
epoch: 0
release: 1
summary: Adds support for reStructuredText to a Flask application
url: http://flask-rstpages.readthedocs.org/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07e7a40f-8cd1-4033-8f46-7e3ee12e6b73
location_href: 00003669-python-flask-rstpages/python-Flask-RSTPages-0.3-1.src.rpm
checksum_type: sha256
description:
  Flask-RSTPages
  ~~~~~~~~~~~~~~

  Flask-RSTPages adds support for reStructuredText to your Flask application.
  See the docs for details: http://flask-rstpages.readthedocs.org/


pkgId: d711f22206f9ec59c481399e9190795b36d366d9f49b649a750fc306c74657c1
name: python-Flask-Script
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Scripting support for Flask
url: http://github.com/smurfix/flask-script
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5970f3bd-0f9b-4def-99e2-a7190ea09ec2
location_href: 00003670-python-flask-script/python-Flask-Script-2.0.6-1.src.rpm
checksum_type: sha256
description:
  Flask support for writing external scripts.
  Links
  `````
  * `documentation <http://flask-script.readthedocs.org>`_


pkgId: bf5e975c079e18b0003219e366eae1a970dd5394607a16c68d72cc37de3da10f
name: python-Flask-SeaSurf
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: An updated CSRF extension for Flask.
url: https://github.com/maxcountryman/flask-seasurf/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-51ef0851-5b45-44c4-bcf2-eccd932b8b50
location_href: 00013274-python-flask-seasurf/python-Flask-SeaSurf-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://img.shields.io/github/workflow/status/maxcountryman/flask-seasurf/Tests/main?label=tests)](https://github.com/maxcountryman/flask-seasurf/actions)
  [![Version](https://img.shields.io/pypi/v/Flask-SeaSurf.svg)](https://pypi.python.org/pypi/Flask-SeaSurf)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/Flask-SeaSurf.svg)](https://pypi.python.org/pypi/Flask-SeaSurf)



  SeaSurf is a Flask extension for preventing cross-site request forgery (CSRF).

  CSRF vulnerabilities have been found in large and popular sites such as
  YouTube. These attacks are problematic because the mechanism they use is
  relatively easy to exploit. This extension attempts to aid you in securing
  your application from such attacks.

  This extension is based on the excellent Django middleware.




  Install the extension with one of the following commands:

      $ easy_install flask-seasurf

  or alternatively if you have pip installed:

      $ pip install flask-seasurf




  Using SeaSurf is fairly straightforward. Begin by importing the extension and
  then passing your application object back to the extension, like this:

      from flask_seasurf import SeaSurf
      csrf = SeaSurf(app)




  The Sphinx-compiled documentation is available here: https://flask-seasurf.readthedocs.io/


pkgId: c47a29fb316cf3520868c6f609422336bd830e87a3027e7014d7b46a58e03124
name: python-Flask-Session
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Adds server-side session support to your Flask application
url: https://github.com/fengsp/flask-session
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b927eccd-e350-4bb2-9204-6b708f6f9627
location_href: 00010693-python-flask-session/python-Flask-Session-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Flask-Session is an extension for Flask that adds support for
  Server-side Session to your application.
  Links
  `````
  * `development version
    <https://github.com/fengsp/flask-session/zipball/master#egg=Flask-dev>`_


pkgId: 5244dd5fc4948c1f8a075a49bc615c7830035699bbef73f473aa6539100084ba
name: python-Flask-Silk
arch: src
version: 0.2
epoch: 0
release: 1
summary: Adds silk icons to your Flask application or blueprint, or extension.
url: http://github.com/sublee/flask-silk
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-40e79081-7300-4599-86a1-f714970b7ca0
location_href: 00003672-python-flask-silk/python-Flask-Silk-0.2-1.src.rpm
checksum_type: sha256
description:
  Adds `silk`_ icons to your Flask application or blueprint, or extension.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Silk>`_
  * `development version
    <http://github.com/sublee/flask-silk/zipball/master#egg=flask-silk-dev>`_


pkgId: d1114d232b832180aa4072399de0fb9c5f1b12ace47f20a98caceeb1401feaeb
name: python-Flask-SocketIO
arch: src
version: 5.3.2
epoch: 0
release: 1
summary: Socket.IO integration for Flask applications
url: https://github.com/miguelgrinberg/flask-socketio
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c5742c20-fb1d-466c-bc7b-4ea8e2516a89
location_href: 00003673-python-flask-socketio/python-Flask-SocketIO-5.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-socketio/workflows/build/badge.svg)](https://github.com/miguelgrinberg/Flask-SocketIO/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-socketio/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-socketio)
  Socket.IO integration for Flask applications.


pkgId: 888fe5357e6b30fa78f464faf72eea45066b86c0dc826be8136d034dda900f65
name: python-Flask-Sphinx-Themes
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Sphinx themes for Flask and related projects.
url: https://github.com/pallets/flask-sphinx-themes
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ad97fe8-e6a2-4ec1-b16c-d3bfa201a25d
location_href: 00003674-python-flask-sphinx-themes/python-Flask-Sphinx-Themes-1.0.2-1.src.rpm
checksum_type: sha256
description:
  This repository contains Sphinx themes for Flask and Flask related
  projects. To use this theme in your Sphinx documentation:
  1. Install the package using pip: ``pip install Flask-Sphinx-Themes``
  2. Add this to ``conf.py``:
         html_theme = 'flask'


pkgId: b9a903b8538937bbdbf50f48723215b1292fea76167134ab7d675378c330d2f5
name: python-Flask-Testing
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Unit testing for Flask
url: https://github.com/jarus/flask-testing
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d44d7a0e-19a9-41fc-8ab8-bebf8be4ec57
location_href: 00010420-python-flask-testing/python-Flask-Testing-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Flask unittest integration.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-Testing>`
  * `development version <http://github.com/jarus/flask-testing/zipball/master#egg=Flask-Testing-dev>`


pkgId: 912fe0c98375ea1c55db077d6852066e5dc7662e16a9e8a688dbf9d9f890f191
name: python-Flask-XML-RPC
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Adds support for creating XML-RPC APIs to Flask
url: http://bitbucket.org/leafstorm/flask-xml-rpc/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c4fcbe5c-69fd-47c3-b4e9-f3eca08710e8
location_href: 00003679-python-flask-xml-rpc/python-Flask-XML-RPC-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Flask-XML-RPC adds XML-RPC support to Flask. This way, you can provide simple
  APIs easily accessible from almost any programming language.
  Links
  `````
  * `documentation <http://packages.python.org/Flask-XML-RPC>`_
  * `development version
    <http://bitbucket.org/leafstorm/flask-xml-rpc/get/tip.gz#egg=Flask-XML-RPC-dev>`_


pkgId: 215cb40c7f229ea399682b2c1d9157871f7ef9682baee8c1b2155d78f12fefdb
name: python-Flask-pyoidc
arch: src
version: 3.13.0
epoch: 0
release: 1
summary: Flask extension for OpenID Connect authentication.
url: https://github.com/zamzterz/flask-pyoidc
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6c6ce444-a3fd-4128-91e2-9b106640c8f5
location_href: 00006212-python-Flask-pyoidc/python-Flask-pyoidc-3.13.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/flask-pyoidc.svg)](https://pypi.python.org/pypi/Flask-pyoidc)
  [![codecov.io](https://codecov.io/github/zamzterz/Flask-pyoidc/coverage.svg?branch=master)](https://codecov.io/github/its-dirg/Flask-pyoidc?branch=master)
  [![Build Status](https://travis-ci.org/zamzterz/Flask-pyoidc.svg?branch=master)](https://travis-ci.org/zamzterz/Flask-pyoidc)

  This Flask extension provides simple OpenID Connect authentication, backed by [pyoidc](https://github.com/rohe/pyoidc).

  ["Authorization Code Flow"](http://openid.net/specs/openid-connect-core-1_0.html#CodeFlowAuth),
  ["Implicit Flow"](https://openid.net/specs/openid-connect-core-1_0.html#ImplicitFlowAuth),
  ["Hybrid Flow"](https://openid.net/specs/openid-connect-core-1_0.html#HybridFlowAuth),
  ["Client Credentials Flow"](https://oauth.net/2/grant-types/client-credentials/) are supported.


  Read [the documentation](https://flask-pyoidc.readthedocs.io/) or have a look at the
  [example Flask app](example/app.py) for a full example of how to use this extension.

  Below is a basic example of how to get started:
  ```python
  app = Flask(__name__)
  app.config.update(
      OIDC_REDIRECT_URI = 'https://example.com/redirect_uri',
      SECRET_KEY = ...
  )


  client_metadata = ClientMetadata(
      client_id='client1',
      client_secret='secret1',
      post_logout_redirect_uris=['https://example.com/logout'])


  provider_config = ProviderConfiguration(issuer='<issuer URL of provider>',
                                          client_metadata=client_metadata)

  auth = OIDCAuthentication({'default': provider_config}, app)

  @app.route('/')
  @auth.oidc_auth('default') # endpoint will require login
  def index():
      user_session = UserSession(flask.session)
      return jsonify(access_token=user_session.access_token,
                     id_token=user_session.id_token,
                     userinfo=user_session.userinfo)
  ```


pkgId: df441fe031e04b143deeb6c82fc52714be25eb7cb63bea28f89bb79920a285c8
name: python-Flask-uWSGI-WebSocket
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: High-performance WebSockets for your Flask apps powered by uWSGI.
url: https://github.com/zeekay/flask_uwsgi_websocket
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c835e06a-347b-48cf-bb70-f60ba0971339
location_href: 00013906-python-flask-uwsgi-websocket/python-Flask-uWSGI-WebSocket-0.6.1-1.src.rpm
checksum_type: sha256
description:
  High-performance WebSockets for your Flask apps powered by `uWSGI
  <http://uwsgi-docs.readthedocs.org/en/latest/>`_. Low-level uWSGI WebSocket API
  access and flexible high-level abstractions for building complex WebSocket
  applications with Flask. Supports several different concurrency models
  including Gevent. Inspired by `Flask-Sockets
  <https://github.com/kennethreitz/flask-sockets>`_.
      from flask import Flask
      from flask_uwsgi_websocket import GeventWebSocket
      app = Flask(__name__)
      websocket = GeventWebSocket(app)
      @websocket.route('/echo')
      def echo(ws):
          while True:
              msg = ws.receive()
              ws.send(msg)
      if __name__ == '__main__':
          app.run(gevent=100)


pkgId: cffdff7f1c5f5a06a1179f3e8221055ee68d0b03d7c136fee69365955f073c09
name: python-FormEncode
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: HTML form validation, generation, and conversion package
url: http://formencode.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d3c6bf0-1c1b-4bad-bc45-82ce1773aeea
location_href: 00003702-python-formencode/python-FormEncode-2.0.1-1.src.rpm
checksum_type: sha256
description:
  FormEncode validates and converts nested structures.

  It allows for a declarative form of defining the validation,
  and decoupled processes for filling and generating forms.

  The official repo is at GitHub: https://github.com/formencode/formencode


pkgId: 85f88de9dbc36dcfde7fe6d5c238cda7a69844fbb3148456b8b6328b211f5b08
name: python-Frozen-Flask
arch: src
version: 0.18
epoch: 0
release: 1
summary: Freezes a Flask application into a set of static files.
url: https://github.com/Frozen-Flask/Frozen-Flask
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cea7eb43-59b4-411a-b975-000919fa1ce8
location_href: 00003708-python-frozen-flask/python-Frozen-Flask-0.18-1.src.rpm
checksum_type: sha256
description:
  Freezes a Flask application into a set of static files. The result can be hosted
  without any server-side software other than a traditional web server.
  Links
  `````
  * `documentation <https://pythonhosted.org/Frozen-Flask/>`_
  * `development version
    <https://github.com/Frozen-Flask/Frozen-Flask/zipball/master#egg=Frozen-Flask-dev>`_


pkgId: 31e82218bee5681c31227b6965b66934d4ad818d3f3d66b46b546398ca1fb8d6
name: python-GDAL
arch: src
version: 3.6.2
epoch: 0
release: 1
summary: GDAL: Geospatial Data Abstraction Library
url: http://www.gdal.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc71e21a-2f27-4f4c-b6c8-a0c15d1964f1
location_href: 00003732-python-gdal/python-GDAL-3.6.2-1.src.rpm
checksum_type: sha256
description:
  This Python package and extensions are a number of tools for programming and
  manipulating the GDAL_ Geospatial Data Abstraction Library.  Actually, it is
  two libraries -- GDAL for manipulating geospatial raster data and OGR for
  manipulating geospatial vector data -- but we'll refer to the entire package
  as the GDAL library for the purposes of this document.
  The GDAL project (primarily Even Rouault) maintains SWIG generated Python
  bindings for GDAL and OGR. Generally speaking the classes and methods mostly
  match those of the GDAL and OGR C++ classes. There is no Python specific
  reference documentation, but the `GDAL API Tutorial`_ includes Python examples.


pkgId: 11e5d369aa1550459e186d4f6594c0113da7ead824f5f7f13578abe2717f1edc
name: python-HeapDict
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: a heap with decrease-key and increase-key operations
url: http://stutzbachenterprises.com/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2470c896-a779-40fd-9ce8-55f16db2bcd4
location_href: 00003845-python-heapdict/python-HeapDict-1.0.1-1.src.rpm
checksum_type: sha256
description:
  heapdict implements the MutableMapping ABC, meaning it works pretty
  much like a regular Python dict.  It's designed to be used as a
  priority queue, where items are added and consumed as follows:
      hd = heapdict()
      hd[obj1] = priority1
      hd[obj2] = priority2
      
      (obj, priority) = hd.popitem()
  Compared to an ordinary dict, a heapdict has the following differences:
  popitem():
      Remove and return the (key, priority) pair with the lowest
      priority, instead of a random object.
  peekitem():
      Return the (key, priority) pair with the lowest priority, without
      removing it.
  Unlike the Python standard library's heapq module, the heapdict
  supports efficiently changing the priority of an existing object
  (often called "decrease-key" in textbooks).  Altering the priority is
  important for many algorithms such as Dijkstra's Algorithm and A*.


pkgId: 4a3763a6bde576ae0f3f1aaaa1e99c2e96550ce154d7899a7bdf181247c0f408
name: python-HepMC3
arch: src
version: 3.2.5
epoch: 0
release: 1
summary: HepMC3 library and Python bindings for HepMC3
url: https://gitlab.cern.ch/hepmc/HepMC3
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1721140d-81e6-476a-96f2-cfc02363a21d
location_href: 00002852-python-HepMC3/python-HepMC3-3.2.5-1.src.rpm
checksum_type: sha256
description:
  Official python bindings for the HepMC3 library. Please visit https://hepmc.web.cern.ch/hepmc/ and  https://gitlab.cern.ch/hepmc/HepMC3 for more documentation


pkgId: ca23234e52d8d24a6997fdc7cb14b1c8d7bc2c763fc288d8e51ca129a9abcaeb
name: python-IMAPClient
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Easy-to-use, Pythonic and complete IMAP client library
url: https://github.com/mjs/imapclient/
rpm_license: http://en.wikipedia.org/wiki/BSD_licenses
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0d80d5c9-4ff9-4ff8-8e4d-e9f0bf4c9ac2
location_href: 00010647-python-imapclient/python-IMAPClient-2.3.1-1.src.rpm
checksum_type: sha256
description:
  IMAPClient is an easy-to-use, Pythonic and complete IMAP client library.

  Features:
      * Arguments and return values are natural Python types.
      * IMAP server responses are fully parsed and readily usable.
      * IMAP unique message IDs (UIDs) are handled transparently.
      * Internationalised mailbox names are transparently handled.
      * Time zones are correctly handled.
      * Convenience methods are provided for commonly used functionality.
      * Exceptions are raised when errors occur.

  Python versions 2.7 and 3.4 through 3.9 are officially supported.

  IMAPClient includes comprehensive units tests and automated
  functional tests that can be run against a live IMAP server.


pkgId: 66eaade930c69cf4e4499f87e5f4773c98d5206b8339c004665f4e01bede900b
name: python-IP2Location
arch: src
version: 8.9.0
epoch: 0
release: 1
url: https://github.com/chrislim2888/ip2location-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-16e890d6-5d87-4a6b-b3f3-85cbae55d527
location_href: 00013144-python-ip2location/python-IP2Location-8.9.0-1.src.rpm
checksum_type: sha256
summary:
  This is an IP geolocation library that enables the user to find the country, region, city, latitude and longitude, ZIP code, time zone, ISP, domain name, area code, weather info, mobile info, elevation, usage type, address type and IAB category from an IP address. It supports both IPv4 and IPv6 lookup.

description:
  This is a IP2Location Python library that enables the user to find the country, region or state, city, latitude and longitude, ZIP code, time zone, Internet Service Provider (ISP) or company name, domain name, net speed, area code, weather station code, weather station name, mobile country code (MCC), mobile network code (MNC) and carrier brand, elevation, usage type, address type and IAB category by IP address or hostname originates from. The library reads the geo location information from **IP2Location BIN data** file.

  Supported IPv4 and IPv6 address.

  For more details, please visit:
  [https://www.ip2location.com/developers/python](https://www.ip2location.com/developers/python)



  1. Python 3.5 and above.



  1. Unzip the package.
  2. Execute python setup.py build
  3. Execute python setup.py install

  or

  To install this module type the following (for PyPI):

  ```bash
  pip install IP2Location
  ```



  You can check the **sample.py** file to learn more about usage.



  Below is the description of the functions available in the **BIN Database** lookup.

  | Method Name       | Description                                                  |
  | ----------------- | ------------------------------------------------------------ |
  | open              | Open the IP2Location BIN data for lookup. Default mode: File I/O. |
  | close             | Close and clean up the file pointer.                         |
  | get_all           | Return the geolocation information in array.                 |
  | get_country_short | Return the ISO3166-1 country code (2-digits) of the IP address. |
  | get_country_long  | Return the ISO3166-1 country name of the IP address.         |
  | get_region        | Return the ISO3166-2 region name of the IP address. Please visit [ISO3166-2 Subdivision Code](https://www.ip2location.com/free/iso3166-2) for the information of ISO3166-2 supported |
  | get_city          | Return the city name of the IP address.                      |
  | get_latitude      | Return the city latitude of the IP address.                  |
  | get_longitude     | Return the city longtitude of the IP address.                |
  | get_isp           | Return the ISP name of the IP address.                       |
  | get_domain        | Return the domain name of IP address.                        |
  | get_zipcode       | Return the zipcode of the city.                              |
  | get_timezone      | Return the UTC time zone (with DST supported).               |
  | get_netspeed      | Return the Internet connection type. Please see [Internet Connection Type](https://github.com/[chrislim2888/IP2Location-Python](https://github.com/chrislim2888/IP2Location-Python)#internet-connection-type) for details. |
  | get_idd_code      | Return the IDD prefix to call the city from another country. |
  | get_area_code     | Return the area code of the city.                            |
  | get_weather_code  | Return the nearest weather observation station code.         |
  | get_weather_name  | Return the nearest weather observation station name.         |
  | get_mcc           | Return the Mobile Country Codes (MCC).                       |
  | get_mnc           | Return the Mobile Network Code (MNC).                        |
  | get_mobile_brand  | Commercial brand associated with the mobile carrier. Please visit [Mobile Carrier Coverage](https://www.ip2location.com/mobile-carrier-coverage) to view the coverage report. |
  | get_elevation     | Return average height of city above sea level in meters (m). |
  | get_usage_type    | Return the ISP's usage type of IP address. Please see [Usage Type](https://github.com/[chrislim2888/IP2Location-Python](https://github.com/chrislim2888/IP2Location-Python)#usage-type) for details. |
  | get_address_type  | Return the IP address type (A-Anycast, B-Broadcast, M-Multicast & U-Unicast) of IP address or domain name. |
  | get_category      | Return the IAB content taxonomy category of IP address or domain name. You can get a full list of IAB content taxonomy category from [here](https://www.ip2location.com/free/iab-categories). |



  Below is the description of the functions available in the **Web Service** lookup.

  | Function Name | Description                                                  |
  | ------------- | ------------------------------------------------------------ |
  | Constructor   | Expect 3 input parameters:<ol><li>IP2Location API Key.</li><li>Package (WS1 - WS25)</li><li>Use HTTPS or HTTP</li></ol> |
  | lookup        | Return the IP information in array.  <ul><li>country_code</li><li>country_name</li><li>region_name</li><li>city_name</li><li>latitude</li><li>longitude</li><li>zip_code</li><li>time_zone</li><li>isp</li><li>domain</li><li>net_speed</li><li>idd_code</li><li>area_code</li><li>weather_station_code</li><li>weather_station_name</li><li>mcc</li><li>mnc</li><li>mobile_brand</li><li>elevation</li><li>usage_type</li><li>address_type</li><li>category</li><li>category_name</li><li>continent<ul><li>name</li><li>code</li><li>hemisphere</li><li>translations</li></ul></li><li>country<ul><li>name</li><li>alpha3_code</li><li>numeric_code</li><li>demonym</li><li>flag</li><li>capital</li><li>total_area</li><li>population</li><li>currency<ul><li>code</li><li>name</li><li>symbol</li></ul></li><li>language<ul><li>code</li><li>name</li></ul></li><li>idd_code</li><li>tld</li><li>translations</li></ul></li><li>region<ul><li>name</li><li>code</li><li>translations</li></ul></li><li>city<ul><li>name</li><li>translations</li></ul></li><li>geotargeting<ul><li>metro</li></ul></li><li>country_groupings</li><li>time_zone_info<ul><li>olson</li><li>current_time</li><li>gmt_offset</li><li>is_dst</li><li>sunrise</li><li>sunset</li></ul></li><ul> |
  | get_credit    | Return remaining credit of the web service account.          |



  Below is the description of the functions available in the **IP Tools** class.

  | Function Name   | Description                                                  |
  | --------------- | ------------------------------------------------------------ |
  | is_ipv4         | Return either **true** or **false**. Verify if a string is a valid IPv4 address. |
  | is_ipv6         | Return either **true** or **false**. Verify if a string is a valid IPv6 address. |
  | ipv4_to_decimal | Translate IPv4 address from dotted-decimal address to decimal format. |
  | decimal_to_ipv4 | Translate IPv4 address from decimal number to dotted-decimal address. |
  | ipv6_to_decimal | Translate IPv6 address from hexadecimal address to decimal format. |
  | decimal_to_ipv6 | Translate IPv6 address from decimal number into hexadecimal address. |
  | ipv4_to_cidr    | Convert IPv4 range into a list of IPv4 CIDR notation.        |
  | cidr_to_ipv4    | Convert IPv4 CIDR notation into a list of IPv4 addresses.    |
  | ipv6_to_cidr    | Convert IPv6 range into a list of IPv6 CIDR notation.        |
  | cidr_to_ipv6    | Convert IPv6 CIDR notation into a list of IPv6 addresses.    |
  | compressed_ipv6 | Compress a IPv6 to shorten the length.                       |
  | expand_ipv6     | Expand a shorten IPv6 to full length.



  Below is the description of the functions available in the **Country** class.

  | Function Name                          | Description                                                  |
  | -------------------------------------- | ------------------------------------------------------------ |
  | Constructor                            | Expect a IP2Location Country Information CSV file. This database is free for download at https://www.ip2location.com/free/country-information |
  | get_country_info | Provide a ISO 3166 country code to get the country information in array. Will return a full list of countries information if country code not provided. Below is the information returned: <ul><li>country_code</li><li>country_alpha3_code</li><li>country_numeric_code</li><li>capital</li><li>country_demonym</li><li>total_area</li><li>population</li><li>idd_code</li><li>currency_code</li><li>currency_name</li><li>currency_symbol</li><li>lang_code</li><li>lang_name</li><li>cctld</li></ul> |



  Below is the description of the functions available in the **Region** class.

  | Function Name                                       | Description                                                  |
  | --------------------------------------------------- | ------------------------------------------------------------ |
  | Constructor                                         | Expect a IP2Location ISO 3166-2 Subdivision Code CSV file. This database is free for download at https://www.ip2location.com/free/iso3166-2 |
  | get_region_code | Provide a ISO 3166 country code and the region name to get ISO 3166-2 subdivision code for the region. | |



      python sample.py
      python test.py
      python lookup.py <ip_address>


  * Download free IP2Location LITE databases at [https://lite.ip2location.com](https://lite.ip2location.com)
  * Download IP2Location sample databases at [https://www.ip2location.com/developers](https://www.ip2location.com/developers)


  * Use the IPv4 BIN file if you just need to query IPv4 addresses.
  * Use the IPv6 BIN file if you need to query BOTH IPv4 and IPv6 addresses.



  | Internet Connection Type | Description                  |
  | ------------------------ | ---------------------------- |
  | DIAL                     | Dial Up                      |
  | DSL                      | Broadband/Cable/Fiber/Mobile |
  | COMP                     | Company/T1                   |



  | Usage Type | Description                     |
  | ---------- | ------------------------------- |
  | COM        | Commercial                      |
  | ORG        | Organization                    |
  | GOV        | Government                      |
  | MIL        | Military                        |
  | EDU        | University/College/School       |
  | LIB        | Library                         |
  | CDN        | Content Delivery Network        |
  | ISP        | Fixed Line ISP                  |
  | MOB        | Mobile ISP                      |
  | DCH        | Data Center/Web Hosting/Transit |
  | SES        | Search Engine Spider            |
  | RSV        | Reserved                        |



  Email: support@ip2location.com.
  URL: [https://www.ip2location.com](https://www.ip2location.com)


pkgId: 929e2cf1d0bbd1033a3c30dab93470bb92f8d18b759b1bc8c705e59e365a597a
name: python-IPy
arch: src
version: 1.01
epoch: 0
release: 1
summary: Class and tools for handling of IPv4 and IPv6 addresses and networks
url: https://github.com/autocracy/python-ipy
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1734f510-680f-439a-9e4a-766f57204e60
location_href: 00011068-python-ipy/python-IPy-1.01-1.src.rpm
checksum_type: sha256
description:
  The IP class allows a comfortable parsing and handling for most
  notations in use for IPv4 and IPv6 addresses and networks. It was
  greatly inspired by RIPE's Perl module NET::IP's interface but
  doesn't share the implementation. It doesn't share non-CIDR netmasks,
  so funky stuff like a netmask of 0xffffff0f can't be done here. ::
      >>> from IPy import IP
      >>> ip = IP('127.0.0.0/30')
      >>> for x in ip:
      127.0.0.0
      127.0.0.1
      127.0.0.2
      127.0.0.3
      >>> ip2 = IP('0x7f000000/30')
      >>> ip == ip2
      1
      >>> ip.reverseNames()
      ['0.0.0.127.in-addr.arpa.', '1.0.0.127.in-addr.arpa.', '2.0.0.127.in-addr.arpa.', '3.0.0.127.in-addr.arpa.']
      >>> ip.reverseName()
      '0-3.0.0.127.in-addr.arpa.'
      >>> ip.iptype()
      'LOOPBACK'


pkgId: 12ad3ec35d98697a6c8e9075cfd984afbfa7b750d594bad834edb8490bbd24bf
name: python-Inject
arch: src
version: 4.3.1
epoch: 0
release: 1
summary: Python dependency injection framework
url: https://github.com/ivankorobkov/python-inject
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6cd8b573-6d01-4c0a-b7ab-f909ea504a91
location_href: 00003905-python-inject/python-Inject-4.3.1-1.src.rpm
checksum_type: sha256
description:
  Dependency injection the python way, the good way. Not a port of Guice or Spring.


  * Fast.
  * Thread-safe.
  * Simple to use.
  * Does not steal class constructors.
  * Does not try to manage your application object graph.
  * Transparently integrates into tests.
  * Supports Python 3.5+ (`v4.*`) and Python 2.7–3.5 (`v3.*`).
  * Supports type hinting in Python 3.5+.
  * Autoparams leveraging type annotations.



  | Python | Inject Version |
  |--------|----------------|
  | 3.6+   | 4.1+           |
  | 3.5    | 4.0            |
  | < 3.5  | 3.*            |



  Use pip to install the lastest version:

  ```bash
  pip install inject
  ```


  `@inject.autoparams` returns a decorator which automatically injects arguments into a function
  that uses type annotations. This is supported only in Python >= 3.5.

  ```python
  @inject.autoparams()
  def refresh_cache(cache: RedisCache, db: DbInterface):
      pass
  ```

  There is an option to specify which arguments we want to inject without attempts of
  injecting everything:

  ```python
  @inject.autoparams('cache', 'db')
  def sign_up(name, email, cache: RedisCache, db: DbInterface):
      pass
  ```


  ```python

  import inject



  def foo(bar):
      cache = inject.instance(Cache)
      cache.save('bar', bar)




  @inject.params(cache=Cache, user=CurrentUser)
  def baz(foo, cache=None, user=None):
      cache.save('foo', foo, user)



  baz('foo')


  baz('foo', my_cache)


  baz('foo', my_cache, user=current_user)



  @inject.param('cache', Cache)
  def bar(foo, cache=None):
      cache.save('foo', foo)



  class User(object):
      cache = inject.attr(Cache)

      def __init__(self, id):
          self.id = id

      def save(self):
          self.cache.save('users', self)

      @classmethod
      def load(cls, id):
          return cls.cache.load('users', id)



  def my_config(binder):
      binder.install(my_config2)  # Add bindings from another config.
      binder.bind(Cache, RedisCache('localhost:1234'))


  inject.configure(my_config)



  user = User(10)
  user.save()


  foo('Hello')
  bar('world')
  ```



  Django can load some modules multiple times which can lead to
  `InjectorException: Injector is already configured`. You can use `configure_once` which
  is guaranteed to run only once when the injector is absent:
  ```python
  import inject
  inject.configure_once(my_config)
  ```


  In tests use `inject.clear_and_configure(callable)` to create a new injector on setup,
  and optionally `inject.clear()` to clean up on tear down:
  ```python
  class MyTest(unittest.TestCase):
      def setUp(self):
          inject.clear_and_configure(lambda binder: binder
              .bind(Cache, Mock()) \
              .bind(Validator, TestValidator()))

      def tearDown(self):
          inject.clear()
  ```


  After configuration the injector is thread-safe and can be safely reused by multiple threads.


  **Instance** bindings always return the same instance:

  ```python
  redis = RedisCache(address='localhost:1234')
  def config(binder):
      binder.bind(Cache, redis)
  ```

  **Constructor** bindings create a singleton on injection:

  ```python
  def config(binder):
      
      binder.bind_to_constructor(Cache, lambda: RedisCache(address='localhost:1234'))
  ```

  **Provider** bindings call the provider on injection:

  ```python
  def get_my_thread_local_cache():
      pass

  def config(binder):
      
      binder.bind_to_provider(Cache, get_my_thread_local_cache)
  ```

  **Runtime** bindings automatically create singletons on injection, require no configuration.
  For example, only the `Config` class binding is present, other bindings are runtime:

  ```python
  class Config(object):
      pass

  class Cache(object):
      config = inject.attr(Config)

  class Db(object):
      config = inject.attr(Config)

  class User(object):
      cache = inject.attr(Cache)
      db = inject.attr(Db)

      @classmethod
      def load(cls, user_id):
          return cls.cache.load('users', user_id) or cls.db.load('users', user_id)

  inject.configure(lambda binder: binder.bind(Config, load_config_file()))
  user = User.load(10)
  ```

  Sometimes runtime binding leads to unexpected behaviour.  Say if you forget
  to bind an instance to a class, `inject` will try to implicitly instantiate it.

  If an instance is unintentionally created with default arguments it may lead to
  hard-to-debug bugs.  To disable runtime binding and make sure that only
  explicitly bound instances are injected, pass `bind_in_runtime=False`
  to `inject.configure`, `inject.configure_once` or `inject.clear_and_configure`.

  In this case `inject` immediately raises `InjectorException` when the code
  tries to get an unbound instance.


  It is possible to use any hashable object as a binding key. For example:

  ```python
  import inject

  inject.configure(lambda binder: \
      binder.bind('host', 'localhost') \
      binder.bind('port', 1234))
  ```


  I've used Guice and Spring in Java for a lot of years, and I don't like their scopes.
  `python-inject` by default creates objects as singletons. It does not need a prototype scope
  as in Spring or NO_SCOPE as in Guice because `python-inject` does not steal your class
  constructors. Create instances the way you like and then inject dependencies into them.

  Other scopes such as a request scope or a session scope are fragile, introduce high coupling,
  and are difficult to test. In `python-inject` write custom providers which can be thread-local,
  request-local, etc.

  For example, a thread-local current user provider:

  ```python
  import inject
  import threading


  class User(object):
      pass


  _LOCAL = threading.local()

  def get_current_user():
      return getattr(_LOCAL, 'user', None)

  def set_current_user(user):
      _LOCAL.user = user


  inject.configure(lambda binder: binder.bind_to_provider(User, get_current_user))


  @inject.params(user=User)
  def foo(user):
      pass
  ```


  * Project: https://github.com/ivankorobkov/python-inject


  Apache License 2.0


  * Ivan Korobkov [@ivankorobkov](https://github.com/ivankorobkov)
  * Jaime Wyant [@jaimewyant](https://github.com/jaimewyant)
  * Sebastian Buczyński [@Enforcer](https://github.com/Enforcer)
  * Oleksandr Fedorov [@Fedorof](https://github.com/Fedorof)
  * cselvaraj [@cselvaraj](https://github.com/cselvaraj)
  * 陆雨晴 [@SixExtreme](https://github.com/SixExtreme)
  * Andrew William Borba [@andrewborba10](https://github.com/andrewborba10)
  * jdmeyer3 [@jdmeyer3](https://github.com/jdmeyer3)
  * Alex Grover [@ajgrover](https://github.com/ajgrover)
  * Harro van der Kroft [@wisepotato](https://github.com/wisepotato)
  * Samiur Rahman [@samiur](https://github.com/samiur)
  * 45deg [@45deg](https://github.com/45deg)
  * Alexander Nicholas Costas [@ancostas](https://github.com/ancostas)
  * Dmitry Balabka [@dbalabka](https://github.com/dbalabka)


pkgId: a9bfcfeb5f5a2a05e886f4f11866e40db8cb883588687b0c49b21d0e78dea17b
name: python-JPype1
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: A Python to Java bridge.
url: https://github.com/jpype-project/jpype
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cb12d5aa-79a0-4230-b6fe-b25a4d2b8f06
location_href: 00009397-python-jpype1/python-JPype1-1.4.1-1.src.rpm
checksum_type: sha256
description:
  |implementation|  |pyversions|  |javaversions|  |jvm|  |platform|  |license|
  JPype is a Python module to provide full access to Java from
  within Python. It allows Python to make use of Java only libraries,
  exploring and visualization of Java structures, development and testing
  of Java libraries, scientific computing, and much more.  By gaining
  the best of both worlds using Python for rapid prototyping and Java
  for strong typed production code, JPype provides a powerful environment
  for engineering and code development.
  This is achieved not through re-implementing Python, as
  Jython has done, but rather through interfacing at the native
  level in both virtual machines. This shared memory based
  approach achieves decent computing performance, while providing the
  access to the entirety of CPython and Java libraries.
   <https://github.com/jpype-project/jpype>`_
   <https://github.com/jpype-project/jpype/issues>`_
   <https://github.com/jpype-project/jpype/discussions>`_
  The work on this project began on `Sourceforge <http://sourceforge.net/projects/jpype/>`__.
  LLNL-CODE- 812311
  SPDX-License-Identifier: Apache-2.0


pkgId: b5f8821fc6f24d303f9312a244bcaa46d60dd34a4ce8b534dc627488253e5bdd
name: python-JPype1-debuginfo
arch: aarch64
version: 1.4.1
epoch: 0
release: 1
summary: Debug information for package python-JPype1
url: https://github.com/jpype-project/jpype
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cb12d5aa-79a0-4230-b6fe-b25a4d2b8f06
rpm_sourcerpm: python-JPype1-1.4.1-1.src.rpm
location_href: 00009397-python-jpype1/python-JPype1-debuginfo-1.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-JPype1.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 94ba08113a506680a0aeb4dcff61da4ec8ecc1c3c4192c3b16645d954cdfa5fc
name: python-JPype1-debugsource
arch: aarch64
version: 1.4.1
epoch: 0
release: 1
summary: Debug sources for package python-JPype1
url: https://github.com/jpype-project/jpype
rpm_license: License :: OSI Approved :: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cb12d5aa-79a0-4230-b6fe-b25a4d2b8f06
rpm_sourcerpm: python-JPype1-1.4.1-1.src.rpm
location_href: 00009397-python-jpype1/python-JPype1-debugsource-1.4.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-JPype1.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2400436fbea304677ba9f5ea7d52d050272fb98a90c883f5d756cd29f42de815
name: python-Jinja2
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: A very fast and expressive template engine.
url: https://palletsprojects.com/p/jinja/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e41c8187-058a-4d28-9d98-8456fe607fe7
location_href: 00008896-python-jinja2/python-Jinja2-3.1.2-1.src.rpm
checksum_type: sha256
description:
  Jinja is a fast, expressive, extensible templating engine. Special
  placeholders in the template allow writing code similar to Python
  syntax. Then the template is passed data to render the final document.
  It includes:
  -   Template inheritance and inclusion.
  -   Define and import macros within templates.
  -   HTML templates can use autoescaping to prevent XSS from untrusted
      user input.
  -   A sandboxed environment can safely render untrusted templates.
  -   AsyncIO support for generating templates and calling async
      functions.
  -   I18N support with Babel.
  -   Templates are compiled to optimized Python code just-in-time and
      cached, or can be compiled ahead-of-time.
  -   Exceptions point to the correct line in templates to make debugging
      easier.
  -   Extensible filters, tests, functions, and even syntax.
  Jinja's philosophy is that while application logic belongs in Python if
  possible, it shouldn't make the template designer's job difficult by
  restricting functionality too much.


pkgId: c642a9393e804cd8aa809afaeda28e3fd24ec38af9fb0cd54fda6dc0311f855b
name: python-Js2Py
arch: src
version: 0.74
epoch: 0
release: 1
summary: JavaScript to Python Translator & JavaScript interpreter written in 100% pure Python.
url: https://github.com/PiotrDabkowski/Js2Py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3fe09347-c3de-412e-bdf2-6443c805f2d8
location_href: 00010805-python-js2py/python-Js2Py-0.74-1.src.rpm
checksum_type: sha256
description:
  Translates JavaScript to Python code. Js2Py is able to translate and execute virtually any JavaScript code.

  Js2Py is written in pure python and does not have any dependencies. Basically an implementation of JavaScript core in pure python.


      import js2py

      f = js2py.eval_js( "function $(name) {return name.length}" )

      f("Hello world")

      

  Now also supports ECMA 6 through js2py.eval_js6(js6_code)!

  More examples at: https://github.com/PiotrDabkowski/Js2Py


pkgId: 232bded3f29347e95b2df8c9246b409e7f252f4c654feaaea42558a42305d4aa
name: python-Lasagne
arch: src
version: 0.1
epoch: 0
release: 1
summary: A lightweight library to build and train neural networks in Theano
url: https://github.com/Lasagne/Lasagne
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e3a56d6-dd40-44db-b326-6ccce42f8fc7
location_href: 00004044-python-lasagne/python-Lasagne-0.1-1.src.rpm
checksum_type: sha256
description:
  Lasagne is a lightweight library to build and train neural networks in Theano.
  Its main features are:
  * Supports feed-forward networks such as Convolutional Neural Networks (CNNs),
    recurrent networks including Long Short-Term Memory (LSTM), and any
    combination thereof
  * Allows architectures of multiple inputs and multiple outputs, including
    auxiliary classifiers
  * Many optimization methods including Nesterov momentum, RMSprop and ADAM
  * Freely definable cost function and no need to derive gradients due to
    Theano's symbolic differentiation
  * Transparent support of CPUs and GPUs due to Theano's expression compiler
  Its design is governed by `six principles
  <http://lasagne.readthedocs.org/en/latest/user/development.html#philosophy>`_:
  * Simplicity: Be easy to use, easy to understand and easy to extend, to
    facilitate use in research
  * Transparency: Do not hide Theano behind abstractions, directly process and
    return Theano expressions or Python / numpy data types
  * Modularity: Allow all parts (layers, regularizers, optimizers, ...) to be
    used independently of Lasagne
  * Pragmatism: Make common use cases easy, do not overrate uncommon cases
  * Restraint: Do not obstruct users with features they decide not to use
  * Focus: "Do one thing and do it well"


pkgId: 478cb55c96ac85f61df32362c5eb2034c761eb398a0538dfd6d05e1601bc9f99
name: python-Lifetimes
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: Measure customer lifetime value in Python
url: https://github.com/CamDavidsonPilon/lifetimes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e96ce386-cff1-468a-9353-fb129b4d5da4
location_href: 00009710-python-lifetimes/python-Lifetimes-0.11.3-1.src.rpm
checksum_type: sha256
description:
  ![](http://i.imgur.com/7s3jqZM.png)


  [![PyPI version](https://badge.fury.io/py/Lifetimes.svg)](https://badge.fury.io/py/Lifetimes)
  [![Documentation Status](https://readthedocs.org/projects/lifetimes/badge/?version=latest)](http://lifetimes.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/CamDavidsonPilon/lifetimes.svg?branch=master)](https://travis-ci.org/CamDavidsonPilon/lifetimes)
  [![Coverage Status](https://coveralls.io/repos/CamDavidsonPilon/lifetimes/badge.svg?branch=master)](https://coveralls.io/r/CamDavidsonPilon/lifetimes?branch=master)




  Lifetimes can be used to analyze your users based on a few assumption:

  1. Users interact with you when they are "alive".
  2. Users under study may "die" after some period of time.

  I've quoted "alive" and "die" as these are the most abstract terms: feel free to use your own definition of "alive" and "die" (they are used similarly to "birth" and "death" in survival analysis). Whenever we have individuals repeating occurrences, we can use Lifetimes to help understand user behaviour.



  If this is too abstract, consider these applications:

   - Predicting how often a visitor will return to your website. (Alive = visiting. Die = decided the website wasn't for them)
   - Understanding how frequently a patient may return to a hospital. (Alive = visiting. Die = maybe the patient moved to a new city, or became deceased.)
   - Predicting individuals who have churned from an app using only their usage history. (Alive = logins. Die = removed the app)
   - Predicting repeat purchases from a customer. (Alive = actively purchasing. Die = became disinterested with your product)
   - Predicting the lifetime value of your customers



  As emphasized by P. Fader and B. Hardie, understanding and acting on customer lifetime value (CLV) is the most important part of your business's sales efforts. [And (apparently) everyone is doing it wrong (Prof. Fader's Video Lecture)](https://www.youtube.com/watch?v=guj2gVEEx4s). *Lifetimes* is a Python library to calculate CLV for you.



  ```bash
  pip install lifetimes
  ```



  Please refer to the [Contributing Guide](https://github.com/CamDavidsonPilon/lifetimes/blob/master/CONTRIBUTING.md) before creating any *Pull Requests*. It will make life easier for everyone.


  [Official documentation](http://lifetimes.readthedocs.io/en/latest/)




  Please create an issue in the [lifetimes repository](https://github.com/CamDavidsonPilon/lifetimes).



  1. Probably, the seminal article of Non-Contractual CLV is [*Counting Your Customers: Who Are They and What Will They Do Next?*](https://www.jstor.org/stable/2631608?seq=1#page_scan_tab_contents), by David C. Schmittlein, Donald G. Morrison and Richard Colombo. Despite it being paid, it is worth the read. The relevant information will eventually end up in this library's documentation though.
  1. The other (more recent) paper is [*“Counting Your Customers” the Easy Way:
  An Alternative to the Pareto/NBD Model*](http://brucehardie.com/papers/018/fader_et_al_mksc_05.pdf), by Peter Fader, Bruce Hardie and Ka Lok Lee.



  1. [Roberto Medri](http://cdn.oreillystatic.com/en/assets/1/event/85/Case%20Study_%20What_s%20a%20Customer%20Worth_%20Presentation.pdf) did a nice presentation on CLV at Etsy.
  1. [Papers](http://mktg.uni-svishtov.bg/ivm/resources/Counting_Your_Customers.pdf), lots of [papers](http://brucehardie.com/notes/009/pareto_nbd_derivations_2005-11-05.pdf).
  1. R implementation is called [BTYD](http://cran.r-project.org/web/packages/BTYD/vignettes/BTYD-walkthrough.pdf) (*Buy 'Til You Die*).
  1. [Bruce Hardie's Website](http://brucehardie.com/), especially his notes, is full of useful and essential explanations, many of which are featured in this library.


pkgId: f09e2c0a7373b871ced370ceac0a83ea38f45050e7a9c234623d62693590aa0f
name: python-LinkHeader
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: Parse and format link headers according to RFC 5988 "Web Linking"
url: http://bitbucket.org/asplake/link_header
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-db06f4be-788a-4b1e-a63b-67832a070726
location_href: 00004114-python-linkheader/python-LinkHeader-0.4.3-1.src.rpm
checksum_type: sha256
description:
  Parse and format link headers according to RFC 5988 "Web Linking".

  Usage (assuming a suitable headers object in the environment):

  	>>> headers['Link'] = str(LinkHeader([Link("http://example.com/foo", rel="self"),
  	...                                   Link("http://example.com", rel="up")]))
  	>>> headers['Link']
  	'<http://example.com/foo>; rel=self, <http://example.com>; rel=up'
  	>>> parse(headers['Link'])
  	LinkHeader([Link('http://example.com/foo', rel='self'), Link('http://example.com', rel='up')])

  Blank and missing values roundtrip correctly:

  	>>> format_link(parse('</s/1>; obs; if="core.s"; foo=""'))
  	'<</s/1>; obs; if=core.s; foo="">'

  Conversions to and from json-friendly list-based structures are also provided:

  	>>> parse(headers['Link']).to_py()
  	[['http://example.com/foo', [['rel', 'self']]], ['http://example.com', [['rel', 'up']]]]
  	>>> str(LinkHeader([['http://example.com/foo', [['rel', 'self']]],
  	...                 ['http://example.com', [['rel', 'up']]]]))
  	'<http://example.com/foo>; rel=self, <http://example.com>; rel=up'


pkgId: 0f9cf15112511cf5a5ebe8f2d114ba17edc1b46a0f27edeab2166e869cd77593
name: python-Locales
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Module for multilingual solutions
url: https://github.com/vffuunnyy/Locales
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f8692d98-e718-4c0d-adab-7a5ac71a9636
location_href: 00012080-python-locales/python-Locales-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Locales - module for multilingual projects





  Locales uses only standard library **json**. You need to write the translations in *json format*

  ```json
  {
    "languages": {
        "ru": "Р СѓСЃСЃРєРёР№", "eng": "English", "sp": "EspaГ±ol"
    },

    "messages": {
        "welcome": {
            "ru": "Р”РѕР±СЂРѕ РїРѕР¶Р°Р»РѕРІР°С‚СЊ!",
            "eng": "Welcome!"
        },
        "goodbye": {
            "ru": "РџРѕРєР°",
            "eng": "Goodbye",
            "sp": "AdiГіs"
        }
    }
  }
  ```
  Keys `languages` and `messages` required.

  To generate the same file use:
  ```python
  import Locales

  Locales().example()
  ```



  You can install Locales using pip

  ```sh
  $ pip install locales
  ```
  or download `Locales.py` and drop to folder with your project



  ```python
  import Locales

  loc = Locales("filename.json")
  loc.set_default_lang("eng")  # Set the language by default

  print(loc.get("welcome"))


  print(loc.get("welcome", "ru"))


  print(loc.get_all("goodbye")


  print(loc.get_by_name("English"))

  ```



  * **vffuunnyy** - *Initial work* - [@vffuunnyy](https://t.me/vffuunnyy)


pkgId: 8bfc46577e58a96dbcf78982bfb2509abe0a543ad358f78f07478317f361bb72
name: python-LumoPackage
arch: src
version: 2.2022.10.13
epoch: 0
release: 1
summary: Lumo example package
url: https://pypi.org/project/LumoPackage/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ea4a080c-4f97-4b89-820e-0144f478f1c0
location_href: 00012059-python-lumopackage/python-LumoPackage-2.2022.10.13-1.src.rpm
checksum_type: sha256
description:
  **Lumo Packages!**
  *Don't use this package in production!!*
  This is an auto-corralation package used in Lumatch system


pkgId: 5e58c6b526e199c0cf4d252d437d68598fd3b627cdd0182e55588ee3524d878b
name: python-MDAnalysis
arch: src
version: 2.4.2
epoch: 0
release: 1
summary: An object-oriented toolkit to analyze molecular dynamics trajectories.
url: https://www.mdanalysis.org
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4f328773-5142-4202-b516-04f1384fa007
location_href: 00002856-python-MDAnalysis/python-MDAnalysis-2.4.2-1.src.rpm
checksum_type: sha256
description:
     import MDAnalysis as mda
     
     u = mda.Universe('topol.tpr','traj.trr')
     
     ag = u.select_atoms('name OH')
     
     ag.positions
     ag.velocities
     ag.forces
     
     for ts in u.trajectory:
         print(ag.center_of_mass())

rpm_license:
  ========================================================================== Licenses of components of MDAnalysis ==========================================================================   GNU GENERAL PUBLIC LICENSE Version 2, June 1991  Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it.  (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.)  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.  To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.  Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software.  If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.  Finally, any free program is threatened constantly by software patents.  We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary.  To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.  The precise terms and conditions for copying, distribution and modification follow.  GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License.  The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  Each licensee is addressed as "you".  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.  1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.  b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.  c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License.  (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.  In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:  a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,  c) Accompany it with the information you received as to the offer to distribute corresponding source code.  (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)  The source code for a work means the preferred form of the work for making modifications to it.  For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable.  However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.  4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  5. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Program or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.  6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.  7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all.  For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.  10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA   Also add information on how to contact you by electronic and paper mail.  If the program is interactive, make it output a short notice like this when it starts in an interactive mode:  Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.  <signature of Ty Coon>, 1 April 1989 Ty Coon, President of Vice  This General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Library General Public License instead of this License.   ==========================================================================  Gromacs xdrfile library for reading XTC/TRR trajectories - lib/formats/src/xdrfile.c - lib/formats/src/xdrfile_xtc.c - lib/formats/src/xdrfile_trr.c - lib/formats/include/xdrfile.h - lib/formats/include/xdrfile_xtc.h - lib/formats/include/xdrfile_trr.h  Copyright (c) 2009-2014, Erik Lindahl & David van der Spoel All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  ==========================================================================  CatDCD is released under the UIUC Open Source License: http://www.ks.uiuc.edu/Development/MDTools/catdcd/license.html  University of Illinois Open Source License Copyright 2003-2007 Theoretical and Computational Biophysics Group, All rights reserved.  Developed by:           Theoretical and Computational Biophysics Group University of Illinois at Urbana-Champaign http://www.ks.uiuc.edu/  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the Software), to deal with 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:  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.  Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.  Neither the names of Theoretical and Computational Biophysics Group, University of Illinois at Urbana-Champaign, nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.  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 CONTRIBUTORS 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 WITH THE SOFTWARE.  ==========================================================================  Biopython License Agreement  Permission to use, copy, modify, and distribute this software and its documentation with or without modifications and for any purpose and without fee is hereby granted, provided that any copyright notices appear in all copies and that both those copyright notices and this permission notice appear in supporting documentation, and that the names of the contributors or copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific prior permission.  THE CONTRIBUTORS AND COPYRIGHT HOLDERS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE   ==========================================================================  transformations module - transformations.py - transformations.c  Copyright (c) 2006, Christoph Gohlke Copyright (c) 2006-2010, The Regents of the University of California All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the copyright holders nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  ==========================================================================  pyqcprot (src/pyqcprot) is released under the following 'BSD 3-clause' licence:  ----------------------------------------------------------------------------- PyQCPROT  Author(s) of Original Implementation: Douglas L. Theobald Department of Biochemistry MS 009 Brandeis University 415 South St Waltham, MA  02453 USA  dtheobald@brandeis.edu  Pu Liu Johnson & Johnson Pharmaceutical Research and Development, L.L.C. 665 Stockton Drive Exton, PA  19341 USA  pliu24@its.jnj.com  For the original code written in C see: http://theobald.brandeis.edu/qcp/   Author of Python Port: Joshua L. Adelman Department of Biological Sciences University of Pittsburgh Pittsburgh, PA 15260  jla65@pitt.edu   If you use this QCP rotation calculation method in a publication, please reference:  Douglas L. Theobald (2005) "Rapid calculation of RMSD using a quaternion-based characteristic polynomial." Acta Crystallographica A 61(4):478-480.  Pu Liu, Dmitris K. Agrafiotis, and Douglas L. Theobald (2010) "Fast determination of the optimal rotational matrix for macromolecular superpositions." J. Comput. Chem. 31, 1561-1563.   Copyright (c) 2009-2010, Pu Liu and Douglas L. Theobald Copyright (c) 2011       Joshua L. Adelman All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the <ORGANIZATION> nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   ==========================================================================  MDAnalysis logo (see doc/sphinx/source/logos)  The MDAnalysis 'Atom' logo was created by Christian Beckstein and is  Copyright (c) 2011 Christian Beckstein  MDAnalysis Logo 'Atom' by Christian Beckstein is licensed under a Creative Commons Attribution-NoDerivs 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nd/3.0/ or send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.  The logo is contained in the file 'mdanalysis-logo.png'.  Derivatives in the files 'mdanalysis-logo-127x55.png', 'mdanalysis-logo-200x150.png', 'mdanalysis-logo.ico' were created for inclusion in MDAnalysis and on websites related to MDAnalysis. They are distributed under the same license as the 'Atom' logo.  ==========================================================================


pkgId: fcff9538af83192eb710a53ce773cf3db6d26453e649b30c6c37a90792bdd3a0
name: python-MDP
arch: src
version: 3.6
epoch: 0
release: 1
url: https://mdpdocs.readthedocs.io
rpm_license: https://raw.githubusercontent.com/mdp-toolkit/mdp-toolkit/master/COPYRIGHT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-80640407-dfe7-4f9d-8ee2-f841390e7298
location_href: 00004177-python-mdp/python-MDP-3.6-1.src.rpm
checksum_type: sha256
summary:
  MDP is a Python library for building complex data processing software by combining widely used machine learning algorithms into pipelines and networks.

description:
  **The Modular toolkit for Data Processing (MDP)** package is a library
  of widely used data processing algorithms, and the possibility to
  combine them together to form pipelines for building more complex
  data processing software.

  MDP has been designed to be used as-is and as a framework for
  scientific data processing development.

  From the user's perspective, MDP consists of a collection of *units*,
  which process data. For example, these include algorithms for
  supervised and unsupervised learning, principal and independent
  components analysis and classification.

  These units can be chained into data processing flows, to create
  pipelines as well as more complex feed-forward network
  architectures. Given a set of input data, MDP takes care of training
  and executing all nodes in the network in the correct order and
  passing intermediate data between the nodes. This allows the user to
  specify complex algorithms as a series of simpler data processing
  steps.

  The number of available algorithms is steadily increasing and includes
  signal processing methods (Principal Component Analysis, Independent
  Component Analysis, Slow Feature Analysis), manifold learning methods
  ([Hessian] Locally Linear Embedding), several classifiers,
  probabilistic methods (Factor Analysis, RBM), data pre-processing
  methods, and many others.

  Particular care has been taken to make computations efficient in terms
  of speed and memory. To reduce the memory footprint, it is possible to
  perform learning using batches of data. For large data-sets, it is
  also possible to specify that MDP should use single precision floating
  point numbers rather than double precision ones. Finally, calculations
  can be parallelised using the ``parallel`` subpackage, which offers a
  parallel implementation of the basic nodes and flows.

  From the developer's perspective, MDP is a framework that makes the
  implementation of new supervised and unsupervised learning algorithms
  easy and straightforward. The basic class, ``Node``, takes care of tedious
  tasks like numerical type and dimensionality checking, leaving the
  developer free to concentrate on the implementation of the learning
  and execution phases. Because of the common interface, the node then
  automatically integrates with the rest of the library and can be used
  in a network together with other nodes.

  A node can have multiple training phases and even an undetermined
  number of phases. Multiple training phases mean that the training data
  is presented multiple times to the same node. This allows the
  implementation of algorithms that need to collect some statistics on
  the whole input before proceeding with the actual training, and others
  that need to iterate over a training phase until a convergence
  criterion is satisfied. It is possible to train each phase using
  chunks of input data if the chunks are given as an iterable. Moreover,
  crash recovery can be optionally enabled, which will save the state of
  the flow in case of a failure for later inspection.

  MDP is distributed under the open source BSD license. It has been
  written in the context of theoretical research in neuroscience, but it
  has been designed to be helpful in any context where trainable data
  processing algorithms are used. Its simplicity on the user's side, the
  variety of readily available algorithms, and the reusability of the
  implemented nodes also make it a useful educational tool.

  http://mdp-toolkit.sourceforge.net


pkgId: b4dd26d3d1ec635cdb78b10b39001146557f23c1f69b63b45c7b6f3a002184ac
name: python-MEAutility
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Python package for multi-electrode array (MEA) handling and stimulation.
url: https://github.com/alejoe91/MEAutility
rpm_license: GNU General Public License v3 (GPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-83a34ee7-d0e0-4b1d-a07d-854134501806
location_href: 00004179-python-meautility/python-MEAutility-1.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/alejoe91/MEAutility.svg?branch=master)](https://travis-ci.org/alejoe91/MEAutility) [![PyPI version](https://badge.fury.io/py/MEAutility.svg)](https://badge.fury.io/py/MEAutility)



  Python package for multi-electrode array (MEA) handling and stimulation.



  To install run:
  `pip install MEAutility`

  If you want to install from sources and be updated with the latest development you can install with:
  ```
  git clone https://github.com/alejoe91/MEAutility
  cd MEAutility
  python setup.py install (or develop)
  ```

  The package can then imported in Python with:

  `import MEAutility as MEA`


  - numpy
  - pyyaml
  - matplotlib



  Please refer to https://meautility.readthedocs.io/en/latest/



  For any questions or comments, please contact Alessio Buccino: alessiob@ifi.uio.no


pkgId: c6c7d1e474e31c0ac87a3003fbbe336e8d71978517408081644d814cf3426bdb
name: python-Mako
arch: src
version: 1.2.4
epoch: 0
release: 1
url: https://www.makotemplates.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac3521f7-2978-48e4-a023-d31125aa8d7e
location_href: 00008963-python-mako/python-Mako-1.2.4-1.src.rpm
checksum_type: sha256
summary:
  A super-fast templating language that borrows the best ideas from the existing templating languages.


pkgId: 63b35da533daf0f5cede7e94e16dbd81f3207a92d9732462eb38e9bc91a48ad5
name: python-MarkupPy
arch: src
version: 1.14
epoch: 0
release: 1
summary: An HTML/XML generator
url: https://github.com/tylerbakke/MarkupPy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b07ee5ac-21f4-4189-be18-c9ff5d0bc331
location_href: 00010278-python-markuppy/python-MarkupPy-1.14-1.src.rpm
checksum_type: sha256
description:
  This is MarkupPy - a Python module that attempts to make it easier to generate HTML/XML from a Python program in an intuitive, lightweight, customizable and pythonic way. It works with both python 2 and 3.

  The code is in the public domain.

  Version: 1.14 as of August 1, 2017.

  Please send bug reports, feature requests, enhancement ideas or questions to tylerbakke@gmail.com.

  Installation: Run 'pip install MarkupPy" from the terminal.

  Documentation and further info is at https://tylerbakke.github.io/MarkupPy/

  (Migrated from markup.py)


pkgId: 93ace2fbb16edfda0610a37ce44e4c2261765d1cb728a866a44cb88dfc6cc78a
name: python-MarkupSafe
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: Safely add untrusted strings to HTML/XML markup.
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45fb66f2-3f37-4275-b30d-a3d0f271a068
location_href: 00008898-python-markupsafe/python-MarkupSafe-2.1.2-1.src.rpm
checksum_type: sha256
description:
  MarkupSafe implements a text object that escapes characters so it is
  safe to use in HTML and XML. Characters that have special meanings are
  replaced so that they display as the actual characters. This mitigates
  injection attacks, meaning untrusted user input can safely be displayed
  on a page.


pkgId: c4d676d27fa84111a1b184503871f3bb2f6531e2b3ad60aa97e57bb5cc005557
name: python-MarkupSafe-debuginfo
arch: aarch64
version: 2.1.2
epoch: 0
release: 1
summary: Debug information for package python-MarkupSafe
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-45fb66f2-3f37-4275-b30d-a3d0f271a068
rpm_sourcerpm: python-MarkupSafe-2.1.2-1.src.rpm
location_href: 00008898-python-markupsafe/python-MarkupSafe-debuginfo-2.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-MarkupSafe.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 0223e5279c7b3e66675331e40c72b24c19b0bf67c290d0e92ad26c3606998dd6
name: python-MarkupSafe-debugsource
arch: aarch64
version: 2.1.2
epoch: 0
release: 1
summary: Debug sources for package python-MarkupSafe
url: https://palletsprojects.com/p/markupsafe/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-45fb66f2-3f37-4275-b30d-a3d0f271a068
rpm_sourcerpm: python-MarkupSafe-2.1.2-1.src.rpm
location_href: 00008898-python-markupsafe/python-MarkupSafe-debugsource-2.1.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-MarkupSafe.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: ae187702c0742c7222ecbe08b34ce70ca13ee2f648f887898605536439dfa0e2
name: python-Markups
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: A wrapper around various text markups
url: https://github.com/retext-project/pymarkups
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b1f4f4d9-1f33-4119-b8f7-52a57d319fed
location_href: 00004162-python-markups/python-Markups-4.0.0-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://github.com/retext-project/pymarkups/workflows/tests/badge.svg
     :target: https://github.com/retext-project/pymarkups/actions
     :alt: GitHub Actions status
  .. image:: https://codecov.io/gh/retext-project/pymarkups/branch/master/graph/badge.svg
     :target: https://codecov.io/gh/retext-project/pymarkups
     :alt: Coverage status
  .. image:: https://readthedocs.org/projects/pymarkups/badge/?version=latest
     :target: https://pymarkups.readthedocs.io/en/latest/
     :alt: ReadTheDocs status

  This module provides a wrapper around various text markup languages.

  Available by default are Markdown_, reStructuredText_, Textile_ and AsciiDoc_,
  but you can easily add your own markups.

  Usage example:

  .. code:: python

    >>> import markups
    >>> markup = markups.get_markup_for_file_name("myfile.rst")
    >>> markup.name
    'reStructuredText'
    >>> markup.attributes[markups.common.SYNTAX_DOCUMENTATION]
    'https://docutils.sourceforge.io/docs/ref/rst/restructuredtext.html'
    >>> text = """
    ... Hello, world!
    ... =============
    ...
    ... This is an example **reStructuredText** document.
    ... """
    >>> result = markup.convert(text)
    >>> result.get_document_title()
    'Hello, world!'
    >>> print(result.get_document_body())  # doctest: +NORMALIZE_WHITESPACE
    <main id="hello-world">
    <h1 class="title" data-posmap="3">Hello, world!</h1>
    <p data-posmap="5">This is an example <strong>reStructuredText</strong> document.</p>
    </main>

  .. _Markdown: https://daringfireball.net/projects/markdown/
  .. _reStructuredText: https://docutils.sourceforge.io/rst.html
  .. _Textile: https://en.wikipedia.org/wiki/Textile_(markup_language)
  .. _AsciiDoc: https://asciidoc.org

  The release version can be downloaded from PyPI_ or installed using::

    pip install Markups

  .. _PyPI: https://pypi.org/project/Markups/

  The source code is hosted on GitHub_.

  .. _GitHub: https://github.com/retext-project/pymarkups

  The documentation is available online_ or can be generated from source by
  installing Sphinx_ and running::

    python3 -m sphinx docs build/sphinx/html

  .. _online: https://pymarkups.readthedocs.io/en/latest/
  .. _Sphinx: https://www.sphinx-doc.org/en/master/


pkgId: 68546948b5f47ae5e3b8d9faa0e37da509c5f80128be1839db87178a3e3e5c1a
name: python-ModulemdTranslationHelpers
arch: src
version: 0.6
epoch: 0
release: 1
summary: Tools for working with translations of modulemd
url: https://github.com/fedora-modularity/ModulemdTranslationHelpers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b94bb4a-fab0-40bd-84ab-9fbc94b5f0bd
location_href: 00002860-python-ModulemdTranslationHelpers/python-ModulemdTranslationHelpers-0.6-1.src.rpm
checksum_type: sha256
description:
  * [libmodulemd](https://github.com/fedora-modularity/libmodulemd)
  * [koji](https://pagure.io/koji)

  To install on Fedora 28+, run:
  ```
  dnf install libmodulemd koji
  ```


  With the prerequisites installed, the latest version can be installed with
  `pip install ModulemdTranslationHelpers` or on Fedora 28+ with `dnf install
  python3-ModulemdTranslationHelpers` (recommended).




  To extract translatable strings from modules for a particular Fedora
  release (e.g. f29):
  ```
  ModulemdTranslationHelpers --branch f29 extract [--pot-file <path>]
  ```
  This will read all of the module metadata from the Koji build-system and
  convert the translatable strings to a portable object template (`.pot`)
  document.

  Specify the destination for the output file with `--pot-file`.

   
   To convert portable object (`.po`) files into
   modulemd-translations YAML documents that can be included in repodata:
   ```
   ModulemdTranslationHelpers --branch f29 generate_metadata \
                              [--pofile-dir <path>] \
                              [--yaml-file <path>]

   ```

   This will read all files with a `.po` suffix in the `pofile-dir` path and
   write the modulemd YAML to `yaml-file`.



  The ModulemdTranslationHelpers package has two primary functions:
  * get_module_catalog_from_tags()
  * get_modulemd_translations()


  This returns a `babel.message.Catalog` object containing all of the
  translatable strings from any module tagged with one of the passed tags. It
  can be passed to `babel.messages.pofile.write_po()` to create a portable
  object template (`.pot`) file.


  This returns an iterable of modulemd-translation objects generated from a
  set of paths to portable object (`.po`) files containing translation
  information.


  This package provides helper routines for dealing with translations in Fedora
  Modules.


  The URL to the standard Fedora Koji instance.


  Looks up which Fedora version the current Rawhide branch will become.


  Gets the list of tags for modules in a given Fedora branch. (For rawhide,
  make sure to use the value returned from get_fedora_rawhide_version.)


pkgId: 4a126c34d450ce0cb33abcc4b3aa4372ac7d4566a1e72b0f8ddd9e0c9f6375bd
name: python-MonkeyType
arch: src
version: 23.3.0
epoch: 0
release: 1
summary: Generating type annotations from sampled production types
url: https://github.com/Instagram/MonkeyType
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ae83135-3af0-46f8-98e7-c2b1f600cfd1
location_href: 00013734-python-monkeytype/python-MonkeyType-23.3.0-1.src.rpm
checksum_type: sha256
description:
  MonkeyType collects runtime types of function arguments and return values, and
  can automatically generate stub files or even add draft type annotations
  directly to your Python code based on the types collected at runtime.


pkgId: 329d9908d8ed3ce6756ea1c4d34099c31f7e88647c2586c025ac2f256bf560b4
name: python-Moose
arch: src
version: 0.9.8
epoch: 0
release: 1
summary: Your manager for endless iterative tasks.
url: https://github.com/muma378/moose
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6f73fdcb-2318-4745-936b-3096e90cf10f
location_href: 00004228-python-moose/python-Moose-0.9.8-1.src.rpm
checksum_type: sha256
description:
  Moose是一个数据处理的自动化框架，旨在提供一套快速、灵活、便捷、幂等式的数据处理方案。它不仅提供了常用的数据处理类和函数，也提供了一套命令行式的接口以处理和维护版本内单一、重复、繁琐的任务。
  - - - -

      * Python 2.7 or Python 3.3+
      * Works on Linux, Windows, Mac OSX, BSD



  The quick way:

      pip install moose

  For more details see the install section in the documentation:
  https://moose-datatang.readthedocs.io/zh_CN/latest/intro/install.html



  Documentation is available online at https://moose-datatang.readthedocs.io/zh_CN/latest/ and in the `docs`
  directory.



  You can find release notes at https://moose-datatang.readthedocs.io/zh_CN/latest/news.html


  See https://moose-datatang.readthedocs.io/zh_CN/latest/contributing.html


pkgId: 5cccf01ef580b12b855a84672b1c634f274aa7268cfb8ab9e474201c8c07fa5d
name: python-MouseInfo
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://github.com/asweigart/mouseinfo
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ef719d4c-8ec8-4b87-8b76-668233dade40
location_href: 00010136-python-mouseinfo/python-MouseInfo-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  An application to display XY position and RGB color information for the pixel currently under the mouse. Works on Python 2 and 3.

description:
  An application to display XY position and RGB color information for the pixel currently under the mouse. Works on Python 2 and 3. This is useful for GUI automation planning.
  The full documentation is at https://mouseinfo.readthedocs.io/en/latest/


pkgId: 5fa81ac194c02ad2f144821cb2c355a4e3a3eb66757840ff93f1fca3afb9e4dc
name: python-MultipartPostHandler2
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A handler for urllib2 to enable multipart form uploading
url: https://github.com/sergiomb2/MultipartPostHandler2/
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bd7b9e1b-a08c-409a-9280-32ffbed766e1
location_href: 00002861-python-MultipartPostHandler2/python-MultipartPostHandler2-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Usage:
    A handler for urllib2 to enable multipart/form-data for posting forms and uploading data.

  Inspirations:
    Upload files in python:
      http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306

  Example:
    import MultipartPostHandler, urllib2

    opener = urllib2.build_opener(MultipartPostHandler.MultipartPostHandler)
    params = { "username" : "bob", "password" : "riviera",
               "file" : open("filename", "rb") }
    opener.open("http://wwww.bobsite.com/upload/", params)

  Further Example:
    The main function of this file is a sample which downloads a page and
    then uploads it to the W3C validator.


pkgId: 203ff991800c8dee5f109212106418281948a2233cc9d9da3841098bab66b784
name: python-MutatorMath
arch: src
version: 3.0.1
epoch: 0
release: 1
url: https://github.com/LettError/MutatorMath
rpm_license: BSD 3 Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22882c70-1d95-454e-969c-6dce50dd8fdf
location_href: 00004262-python-mutatormath/python-MutatorMath-3.0.1-1.src.rpm
checksum_type: sha256
summary:
  Python for piecewise linear interpolation in multiple dimensions with multiple, arbitrarily placed, masters.

description:
     A MutatorMath Colorfield
  MutatorMath is a Python library for the calculation of piecewise linear
  interpolations in n-dimensions with any number of masters. It was
  developed for interpolating data related to fonts, but if can handle any
  arithmetic object.
  -  The **objects/** subpackage contains the general calculation tools.
  -  The **ufo/** subpackage contains tools to specifically process UFO
     data.
  -  MutatorMath has no user interface, just the math.


pkgId: 1793ca4406018b181b05f92c73ab80645513134bc283611a22bf326cd295b108
name: python-O365
arch: src
version: 2.0.26
epoch: 0
release: 1
summary: Microsoft Graph and Office 365 API made easy
url: https://github.com/O365/python-o365
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c5e44e1f-3175-4536-bee3-2c13bdd530c1
location_href: 00010649-python-o365/python-O365-2.0.26-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/O365)](https://pepy.tech/project/O365)
  [![PyPI](https://img.shields.io/pypi/v/O365.svg)](https://pypi.python.org/pypi/O365)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/O365.svg)](https://pypi.python.org/pypi/O365/)
  [![Build Status](https://travis-ci.org/O365/python-o365.svg?branch=master)](https://travis-ci.org/O365/python-o365)




  > Detailed usage documentation is [still in progress](https://o365.github.io/python-o365/latest/index.html)

  This project aims to make interacting with Microsoft Graph and Office 365 easy to do in a Pythonic way.
  Access to Email, Calendar, Contacts, OneDrive, etc. Are easy to do in a way that feel easy and straight forward to beginners and feels just right to seasoned python programmer.

  The project is currently developed and maintained by [Janscas](https://github.com/janscas).


  - [Janscas](https://github.com/janscas)
  - [Toben Archer](https://github.com/Narcolapser)
  - [Geethanadh](https://github.com/GeethanadhP)

  **We are always open to new pull requests!**


  - Install `sphinx` python library

      `pip install sphinx==2.2.2`

  - Run the shell script `build_docs.sh`, or copy the command from the file when using on windows




  ```python
  from O365 import Account

  credentials = ('client_id', 'client_secret')

  account = Account(credentials)
  m = account.new_message()
  m.to.add('to_example@example.com')
  m.subject = 'Testing!'
  m.body = "George Best quote: I've stopped drinking, but only while I'm asleep."
  m.send()
  ```



  - Almost Full Support for MsGraph and Office 365 Rest Api.
  - Good Abstraction layer between each Api. Change the api (Graph vs Office365) and don't worry about the api internal implementation.
  - Full oauth support with automatic handling of refresh tokens.
  - Automatic handling between local datetimes and server datetimes. Work with your local datetime and let this library do the rest.
  - Change between different resource with ease: access shared mailboxes, other users resources, SharePoint resources, etc.
  - Pagination support through a custom iterator that handles future requests automatically. Request Infinite items!
  - A query helper to help you build custom OData queries (filter, order, select and search).
  - Modular ApiComponents can be created and built to achieve further functionality.

  ___

  This project was also a learning resource for us. This is a list of not so common python idioms used in this project:
  - New unpacking technics: `def method(argument, *, with_name=None, **other_params):`
  - Enums: `from enum import Enum`
  - Factory paradigm
  - Package organization
  - Timezone conversion and timezone aware datetimes
  - Etc. ([see the code!](https://github.com/O365/python-o365/tree/master/O365))


  What follows is kind of a wiki...



  - [Install](#install)
  - [Usage](#usage)
  - [Authentication](#authentication)
  - [Protocols](#protocols)
  - [Account Class and Modularity](#account)
  - [MailBox](#mailbox)
  - [AddressBook](#addressbook)
  - [Directory and Users](#directory-and-users)
  - [Calendar](#calendar)
  - [Tasks](#tasks)
  - [OneDrive](#onedrive)
  - [Excel](#excel)
  - [SharePoint](#sharepoint)
  - [Planner](#planner)
  - [Outlook Categories](#outlook-categories)
  - [Utils](#utils)



  O365 is available on pypi.org. Simply run `pip install O365` to install it.

  Requirements: >= Python 3.4

  Project dependencies installed by pip:
   - requests
   - requests-oauthlib
   - beatifulsoup4
   - stringcase
   - python-dateutil
   - tzlocal
   - pytz



  The first step to be able to work with this library is to register an application and retrieve the auth token. See [Authentication](#authentication).

  It is highly recommended to add the "offline_access" permission and request this scope when authenticating. Otherwise the library will only have access to the user resources for 1 hour. See [Permissions and Scopes](#permissions-and-scopes).

  With the access token retrieved and stored you will be able to perform api calls to the service.

  A common pattern to check for authentication and use the library is this one:

  ```python
  scopes = ['my_required_scopes']  # you can use scope helpers here (see Permissions and Scopes section)

  account = Account(credentials)

  if not account.is_authenticated:  # will check if there is a token and has not expired
      
      
      account.authenticate(scopes=scopes)





  ```


  You can only authenticate using oauth athentication as Microsoft deprecated basic auth on November 1st 2018.

  There are currently three authentication methods:

  - [Authenticate on behalf of a user](https://docs.microsoft.com/en-us/graph/auth-v2-user?context=graph%2Fapi%2F1.0&view=graph-rest-1.0):
  Any user will give consent to the app to access it's resources.
  This oauth flow is called **authorization code grant flow**. This is the default authentication method used by this library.
  - [Authenticate on behalf of a user (public)](https://docs.microsoft.com/en-us/graph/auth-v2-user?context=graph%2Fapi%2F1.0&view=graph-rest-1.0):
  Same as the former but for public apps where the client secret can't be secured. Client secret is not required.
  - [Authenticate with your own identity](https://docs.microsoft.com/en-us/graph/auth-v2-service?context=graph%2Fapi%2F1.0&view=graph-rest-1.0):
  This will use your own identity (the app identity). This oauth flow is called **client credentials grant flow**.

      > 'Authenticate with your own identity' is not an allowed method for **Microsoft Personal accounts**.

  When to use one or the other and requirements:

    Topic                             | On behalf of a user *(auth_flow_type=='authorization')*  | On behalf of a user (public) *(auth_flow_type=='public')*  | With your own identity *(auth_flow_type=='credentials')*
   :---:                              | :---:                                                    | :---:                                                      | :---:
   **Register the App**               | Required                                                 | Required                                                   | Required
   **Requires Admin Consent**         | Only on certain advanced permissions                     | Only on certain advanced permissions                       | Yes, for everything
   **App Permission Type**            | Delegated Permissions (on behalf of the user)            | Delegated Permissions (on behalf of the user)              | Application Permissions
   **Auth requirements**              | Client Id, Client Secret, Authorization Code             | Client Id, Authorization Code                              | Client Id, Client Secret
   **Authentication**                 | 2 step authentication with user consent                  | 2 step authentication with user consent                    | 1 step authentication
   **Auth Scopes**                    | Required                                                 | Required                                                   | None
   **Token Expiration**               | 60 Minutes without refresh token or 90 days*             | 60 Minutes without refresh token or 90 days*               | 60 Minutes*
   **Login Expiration**               | Unlimited if there is a refresh token and as long as a re| Unlimited if there is a refresh token and as long as a refresh is done within the 90 days          | Unlimited
   **Resources**                      | Access the user resources, and any shared resources      | Access the user resources, and any shared resources        | All Azure AD users the app has access to
   **Microsoft Account Type**         | Any                                                      | Any                                                        | Not Allowed for Personal Accounts
   **Tenant ID Required**             | Defaults to "common"                                     | Defaults to "common"                                       | Required (can't be "common")

  **O365 will automatically refresh the token for you on either authentication method. The refresh token lasts 90 days but it's refreshed on each connection so as long as you connect within 90 days you can have unlimited access.*

  The `Connection` Class handles the authentication.



  This section is explained using Microsoft Graph Protocol, almost the same applies to the Office 365 REST API.


  1. To allow authentication you first need to register your application at [Azure App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade).

      1. Login at [Azure Portal (App Registrations)](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade)
      1. Create an app. Set a name.
      1. In Supported account types choose "Accounts in any organizational directory and personal Microsoft accounts (e.g. Skype, Xbox, Outlook.com)", if you are using a personal account.
      1. Set the redirect uri (Web) to: `https://login.microsoftonline.com/common/oauth2/nativeclient` and click register. This needs to be inserted into the "Redirect URI" text box as simply checking the check box next to this link seems to be insufficent. This is the default redirect uri used by this library, but you can use any other if you want.
      1. Write down the Application (client) ID. You will need this value.
      1. Under "Certificates & secrets", generate a new client secret. Set the expiration preferably to never. Write down the value of the client secret created now. It will be hidden later on.
      1. Under Api Permissions:
          - When authenticating "on behalf of a user":
              1. add the **delegated permissions** for Microsoft Graph you want (see scopes).
              1. It is highly recommended to add "offline_access" permission. If not the user you will have to re-authenticate every hour.
          - When authenticating "with your own identity":
              1. add the **application permissions** for Microsoft Graph you want.
              1. Click on the Grant Admin Consent button (if you have admin permissions) or wait until the admin has given consent to your application.

          As an example, to read and send emails use:
          1. Mail.ReadWrite
          1. Mail.Send
          1. User.Read

  1. Then you need to login for the first time to get the access token that will grant access to the user resources.

      To authenticate (login) you can use [different authentication interfaces](#different-authentication-interfaces). On the following examples we will be using the Console Based Interface but you can use any one.

      - When authenticating on behalf of a user:

          > **Important:** In case you can't secure the client secret you can use the auth flow type 'public' which only requires the client id.

          1. Instantiate an `Account` object with the credentials (client id and client secret).
          1. Call `account.authenticate` and pass the scopes you want (the ones you previously added on the app registration portal).

              > Note: when using the "on behalf of a user" authentication, you can pass the scopes to either the `Account` init or to the authenticate method. Either way is correct.

              You can pass "protocol scopes" (like: "https://graph.microsoft.com/Calendars.ReadWrite") to the method or use "[scope helpers](https://github.com/O365/python-o365/blob/master/O365/connection.py#L34)" like ("message_all").
              If you pass protocol scopes, then the `account` instance must be initialized with the same protocol used by the scopes. By using scope helpers you can abstract the protocol from the scopes and let this library work for you.
              Finally, you can mix and match "protocol scopes" with "scope helpers".
              Go to the [procotol section](#protocols) to know more about them.

              For Example (following the previous permissions added):

              ```python
              from O365 import Account
              credentials = ('my_client_id', 'my_client_secret')

              
              

              account = Account(credentials)
              if account.authenticate(scopes=['basic', 'message_all']):
                 print('Authenticated!')

              
              
              ```
              When using the "on behalf of the user" authentication method, this method call will print a url that the user must visit to give consent to the app on the required permissions.

              The user must then visit this url and give consent to the application. When consent is given, the page will rediret to: "https://login.microsoftonline.com/common/oauth2/nativeclient" by default (you can change this) with a url query param called 'code'.

              Then the user must copy the resulting page url and paste it back on the console.
              The method will then return True if the login attempt was succesful.

      - When authenticating with your own identity:

          1. Instantiate an `Account` object with the credentials (client id and client secret), specifying the parameter `auth_flow_type` to *"credentials"*. You also need to provide a 'tenant_id'. You don't need to specify any scopes.
          1. Call `account.authenticate`. This call will request a token for you and store it in the backend. No user interaction is needed. The method will store the token in the backend and return True if the authentication succeeded.

              For Example:
              ```python
              from O365 import Account

              credentials = ('my_client_id', 'my_client_secret')

              

              account = Account(credentials, auth_flow_type='credentials', tenant_id='my-tenant-id')
              if account.authenticate():
                 print('Authenticated!')
              ```

  1. At this point you will have an access token stored that will provide valid credentials when using the api.

      The access token only lasts **60 minutes**, but the app try will automatically request new access tokens.

      When using the "on behalf of a user" authentication method this is accomplished through the refresh tokens (if and only if you added the "offline_access" permission), but note that a refresh token only lasts for 90 days. So you must use it before or you will need to request a new access token again (no new consent needed by the user, just a login).
      If your application needs to work for more than 90 days without user interaction and without interacting with the API, then you must implement a periodic call to `Connection.refresh_token` before the 90 days have passed.

      **Take care: the access (and refresh) token must remain protected from unauthorized users.**

      Under the "on behalf of a user" authentication method, if you change the scope requested, then the current token won't work, and you will need the user to give consent again on the application to gain access to the new scopes requested.




  To acomplish the authentication you can basically use different approaches.
  The following apply to the "on behalf of a user" authentication method as this is 2-step authentication flow.
  For the "with your own identity" authentication method, you can just use `account.authenticate` as it's not going to require a console input.

  1. Console based authentication interface:

      You can authenticate using a console. The best way to achieve this is by using the `authenticate` method of the `Account` class.

      ```python
      account = Account(credentials)
      account.authenticate(scopes=['basic', 'message_all'])
      ```

      The `authenticate` method will print into the console a url that you will have to visit to achieve authentication.
      Then after visiting the link and authenticate you will have to paste back the resulting url into the console.
      The method will return `True` and print a message if it was succesful.

      **Tip:** When using MacOs the console is limited to 1024 characters. If your url has multiple scopes it can exceed this limit. To solve this. Just `import readline` a the top of your script.

  1. Web app based authentication interface:

      You can authenticate your users in a web environment by following this steps:

      1. First ensure you are using an appropiate TokenBackend to store the auth tokens (See Token storage below).
      1. From a handler redirect the user to the Microsoft login url. Provide a callback. Store the state.
      1. From the callback handler complete the authentication with the state and other data.

      The following example is done using Flask.
      ```python
      @route('/stepone')
      def auth_step_one():

          callback = 'my absolute url to auth_step_two_callback'
          account = Account(credentials)
          url, state = account.con.get_authorization_url(requested_scopes=my_scopes,
                                                         redirect_uri=callback)

          
          my_db.store_state(state) # example...

          return redirect(url)

      @route('/steptwo')
      def auth_step_two_callback():
          account = Account(credentials)

          
          my_saved_state = my_db.get_state()  # example...

          
          callback = 'my absolute url to auth_step_two_callback'

          result = account.con.request_token(request.url,
                                             state=my_saved_state,
                                             redirect_uri=callback)
          
          
          if result:
              return render_template('auth_complete.html')
          
      ```

  1. Other authentication interfaces:

      Finally you can configure any other flow by using `connection.get_authorization_url` and `connection.request_token` as you want.






  When using oauth, you create an application and allow some resources to be accessed and used by its users.
  These resources are managed with permissions. These can either be delegated (on behalf of a user) or aplication permissions.
  The former are used when the authentication method is "on behalf of a user". Some of these require administrator consent.
  The latter when using the "with your own identity" authentication method. All of these require administrator consent.



  The scopes only matter when using the "on behalf of a user" authentication method.

  > Note: You only need the scopes when login as those are kept stored within the token on the token backend.

  The user of this library can then request access to one or more of this resources by providing scopes to the oauth provider.

  > Note: If you latter on change the scopes requested, the current token will be invaled and you will have to re-authenticate. The user that logins will be asked for consent.

  For example your application can have Calendar.Read, Mail.ReadWrite and Mail.Send permissions, but the application can request access only to the Mail.ReadWrite and Mail.Send permission.
  This is done by providing scopes to the `Account` instance or `account.authenticate` method like so:

  ```python
  from O365 import Account

  credentials = ('client_id', 'client_secret')

  scopes = ['https://graph.microsoft.com/Mail.ReadWrite', 'https://graph.microsoft.com/Mail.Send']

  account = Account(credentials, scopes=scopes)
  account.authenticate()




  ```

  Scope implementation depends on the protocol used. So by using protocol data you can automatically set the scopes needed.
  This is implemented by using 'scope helpers'. Those are little helpers that group scope functionality and abstract the protocol used.

  Scope Helper                       | Scopes included
  :---                               | :---
  basic                              | 'offline_access' and 'User.Read'
  mailbox                            | 'Mail.Read'
  mailbox_shared                     | 'Mail.Read.Shared'
  mailbox_settings                   | 'MailboxSettings.ReadWrite'
  message_send                       | 'Mail.Send'
  message_send_shared                | 'Mail.Send.Shared'
  message_all                        | 'Mail.ReadWrite' and 'Mail.Send'
  message_all_shared                 | 'Mail.ReadWrite.Shared' and 'Mail.Send.Shared'
  address_book                       | 'Contacts.Read'
  address_book_shared                | 'Contacts.Read.Shared'
  address_book_all                   | 'Contacts.ReadWrite'
  address_book_all_shared            | 'Contacts.ReadWrite.Shared'
  calendar                           | 'Calendars.Read'
  calendar_shared                    | 'Calendars.Read.Shared'
  calendar_all                       | 'Calendars.ReadWrite'
  calendar_shared_all                | 'Calendars.ReadWrite.Shared'
  tasks                              | 'Tasks.Read'
  tasks_all                          | 'Tasks.ReadWrite'
  users                              | 'User.ReadBasic.All'
  onedrive                           | 'Files.Read.All'
  onedrive_all                       | 'Files.ReadWrite.All'
  sharepoint                         | 'Sites.Read.All'
  sharepoint_dl                      | 'Sites.ReadWrite.All'


  You can get the same scopes as before using protocols and scope helpers like this:

  ```python
  protocol_graph = MSGraphProtocol()

  scopes_graph = protocol.get_scopes_for('message all')


  account = Account(credentials, scopes=scopes_graph)
  ```

  ```python
  protocol_office = MSOffice365Protocol()

  scopes_office = protocol.get_scopes_for('message all')


  account = Account(credentials, scopes=scopes_office)
  ```

  > Note: When passing scopes at the `Account` initialization or on the `account.authenticate` method, the scope helpers are autommatically converted to the protocol flavor.
  >Those are the only places where you can use scope helpers. Any other object using scopes (such as the `Connection` object) expects scopes that are already set for the protocol.




  When authenticating you will retrieve oauth tokens. If you don't want a one time access you will have to store the token somewhere.
  O365 makes no assumptions on where to store the token and tries to abstract this from the library usage point of view.

  You can choose where and how to store tokens by using the proper Token Backend.

  **Take care: the access (and refresh) token must remain protected from unauthorized users.**

  The library will call (at different stages) the token backend methods to load and save the token.

  Methods that load tokens:
  - `account.is_authenticated` property will try to load the token if is not already loaded.
  - `connection.get_session`: this method is called when there isn't a request session set. By default it will not try to load the token. Set `load_token=True` to load it.

  Methods that stores tokens:
  - `connection.request_token`: by default will store the token, but you can set `store_token=False` to avoid it.
  - `connection.refresh_token`: by default will store the token. To avoid it change `connection.store_token` to False. This however it's a global setting (that only affects the `refresh_token` method). If you only want the next refresh operation to not store the token you will have to set it back to True afterwards.

  To store the token you will have to provide a properly configured TokenBackend.

  Actually there are only two implemented (but you can easely implement more like a CookieBackend, RedisBackend, etc.):
  - `FileSystemTokenBackend` (Default backend): Stores and retrieves tokens from the file system. Tokens are stored as files.
  - `FirestoreTokenBackend`: Stores and retrives tokens from a Google Firestore Datastore. Tokens are stored as documents within a collection.

  For example using the FileSystem Token Backend:

  ```python
  from O365 import Account, FileSystemTokenBackend

  credentials = ('id', 'secret')



  token_backend = FileSystemTokenBackend(token_path='my_folder', token_filename='my_token.txt')
  account = Account(credentials, token_backend=token_backend)




  ```

  And now using the same example using FirestoreTokenBackend:

  ```python
  from O365 import Account
  from O365.utils import FirestoreBackend
  from google.cloud import firestore

  credentials = ('id', 'secret')



  user_id = 'whatever the user id is'  # used to create the token document id
  document_id = 'token_{}'.format(user_id)  # used to uniquely store this token
  token_backend = FirestoreBackend(client=firestore.Client(), collection='tokens', doc_id=document_id)
  account = Account(credentials, token_backend=token_backend)




  ```

  To implement a new TokenBackend:

   1. Subclass `BaseTokenBackend`
   1. Implement the following methods:

       - `__init__` (don't forget to call `super().__init__`)
       - `load_token`: this should load the token from the desired backend and return a `Token` instance or None
       - `save_token`: this should store the `self.token` in the desired backend.
       - Optionally you can implement: `check_token`, `delete_token` and `should_refresh_token`

  The `should_refresh_token` method is intended to be implemented for environments where multiple Connection instances are running on paralel.
  This method should check if it's time to refresh the token or not.
  The chosen backend can store a flag somewhere to answer this question.
  This can avoid race conditions between different instances trying to refresh the token at once, when only one should make the refresh.
  The method should return three posible values:
  - **True**: then the Connection will refresh the token.
  - **False**: then the Connection will NOT refresh the token.
  - **None**: then this method already executed the refresh and therefore the Connection does not have to.

  By default this always returns True as it's asuming there is are no parallel connections running at once.

  There are two examples of this method in the examples folder [here](https://github.com/O365/python-o365/blob/master/examples/token_backends.py).



  Protocols handles the aspects of communications between different APIs.
  This project uses either the Microsoft Graph APIs (by default) or the Office 365 APIs.
  But, you can use many other Microsoft APIs as long as you implement the protocol needed.

  You can use one or the other:

  - `MSGraphProtocol` to use the [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/docs/concepts/overview)
  - `MSOffice365Protocol` to use the [Office 365 API](https://msdn.microsoft.com/en-us/office/office365/api/api-catalog)

  Both protocols are similar but consider the following:

  Reasons to use `MSGraphProtocol`:
  - It is the recommended Protocol by Microsoft.
  - It can access more resources over Office 365 (for example OneDrive)

  Reasons to use `MSOffice365Protocol`:
  - It can send emails with attachments up to 150 MB. MSGraph only allows 4MB on each request (UPDATE: Starting 22 October'19 you can [upload files up to 150MB with MSGraphProtocol **beta** version](https://developer.microsoft.com/en-us/office/blogs/attaching-large-files-to-outlook-messages-in-microsoft-graph-preview/))

  The default protocol used by the `Account` Class is `MSGraphProtocol`.

  You can implement your own protocols by inheriting from `Protocol` to communicate with other Microsoft APIs.

  You can instantiate and use protocols like this:
  ```python
  from O365 import Account, MSGraphProtocol  # same as from O365.connection import MSGraphProtocol




  protocol = MSGraphProtocol(api_version='beta')  # MSGraphProtocol defaults to v1.0 api version
  account = Account(credentials, protocol=protocol)
  ```


  Each API endpoint requires a resource. This usually defines the owner of the data.
  Every protocol defaults to resource 'ME'. 'ME' is the user which has given consent, but you can change this behaviour by providing a different default resource to the protocol constructor.

  > Note: When using the "with your own identity" authentication method the resource 'ME' is overwritten to be blank as the authentication method already states that you are login with your own identity.

  For example when accessing a shared mailbox:


  ```python

  account = Account(credentials=my_credentials, main_resource='shared_mailbox@example.com')

  ```

  This can be done however at any point. For example at the protocol level:
  ```python

  protocol = MSGraphProtocol(default_resource='shared_mailbox@example.com')

  account = Account(credentials=my_credentials, protocol=protocol)


  shared_mailbox_messages = account.mailbox().get_messages()
  ```

  Instead of defining the resource used at the account or protocol level, you can provide it per use case as follows:
  ```python

  account = Account(credentials=my_credentials)  # account defaults to 'ME' resource

  mailbox = account.mailbox('shared_mailbox@example.com')  # mailbox is using 'shared_mailbox@example.com' resource instead of 'ME'



  message = Message(parent=account, main_resource='shared_mailbox@example.com')  # message is using 'shared_mailbox@example.com' resource
  ```

  Usually you will work with the default 'ME' resource, but you can also use one of the following:

  - **'me'**: the user which has given consent. the default for every protocol. Overwritten when using "with your own identity" authentication method (Only available on the authorization auth_flow_type).
  - **'user:user@domain.com'**: a shared mailbox or a user account for which you have permissions. If you don't provide 'user:' will be infered anyways.
  - **'site:sharepoint-site-id'**: a sharepoint site id.
  - **'group:group-site-id'**: a office365 group id.

  By setting the resource prefix (such as **'user:'** or **'group:'**) you help the library understand the type of resource. You can also pass it like 'users/example@exampl.com'. Same applies to the other resource prefixes.



  Usually you will only need to work with the `Account` Class. This is a wrapper around all functionality.

  But you can also work only with the pieces you want.

  For example, instead of:
  ```python
  from O365 import Account

  account = Account(('client_id', 'client_secret'))
  message = account.new_message()

  mailbox = account.mailbox()

  ```

  You can work only with the required pieces:

  ```python
  from O365 import Connection, MSGraphProtocol
  from O365.message import Message
  from O365.mailbox import MailBox

  protocol = MSGraphProtocol()
  scopes = ['...']
  con = Connection(('client_id', 'client_secret'), scopes=scopes)

  message = Message(con=con, protocol=protocol)

  mailbox = MailBox(con=con, protocol=protocol)
  message2 = Message(parent=mailbox)  # message will inherit the connection and protocol from mailbox when using parent.

  ```

  It's also easy to implement a custom Class.

  Just Inherit from `ApiComponent`, define the endpoints, and use the connection to make requests. If needed also inherit from Protocol to handle different comunications aspects with the API server.

  ```python
  from O365.utils import ApiComponent

  class CustomClass(ApiComponent):
      _endpoints = {'my_url_key': '/customendpoint'}

      def __init__(self, *, parent=None, con=None, **kwargs):
          
          self.con = parent.con if parent else con
          protocol = parent.protocol if parent else kwargs.get('protocol')
          main_resource = parent.main_resource

          super().__init__(protocol=protocol, main_resource=main_resource)
          

      def do_some_stuff(self):

          
          
          url = self.build_url(self._endpoints.get('my_url_key'))

          my_params = {'param1': 'param1'}

          response = self.con.get(url, params=my_params)  # note the use of the connection here.

          


  from O365 import Connection, MSGraphProtocol

  protocol = MSGraphProtocol()  # or maybe a user defined protocol
  con = Connection(('client_id', 'client_secret'), scopes=protocol.get_scopes_for(['...']))
  custom_class = CustomClass(con=con, protocol=protocol)

  custom_class.do_some_stuff()
  ```


  Mailbox groups the funcionality of both the messages and the email folders.

  These are the scopes needed to work with the `MailBox` and `Message` classes.

   Raw Scope                   |  Included in Scope Helper                  | Description
   :---:                       |  :---:                                     | ---
   *Mail.Read*                 |  *mailbox*                                 | To only read my mailbox
   *Mail.Read.Shared*          |  *mailbox_shared*                          | To only read another user / shared mailboxes
   *Mail.Send*                 |  *message_send, message_all*               | To only send message
   *Mail.Send.Shared*          |  *message_send_shared, message_all_shared* | To only send message as another user / shared mailbox
   *Mail.ReadWrite*            |  *message_all*                             | To read and save messages in my mailbox
   *MailboxSettings.ReadWrite* |  *mailbox_settings*                        | To read and write suer mailbox settings

  ```python
  mailbox = account.mailbox()

  inbox = mailbox.inbox_folder()

  for message in inbox.get_messages():
      print(message)

  sent_folder = mailbox.sent_folder()

  for message in sent_folder.get_messages():
      print(message)

  m = mailbox.new_message()

  m.to.add('to_example@example.com')
  m.body = 'George Best quote: In 1969 I gave up women and alcohol - it was the worst 20 minutes of my life.'
  m.save_draft()
  ```


  Represents a `Folder` within your email mailbox.

  You can get any folder in your mailbox by requesting child folders or filtering by name.

  ```python
  mailbox = account.mailbox()

  archive = mailbox.get_folder(folder_name='archive')  # get a folder with 'archive' name

  child_folders = archive.get_folders(25) # get at most 25 child folders of 'archive' folder

  for folder in child_folders:
      print(folder.name, folder.parent_id)

  new_folder = archive.create_child_folder('George Best Quotes')
  ```


  An email object with all its data and methods.

  Creating a draft message is as easy as this:
  ```python
  message = mailbox.new_message()
  message.to.add(['example1@example.com', 'example2@example.com'])
  message.sender.address = 'my_shared_account@example.com'  # changing the from address
  message.body = 'George Best quote: I might go to Alcoholics Anonymous, but I think it would be difficult for me to remain anonymous'
  message.attachments.add('george_best_quotes.txt')
  message.save_draft()  # save the message on the cloud as a draft in the drafts folder
  ```

  Working with saved emails is also easy:
  ```python
  query = mailbox.new_query().on_attribute('subject').contains('george best')  # see Query object in Utils
  messages = mailbox.get_messages(limit=25, query=query)

  message = messages[0]  # get the first one

  message.mark_as_read()
  reply_msg = message.reply()

  if 'example@example.com' in reply_msg.to:  # magic methods implemented
      reply_msg.body = 'George Best quote: I spent a lot of money on booze, birds and fast cars. The rest I just squandered.'
  else:
      reply_msg.body = 'George Best quote: I used to go missing a lot... Miss Canada, Miss United Kingdom, Miss World.'

  reply_msg.send()
  ```


  You can send inline images by doing this:

  ```python

  msg = account.new_message()
  msg.to.add('george@best.com')
  msg.attachments.add('my_image.png')
  att = msg.attachments[0]  # get the attachment object


  att.is_inline = True
  att.content_id = 'image.png'


  body = """
      <html>
          <body>
              <strong>There should be an image here:</strong>
              <p>
                  <img src="cid:image.png">
              </p>
          </body>
      </html>
      """
  msg.body = body
  msg.send()
  ```


  You can retrieve message headers by doing this:

  ```python

  mb = account.mailbox()
  msg = mb.get_message(query=mb.q().select('internet_message_headers'))
  print(msg.message_headers)  # returns a list of dicts.
  ```

  Note that only message headers and other properties added to the select statement will be present.


  Messages and attached messages can be saved as *.eml.

   - Save message as "eml":
      ```python
          msg.save_as_eml(to_path=Path('my_saved_email.eml'))
      ```
  - Save attached message as "eml":

      Carefull: there's no way to identify that an attachment is in fact a message. You can only check if the attachment.attachment_type == 'item'.
      if is of type "item" then it can be a message (or an event, etc...). You will have to determine this yourself.

      ```python
          msg_attachment = msg.attachments[0]  # the first attachment is attachment.attachment_type == 'item' and I know it's a message.
          msg.attachments.save_as_eml(msg_attachment, to_path=Path('my_saved_email.eml'))
      ```


  The mailbox settings and associated methods.

  Retrieve and update mailbox auto reply settings:
  ```python
  from O365.mailbox import AutoReplyStatus, ExternalAudience

  mailboxsettings = mailbox.get_settings()
  ars = mailboxsettings.automaticrepliessettings

  ars.scheduled_startdatetime = start # Sets the start date/time
  ars.scheduled_enddatetime = end # Sets the end date/time
  ars.status = AutoReplyStatus.SCHEDULED # DISABLED/SCHEDULED/ALWAYSENABLED - Uses start/end date/time if scheduled.
  ars.external_audience = ExternalAudience.NONE # NONE/CONTACTSONLY/ALL
  ars.internal_reply_message = "ARS Internal" # Internal message
  ars.external_reply_message = "ARS External" # External message
  mailboxsettings.save()
  ```

  Alternatively to enable and disable
  ```python
  mailboxsettings.save()

  mailbox.set_automatic_reply(
      "Internal",
      "External",
      scheduled_start_date_time=start, # Status will be 'scheduled' if start/end supplied, otherwise 'alwaysEnabled'
      scheduled_end_date_time=end,
      externalAudience=ExternalAudience.NONE, # Defaults to ALL
  )
  mailbox.set_disable_reply()
  ```


  AddressBook groups the functionality of both the Contact Folders and Contacts. Outlook Distribution Groups are not supported (By the Microsoft API's).

  These are the scopes needed to work with the `AddressBook` and `Contact` classes.

   Raw Scope                       |  Included in Scope Helper                        | Description
   :---:                           |  :---:                                          | ---
   *Contacts.Read*                 |  *address_book*                                 | To only read my personal contacts
   *Contacts.Read.Shared*          |  *address_book_shared*                          | To only read another user / shared mailbox contacts
   *Contacts.ReadWrite*            |  *address_book_all*                             | To read and save personal contacts
   *Contacts.ReadWrite.Shared*     |  *address_book_all_shared*                      | To read and save contacts from another user / shared mailbox
   *User.ReadBasic.All*            |  *users*                                        | To only read basic properties from users of my organization (User.Read.All requires administrator consent).


  Represents a Folder within your Contacts Section in Office 365.
  AddressBook class represents the parent folder (it's a folder itself).

  You can get any folder in your address book by requesting child folders or filtering by name.

  ```python
  address_book = account.address_book()

  contacts = address_book.get_contacts(limit=None)  # get all the contacts in the Personal Contacts root folder

  work_contacts_folder = address_book.get_folder(folder_name='Work Contacts')  # get a folder with 'Work Contacts' name

  message_to_all_contats_in_folder = work_contacts_folder.new_message()  # creates a draft message with all the contacts as recipients

  message_to_all_contats_in_folder.subject = 'Hallo!'
  message_to_all_contats_in_folder.body = """
  George Best quote:

  If you'd given me the choice of going out and beating four men and smashing a goal in
  from thirty yards against Liverpool or going to bed with Miss World,
  it would have been a difficult choice. Luckily, I had both.
  """
  message_to_all_contats_in_folder.send()


  child_folders = address_book.get_folders(25) # get at most 25 child folders

  for folder in child_folders:
      print(folder.name, folder.parent_id)


  address_book.create_child_folder('new folder')
  ```


  Office 365 API (Nor MS Graph API) has no concept such as the Outlook Global Address List.
  However you can use the [Users API](https://developer.microsoft.com/en-us/graph/docs/api-reference/v1.0/resources/users) to access all the users within your organization.

  Without admin consent you can only access a few properties of each user such as name and email and litte more.
  You can search by name or retrieve a contact specifying the complete email.

  - Basic Permision needed is Users.ReadBasic.All (limit info)
  - Full Permision is Users.Read.All but needs admin consent.

  To search the Global Address List (Users API):

  ```python
  global_address_list = account.directory()





  q = global_address_list.new_query('display_name')
  q.startswith('George Best')

  for user in global_address_list.get_users(query=q):
      print(user)
  ```


  To retrieve a contact by their email:

  ```python
  contact = global_address_list.get_user('example@example.com')
  ```


  Everything returned from an `AddressBook` instance is a `Contact` instance.
  Contacts have all the information stored as attributes

  Creating a contact from an `AddressBook`:

  ```python
  new_contact = address_book.new_contact()

  new_contact.name = 'George Best'
  new_contact.job_title = 'football player'
  new_contact.emails.add('george@best.com')

  new_contact.save()  # saved on the cloud

  message = new_contact.new_message()  #  Bonus: send a message to this contact



  new_contact.delete()  # Bonus: deteled from the cloud
  ```



  The Directory object can retrieve users.

  A User instance contains by default the [basic properties of the user](https://docs.microsoft.com/en-us/graph/api/user-list?view=graph-rest-1.0&tabs=http#optional-query-parameters).
  If you want to include more, you will have to select the desired properties manually.

  Check [The Global Address List](#the-global-address-list) for further information.

  ```python
  directory = account.directory()
  for user in directory.get_users():
      print(user)
  ```



  The calendar and events functionality is group in a `Schedule` object.

  A `Schedule` instance can list and create calendars. It can also list or create events on the default user calendar.
  To use other calendars use a `Calendar` instance.

  These are the scopes needed to work with the `Schedule`, `Calendar` and `Event` classes.

   Raw Scope                        |  Included in Scope Helper                        | Description
   :---:                            |  :---:                                          | ---
   *Calendars.Read*                 |  *calendar*                                     | To only read my personal calendars
   *Calendars.Read.Shared*          |  *calendar_shared*                              | To only read another user / shared mailbox calendars
   *Calendars.ReadWrite*            |  *calendar_all*                                 | To read and save personal calendars
   *Calendars.ReadWrite.Shared*     |  *calendar_shared_all*                          | To read and save calendars from another user / shared mailbox


  Working with the `Schedule` instance:
  ```python
  import datetime as dt


  schedule = account.schedule()

  calendar = schedule.get_default_calendar()
  new_event = calendar.new_event()  # creates a new unsaved event
  new_event.subject = 'Recruit George Best!'
  new_event.location = 'England'




  new_event.start = dt.datetime(2019, 9, 5, 19, 45)


  new_event.recurrence.set_daily(1, end=dt.datetime(2019, 9, 10))
  new_event.remind_before_minutes = 45

  new_event.save()
  ```

  Working with `Calendar` instances:

  ```python
  calendar = schedule.get_calendar(calendar_name='Birthdays')

  calendar.name = 'Football players birthdays'
  calendar.update()

  q = calendar.new_query('start').greater_equal(dt.datetime(2018, 5, 20))
  q.chain('and').on_attribute('end').less_equal(dt.datetime(2018, 5, 24))

  birthdays = calendar.get_events(query=q, include_recurring=True)  # include_recurring=True will include repeated events on the result set.

  for event in birthdays:
      if event.subject == 'George Best Birthday':
          
          event.accept("I'll attend!")  # send a response accepting
      else:
          event.decline("No way I'm comming, I'll be in Spain", send_response=False)  # decline the event but don't send a reponse to the organizer
  ```



  1. Include_recurring=True:
      > It's important to know that when querying events with `include_recurring=True` (which is the default), it is required that you must provide a query parameter with the start and end attributes defined.
      > Unlike when using `include_recurring=False` those attributes will NOT filter the data based on the operations you set on the query (greater_equal, less, etc.) but just filter the events start datetime between the provided start and end datetimes.

  1. Shared Calendars:

      There are some known issues when working with [shared calendars](https://docs.microsoft.com/en-us/graph/known-issues#calendars) in Microsoft Graph.

  1. Event attachments:

      For some unknow reason, microsoft does not allow to upload an attachment at the event creation time (as opposed with message attachments).
      See [this](https://stackoverflow.com/questions/46438302/office365-rest-api-creating-a-calendar-event-with-attachments?rq=1).
      So, to upload attachments to Events, first save the event, then attach the message and save again.



  The tasks functionality is grouped in a `ToDo` object.

  A `ToDo` instance can list and create task folders. It can also list or create tasks on the default user folder. To use other folders use a `Folder` instance.

  These are the scopes needed to work with the `ToDo`, `Folder` and `Task` classes.

   Raw Scope                        |  Included in Scope Helper                       | Description
   :---:                            |  :---:                                          | ---
   *Tasks.Read*                     |  *tasks*                                        | To only read my personal tasks
   *Tasks.ReadWrite*                |  *tasks_all*                                    | To read and save personal calendars

   Working with the `ToDo` instance:
  ```python
  import datetime as dt


  todo = account.tasks()


  folder = todo.get_default_folder()
  new_task = folder.new_task()  # creates a new unsaved task
  new_task.subject = 'Send contract to George Best'
  new_task.due = dt.datetime(2020, 9, 25, 18, 30)
  new_task.save()



  new_task.mark_completed()
  new_task.save()





  ```

  Working with `Folder` instances:

  ```python

  new_folder = todo.new_folder('Defenders')


  folder = todo.get_folder(folder_name='Strikers')
  folder.name = 'Forwards'
  folder.update()


  task_list = folder.get_tasks()
  for task in task_list:
      print(task)
      print('')
  ```


  The `Storage` class handles all functionality around One Drive and Document Library Storage in SharePoint.

  The `Storage` instance allows to retrieve `Drive` instances which handles all the Files and Folders from within the selected `Storage`.
  Usually you will only need to work with the default drive. But the `Storage` instances can handle multiple drives.

  A `Drive` will allow you to work with Folders and Files.

  These are the scopes needed to work with the `Storage`, `Drive` and `DriveItem` classes.

   Raw Scope                  |  Included in Scope Helper     | Description
   :---:                      |  :---:                       | ---
   *Files.Read*               |                              | To only read my files
   *Files.Read.All*           |  *onedrive*                  | To only read all the files the user has access
   *Files.ReadWrite*          |                              | To read and save my files
   *Files.ReadWrite.All*      |  *onedrive_all*              | To read and save all the files the user has access


  ```python
  account = Account(credentials=my_credentials)

  storage = account.storage()  # here we get the storage instance that handles all the storage options.


  drives = storage.get_drives()


  my_drive = storage.get_default_drive()  # or get_drive('drive-id')


  root_folder = my_drive.get_root_folder()
  attachments_folder = my_drive.get_special_folder('attachments')


  for item in root_folder.get_items(limit=25):
      if item.is_folder:
          print(list(item.get_items(2)))  # print the first to element on this folder.
      elif item.is_file:
          if item.is_photo:
              print(item.camera_model)  # print some metadata of this photo
          elif item.is_image:
              print(item.dimensions)  # print the image dimensions
          else:
              
              print(item.mime_type)  # print the mime type
  ```

  Both Files and Folders are DriveItems. Both Image and Photo are Files, but Photo is also an Image. All have some different methods and properties.
  Take care when using 'is_xxxx'.

  When copying a DriveItem the api can return a direct copy of the item or a pointer to a resource that will inform on the progress of the copy operation.

  ```python


  documents_folder = my_drive.get_special_folder('documents')

  files = my_drive.search('george best quotes', limit=1)

  if files:
      george_best_quotes = files[0]
      operation = george_best_quotes.copy(target=documents_folder)  # operation here is an instance of CopyOperation

      
      
      for status, progress in operation.check_status():  # if it's an async operations, this will request to the api for the status in every loop
          print('{} - {}'.format(status, progress))  # prints 'in progress - 77.3' until finally completed: 'completed - 100.0'
      copied_item = operation.get_item()  # the copy operation is completed so you can get the item.
      if copied_item:
          copied_item.delete()  # ... oops!
  ```

  You can also work with share permissions:

  ```python
  current_permisions = file.get_permissions()  # get all the current permissions on this drive_item (some may be inherited)


  permission = file.share_with_link(share_type='edit')
  if permission:
      print(permission.share_link)  # the link you can use to share this drive item

  permission = file.share_with_invite(recipients='george_best@best.com', send_email=True, message='Greetings!!', share_type='edit')
  if permission:
      print(permission.granted_to)  # the person you share this item with
  ```

  You can also:
  ```python

  file.download(to_path='/quotes/')





  uploaded_file = folder.upload_file(item='path_to_my_local_file')


  versions = file.get_versions()
  for version in versions:
      if version.name == '2.0':
          version.restore()  # restore the version 2.0 of this file


  ```



  You can interact with new excel files (.xlsx) stored in OneDrive or a SharePoint Document Library.
  You can retrieve workbooks, worksheets, tables, and even cell data.
  You can also write to any excel online.

  To work with excel files, first you have to retrieve a `File` instance using the OneDrive or SharePoint functionallity.

  The scopes needed to work with the `WorkBook` and Excel related classes are the same used by OneDrive.

  This is how you update a cell value:

  ```python
  from O365.excel import WorkBook


  excel_file = WorkBook(my_file_instance)  # my_file_instance should be an instance of File.

  ws = excel_file.get_worksheet('my_worksheet')
  cella1 = ws.get_range('A1')
  cella1.values = 35
  cella1.update()
  ```


  When interacting with excel, you can use a workbook session to efficiently make changes in a persistent or nonpersistent way.
  This sessions become usefull if you perform numerous changes to the excel file.

  The default is to use a session in a persistent way.
  Sessions expire after some time of inactivity. When working with persistent sessions, new sessions will automatically be created when old ones expire.

  You can however change this when creating the `Workbook` instance:

  ```python
  excel_file = WorkBook(my_file_instance, use_session=False, persist=False)
  ```



  After creating the `WorkBook` instance you will have access to the following objects:

  - WorkSheet
  - Range and NamedRange
  - Table, TableColumn and TableRow
  - RangeFormat (to format ranges)
  - Charts (not available for now)

  Some examples:

  Set format for a given range
  ```python

  my_range = ws.get_range('B2:C10')
  fmt = myrange.get_format()
  fmt.font.bold = True
  fmt.update()
  ```
  Autofit Columns:
  ```python
  ws.get_range('B2:C10').get_format().auto_fit_columns()
  ```

  Get values from Table:
  ```python
  table = ws.get_table('my_table')
  column = table.get_column_at_index(1)
  values = column.values[0]  # values returns a two dimensional array.
  ```


  The SharePoint api is done but there are no docs yet. Look at the sharepoint.py file to get insights.

  These are the scopes needed to work with the `SharePoint` and `Site` classes.

   Raw Scope                  |  Included in Scope Helper    | Description
   :---:                      |  :---:                       | ---
   *Sites.Read.All*           |  *sharepoint*                | To only read sites, lists and items
   *Sites.ReadWrite.All*      |  *sharepoint_dl*             | To read and save sites, lists and items


  The planner api is done but there are no docs yet. Look at the planner.py file to get insights.

  The planner functionality requires Administrator Permission.


  You can retrive, update, create and delete outlook categories.
  These categories can be used to categorize Messages, Events and Contacts.

  These are the scopes needed to work with the `SharePoint` and `Site` classes.

   Raw Scope                      |  Included in Scope Helper     | Description
   :---:                          |  :---:                        | ---
   *MailboxSettings.Read*         |  *-*                          | To only read outlook settingss
   *MailboxSettings.ReadWrite*    |  *settings_all*               | To read and write outlook settings

  Example:

  ```python
  from O365.category import CategoryColor

  oc = account.outlook_categories()
  categories = oc.get_categories()
  for category in categories:
      print(category.name, category.color)

  my_category = oc.create_category('Important Category', color=CategoryColor.RED)
  my_category.update_color(CategoryColor.DARKGREEN)

  my_category.delete()  # oops!
  ```





  When using certain methods, it is possible that you request more items than the api can return in a single api call.
  In this case the Api, returns a "next link" url where you can pull more data.

  When this is the case, the methods in this library will return a `Pagination` object which abstracts all this into a single iterator.
  The pagination object will request "next links" as soon as they are needed.

  For example:

  ```python
  mailbox = account.mailbox()

  messages = mailbox.get_messages(limit=1500)  # the Office 365 and MS Graph API have a 999 items limit returned per api call.







  for message in messages:
      print(message.subject)
  ```

  When using certain methods you will have the option to specify not only a limit option (the number of items to be returned) but a batch option.
  This option will indicate the method to request data to the api in batches until the limit is reached or the data consumed.
  This is usefull when you want to optimize memory or network latency.

  For example:

  ```python
  messages = mailbox.get_messages(limit=100, batch=25)




  for message in messages:  # 100 loops with 4 requests to the api server
      print(message.subject)
  ```



  When using the Office 365 API you can filter, order, select, expand or search on some fields.
  This filtering is tedious as is using [Open Data Protocol (OData)](http://docs.oasis-open.org/odata/odata/v4.0/errata03/os/complete/part2-url-conventions/odata-v4.0-errata03-os-part2-url-conventions-complete.html).

  Every `ApiComponent` (such as `MailBox`) implements a new_query method that will return a `Query` instance.
  This `Query` instance can handle the filtering, sorting, selecting, expanding and search very easily.

  For example:

  ```python
  query = mailbox.new_query()  # you can use the shorthand: mailbox.q()

  query = query.on_attribute('subject').contains('george best').chain('or').startswith('quotes')




  query = query.chain('and').on_attribute('created_date_time').greater(datetime(2018, 3, 21))

  print(query)





  filtered_messages = mailbox.get_messages(query=query)
  ```

  You can also specify specific data to be retrieved with "select":

  ```python

  query = mailbox.new_query().select('subject', 'to_recipients', 'created_date_time')

  messages_with_selected_properties = mailbox.get_messages(query=query)
  ```

  You can also search content. As said in the graph docs:

  > You can currently search only message and person collections. A $search request returns up to 250 results. You cannot use $filter or $orderby in a search request.

  > If you do a search on messages and specify only a value without specific message properties, the search is carried out on the default search properties of from, subject, and body.

  ```python

  query = mailbox.q().search('george best is da boss')
  messages = mailbox.get_messages(query=query)
  ```



  Whenever a Request error raises, the connection object will raise an exception.
  Then the exception will be captured and logged it to the stdout with it's message, an return Falsy (None, False, [], etc...)

  HttpErrors 4xx (Bad Request) and 5xx (Internal Server Error) are considered exceptions and raised also by the connection.
  You can tell the `Connection` to not raise http errors by passing `raise_http_errors=False` (defaults to True).


pkgId: 361f447fc1ac846506e1d3057b756b4e459abd69f14bec9ad10a6da35b7601de
name: python-OSGridConverter
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://github.com/....
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e368d11c-c7b6-4d5f-a7c5-630dd0b4d736
location_href: 00011726-python-osgridconverter/python-OSGridConverter-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  Library to convert co-ordinates between the (UK) Ordnance Survey National Grid and latitude/longitude


pkgId: 70a24df8b6826bc90e03b35132ce0a8d52b39946f6273a7d25653f15c9c9e76a
name: python-OWSLib
arch: src
version: 0.28.1
epoch: 0
release: 1
summary: OGC Web Service utility library
url: https://geopython.github.io/OWSLib
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89999533-09e0-42d9-ae4f-61e4e5cbe470
location_href: 00002865-python-OWSLib/python-OWSLib-0.28.1-1.src.rpm
checksum_type: sha256
description:
  OWSLib is a Python package for client programming with Open Geospatial
  Consortium (OGC) web service (hence OWS) interface standards, and their
  related content models.
  Full documentation is available at http://geopython.github.io/OWSLib
  OWSLib provides a common API for accessing service metadata and wrappers for
  numerous OGC Web Service interfaces.


pkgId: bb56d3f103976d6f5f0a5c95f5d0c57ae4cf4b0c701259471e4b1bc13d364d00
name: python-OctoPrint-FirmwareCheck
arch: src
version: 2021.10.11
epoch: 0
release: 1
summary: Checks for unsafe or broken printer firmwares
url: https://github.com/OctoPrint/OctoPrint-FirmwareCheck
rpm_license: AGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1141a7cb-8864-45bb-af8c-65735c85f910
location_href: 00013473-python-octoprint-firmwarecheck/python-OctoPrint-FirmwareCheck-2021.10.11-1.src.rpm
checksum_type: sha256
description:
  The Firmware Check plugin tries to identify printers or rather printer firmware with known safety issues, such as
  disabled thermal runaway protection, or other kinds of severe issues, like known communication crippling bugs, and
  displays a warning box to logged in users on identification of such a firmware.

  ![Screenshot of two warnings](https://raw.githubusercontent.com/OctoPrint/OctoPrint-FirmwareCheck/master/extras/screenshot.png)

  Since version 2021-2-4 it also displays info/"heads-ups" messages if a development firmware build
  is detected. This kind of message can be disabled.

  ![Screenshot of an info](https://raw.githubusercontent.com/OctoPrint/OctoPrint-FirmwareCheck/master/extras/screenshot2.png)

  It was formerly called "Printer Safety Check" and used to be bundled with OctoPrint since version
  1.3.7. It was unbundled in 1.4.1 and turned into an install dependency to allow for a separate release cycle. It is
  still considered a core plugin of OctoPrint, treated as if bundled and thus also active in [safe mode](https://docs.octoprint.org/en/master/features/safemode.html).



  The plugin is part of the core dependencies of OctoPrint 1.4.1+ and will be installed automatically alongside it.

  In case you want to manually install it into an older version for whatever reason, install via the bundled
  [Plugin Manager](https://docs.octoprint.org/en/master/bundledplugins/pluginmanager.html)
  or manually using this URL:

      https://github.com/OctoPrint/OctoPrint-FirmwareCheck/archive/master.zip

  To install and/or rollback to a specific version `<version>`, either use this URL in the plugin manager:

      https://github.com/OctoPrint/OctoPrint-FirmwareCheck/archive/<version>.zip

  or run

      pip install OctoPrint-FirmwareCheck==<version>

  in your OctoPrint virtual environment, substituting `<version>` accordingly.





  *(as `Events.PLUGIN_FIRMWARE_CHECK_WARNING`)*

  A firmware check warning was triggered.

  Payload:
    * `warning_type`: type of warning that was triggered (currently `firmware-unsafe` or `firmware-broken`)
    * `check_name`: name of check that was triggered (e.g. `aneta8`, `cbd`)
    * `check_type`: type of check that was triggered (e.g. `m115`, `received` or `cap`)



  The plugin currently issues three types of warnings: `firmware-unsafe` for firmware known to have severe safety issues,
  `firmware-broken` for firmware known to have a broken implementation of the communication protocol
  and `firmware-development` for detected development builds of firmware.



  Please refer to the [entry on the "unsafe firmware" warning in OctoPrint's FAQ](https://faq.octoprint.org/warning-firmware-unsafe)
  for a list of currently known to be affected printers.





  Please refer to the [entry on the "broken CBD firmware" warning in OctoPrint's FAQ](https://faq.octoprint.org/warning-firmware-broken-cbd)
  for a list of currently known to be affected printers.



  Please refer to the [entry on the this warning in OctoPrint's FAQ](https://faq.octoprint.org/warning-firmware-broken-creality-temp)
  for variants of this and a list of currently known to be affected printers.



  Please refer to the [entry on the "development firmware" warning in OctoPrint's FAQ](https://faq.octoprint.org/warning-firmware-development)
  for a list of currently detected firmware variants.


pkgId: 935e3db1130be5d6aa184041d0c3a17ee9dc27dd7360559df29c691103e63542
name: python-OctoPrint-PiSupport
arch: src
version: 2022.6.13
epoch: 0
release: 1
summary: Provides additional information about your Pi in the UI
url: https://github.com/OctoPrint/OctoPrint-PiSupport
rpm_license: AGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c02195a5-8a8f-4d0d-b638-d1d3780f6d74
location_href: 00013629-python-octoprint-pisupport/python-OctoPrint-PiSupport-2022.6.13-1.src.rpm
checksum_type: sha256
description:
  The Pi Support plugin provides additional information about your Pi in the UI and also
  alerts you about undervoltage or overheating issues observed on your Pi or if your Pi is
  unsupported. If you are running OctoPi, the Pi Support plugin will also provide additional
  information about that.

  OctoPrint will only load this plugin when it detects that it is being run on a
  Raspberry Pi.

  This plugin was bundled right with OctoPrint's sources until version 1.6.0. It has been
  extracted into a standalone project to allow for a different release cycle, but is still
  considered a bundled plugin.



  The plugin is part of the core dependencies of OctoPrint 1.6.0+ and will be installed automatically alongside it.

  In case you want to manually install it into an older version for whatever reason, install via the bundled
  [Plugin Manager](https://docs.octoprint.org/en/master/bundledplugins/pluginmanager.html)
  or manually using this URL:

      https://github.com/OctoPrint/OctoPrint-PiSupport/archive/main.zip

  To install and/or rollback to a specific version `<version>`, either use this URL in the plugin manager:

      https://github.com/OctoPrint/OctoPrint-PiSupport/archive/<version>.zip

  or run

      pip install OctoPrint-PiSupport==<version>

  in your OctoPrint virtual environment, substituting `<version>` accordingly.





  *(as `Events.PLUGIN_PI_SUPPORT_THROTTLE_STATE`)*

  A change in throttle state was detected.

  Payload:
    * `raw_value`: The raw throttle state value as received from `vcgencmd get_throttled`
    * `current_undervolate`: Whether there is currently an undervoltage condition
    * `past_undervoltage`: Whether there has been an undervoltage condition since last boot
    * `current_overheat`: Whether there is currently an overheat condition
    * `past_overheat`: Whether there has been an overheat condition since last boot
    * `current_issue`: Whether there is currently an undervoltage or overheat condition
    * `past_issue`: Whether there has been either an undervoltage or overheat condition since last boot





  Access to `get_throttle_state`, to retrieve the current throttle state. Returns a `dict`
  with the same fields as the `PLUGIN_PI_SUPPORT_THROTTLE_STATE` event payload. By setting
  the keyword argument `run_now` set to `True`, the throttle state will be refreshed before
  returning.


pkgId: e54fa28d86c5dd2edc62d2a6b0a68d03b178be213e17c7ff00abb282d08986a8
name: python-Office365-REST-Python-Client
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Microsoft 365 & Microsoft Graph Library for Python
url: https://github.com/vgrem/Office365-REST-Python-Client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bb159d62-1113-4ad5-91e6-5acfc3aa2bc2
location_href: 00009995-python-office365-rest-python-client/python-Office365-REST-Python-Client-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Office 365 & Microsoft Graph library for Python



  1. [Installation](#Installation)
  2. [Working with SharePoint API](#Working-with-SharePoint-API)
  3. [Working with Outlook API](#Working-with-Outlook-API)
  4. [Working with OneDrive API](#Working-with-OneDrive-API)
  5. [Working with Teams API](#Working-with-Microsoft-Teams-API)
  6. [Working with OneNote API](#Working-with-Microsoft-OneNote-API)
  7. [Working with Planner API](#Working-with-Microsoft-Planner-API)


  [![Downloads](https://pepy.tech/badge/office365-rest-python-client/month)](https://pepy.tech/project/office365-rest-python-client)
  [![PyPI](https://img.shields.io/pypi/v/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client/)
  [![Build Status](https://travis-ci.com/vgrem/Office365-REST-Python-Client.svg?branch=master)](https://travis-ci.com/vgrem/Office365-REST-Python-Client)



  Use pip:

  ```
  pip install Office365-REST-Python-Client
  ```


  >

  >Alternatively the _latest_ version could be directly installed via GitHub:
  >```
  >pip install git+https://github.com/vgrem/Office365-REST-Python-Client.git
  >```


  For the following examples, relevant credentials can be found in the Azure Portal.

  Steps to access:
  1. Login to the home page of the Azure Portal
  2. Navigate to "Azure Active Directory" using the three bars in the top right corner of the portal
  3. Select "App registrations" in the navigation panel on the left
  4. Search for and select your relevant application
  5. In the application's "Overview" page, the client id can be found under "Application (client) id"
  6. In the application's "Certificates & Secrets" page, the client secret can be found under the "Value" of the "Client Secrets." If there is no client secret yet, create one here.



  The list of supported API versions:
  -   [SharePoint 2013 REST API](https://msdn.microsoft.com/en-us/library/office/jj860569.aspx) and above
  -   SharePoint Online & OneDrive for Business REST API



  The following auth flows are supported:

  - app principals flow:
    `ClientContext.with_credentials(client_credentials)`

    Usage:
    ```
    client_credentials = ClientCredential('{client_id}','{client_secret}')
    ctx = ClientContext('{url}').with_credentials(client_credentials)
    ```
    Documentation: refer [Granting access using SharePoint App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azureacs) for a details

    Example: [connect_with_app_principal.py](examples/sharepoint/connect_with_app_only_principal.py)

  - user credentials flow: `ClientContext.with_credentials(user_credentials)`

    Usage:
    ```
    user_credentials = UserCredential('{username}','{password}')
    ctx = ClientContext('{url}').with_credentials(user_credentials)
    ```
    Example: [connect_with_user_credential.py](examples/sharepoint/connect_with_user_credential.py)

  - certificate credentials flow: `ClientContext.with_certificate(tenant, client_id, thumbprint, cert_path)`

    Documentation: [Granting access via Azure AD App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azuread)

    Example: [connect_with_client_certificate.py](examples/sharepoint/connect_with_client_certificate.py)



  There are **two approaches** available to perform API queries:

  1. `ClientContext class` - where you target SharePoint resources such as `Web`, `ListItem` and etc (recommended)

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web
  ctx.load(web)
  ctx.execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```
  or alternatively via method chaining (a.k.a Fluent Interface):

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web.get().execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```


  2. `RequestOptions class` - where you construct REST queries (and no model is involved)

     The example demonstrates how to read `Web` properties:

  ```python
  import json
  from office365.runtime.auth.user_credential import UserCredential
  from office365.runtime.http.request_options import RequestOptions
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  request = RequestOptions("{0}/_api/web/".format(site_url))
  response = ctx.pending_request().execute_request_direct(request)
  json = json.loads(response.content)
  web_title = json['d']['Title']
  print("Web title: {0}".format(web_title))
  ```


  The list of examples:

  - Working with files
    - [download a file](examples/sharepoint/files/download_file.py)
    - [upload a file](examples/sharepoint/files/upload_file.py)

  - Working with lists and list items
    -  [create a list item](examples/sharepoint/lists/data_generator.py)
    -  [read a list item](examples/sharepoint/lists/read_large_list.py)
    -  [update a list item](examples/sharepoint/listitems/update_items_batch.py)
    -  [delete a list item](examples/sharepoint/listitems/delete_list_item.py)

  Refer [examples section](examples/sharepoint) for another scenarios



  The list of supported APIs:
  -   [Outlook Contacts REST API](https://msdn.microsoft.com/en-us/office/office365/api/contacts-rest-operations)
  -   [Outlook Calendar REST API](https://msdn.microsoft.com/en-us/office/office365/api/calendar-rest-operations)
  -   [Outlook Mail REST API](https://msdn.microsoft.com/en-us/office/office365/api/mail-rest-operations)


  Since Outlook REST APIs are available in both Microsoft Graph and the Outlook API endpoint,
  the following clients are available:

  - `GraphClient` which targets Outlook API `v2.0` version (*preferable* nowadays, refer [transition to Microsoft Graph-based Outlook REST API](https://docs.microsoft.com/en-us/outlook/rest/compare-graph-outlook) for a details)
  ~~- `OutlookClient` which targets Outlook API `v1.0` version (not recommended for usage since `v1.0` version is being deprecated.)~~




  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used as a default library to obtain tokens to call Microsoft Graph API.

  Using [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)

  > Note: access token is getting acquired via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)
  > in the provided examples. Other forms of token aquisition can be found here: https://msal-python.readthedocs.io/en/latest/

  ```python
  import msal
  from office365.graph_client import GraphClient

  def acquire_token():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token


  client = GraphClient(acquire_token)

  ```

  But in terms of Microsoft Graph API authentication, another OAuth spec compliant libraries
  such as [adal](https://github.com/AzureAD/azure-activedirectory-library-for-python)
  are supported as well.

  Using [ADAL Python](https://adal-python.readthedocs.io/en/latest/#)

  Usage

  ```python
  import adal
  from office365.graph_client import GraphClient

  def acquire_token_func():
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      auth_ctx = adal.AuthenticationContext(authority_url)
      token = auth_ctx.acquire_token_with_client_credentials(
          "https://graph.microsoft.com",
          "{client_id}",
          "{client_secret}")
      return token

  client = GraphClient(acquire_token_func)

  ```



  The example demonstrates how to send an email via [Microsoft Graph endpoint](https://docs.microsoft.com/en-us/graph/api/user-sendmail?view=graph-rest-1.0&tabs=http).

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)

  client.me.send_mail(
      subject="Meet for lunch?",
      body="The new cafeteria is open.",
      to_recipients=["fannyd@contoso.onmicrosoft.com"]
  ).execute_query()

  ```

  > How to enable sending emails on behalf of another user in your organization: https://learn.microsoft.com/en-us/microsoft-365/solutions/allow-members-to-send-as-or-send-on-behalf-of-group?view=o365-worldwide&viewFallbackFrom=o365-worldwide%3FWT.mc_id%3D365AdminCSH_globalsearch

  Additional examples:

  -  [download a message](examples/outlook/download_messages.py)
  -  [list messages](examples/outlook/list_message.py)
  -  [move messages to a different folder](examples/outlook/move_message.py)
  -  [search messages](examples/outlook/search_message.py)
  -  [send messages](examples/outlook/send_message.py)
  -  [send messages with attachments](examples/outlook/send_message_with_attachment.py)

  Refer to [examples section](examples/outlook) for other scenarios






  [OneDrive Graph API reference](https://docs.microsoft.com/en-us/graph/api/resources/onedrive?view=graph-rest-1.0)



  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token

  ```python
  import msal

  def acquire_token_func():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token
  ```






  The example demonstrates how to enumerate and print drive's url
  which corresponds to [`list available drives` endpoint](https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/drive_list?view=odsp-graph-online)

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  tenant_name = "contoso.onmicrosoft.com"
  client = GraphClient(acquire_token_func)
  drives = client.drives.get().execute_query()
  for drive in drives:
      print("Drive url: {0}".format(drive.web_url))
  ```




  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  drive = client.users["{user_id_or_principal_name}"].drive.get().execute_query()

  with tempfile.TemporaryDirectory() as path:
      download_files(drive.root, path)
  ```

  where

  ```python
  def download_files(remote_folder, local_path):
      drive_items = remote_folder.children.get().execute_query()
      for drive_item in drive_items:
          if drive_item.file is not None:  # is file?
              
              with open(os.path.join(local_path, drive_item.name), 'wb') as local_file:
                  drive_item.download(local_file).execute_query()
  ```

  Additional examples:

  -  [create list column](examples/onedrive/create_list_column.py)
  -  [download file](examples/onedrive/download_file_default.py)
  -  [export files](examples/onedrive/export_files.py)
  -  [import files](examples/onedrive/import_files.py)
  -  [list drives](examples/onedrive/list_drives.py)
  -  [list files](examples/onedrive/list_files.py)

  Refer to [OneDrive examples section](examples/onedrive) for more examples.






  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token





  The example demonstrates how create a new team under a group
  which corresponds to [`Create team` endpoint](https://docs.microsoft.com/en-us/graph/api/team-put-teams?view=graph-rest-1.0&tabs=http)

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)
  new_team = client.groups["{group_id}"].add_team().execute_query_retry()
  ```

  Additional examples:

  -  [create a team](examples/teams/create_team.py)
  -  [create team from group](examples/teams/create_team_from_group.py)
  -  [list all teams](examples/teams/list_all_teams.py)
  -  [list my teams](examples/teams/list_my_teams.py)
  -  [send messages](examples/teams/send_message.py)

  Refer to [examples section](examples/teams) for other scenarios



  The library supports OneNote API in terms of calls to a user's OneNote notebooks, sections, and pages in a personal or organization account

  Example: Create a new page

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  files = {}
  with open("./MyPage.html", 'rb') as f, \
      open("./MyImage.png", 'rb') as img_f, \
      open("./MyDoc.pdf", 'rb') as pdf_f:
      files["imageBlock1"] = img_f
      files["fileBlock1"] = pdf_f
      page = client.me.onenote.pages.add(presentation_file=f, attachment_files=files).execute_query()
  ```



  The example demonstrates how to create a new planner task
  which corresponds to [`Create plannerTask` endpoint](https://docs.microsoft.com/en-us/graph/api/planner-post-tasks?view=graph-rest-1.0):

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)
  task = client.planner.tasks.add(title="New task", planId="--plan id goes here--").execute_query()
  ```


  The following libraries will be installed when you install the client library:
  * [requests](https://github.com/kennethreitz/requests)
  * [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)


pkgId: 6d15cc30c62c265067783bbc695322d973815926863bcd45d22fb05741f92e7f
name: python-Office365-REST-Python-Client-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for Office365-REST-Python-Client
url: https://github.com/vgrem/Office365-REST-Python-Client
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bb159d62-1113-4ad5-91e6-5acfc3aa2bc2
rpm_sourcerpm: python-Office365-REST-Python-Client-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Office 365 & Microsoft Graph library for Python



  1. [Installation](#Installation)
  2. [Working with SharePoint API](#Working-with-SharePoint-API)
  3. [Working with Outlook API](#Working-with-Outlook-API)
  4. [Working with OneDrive API](#Working-with-OneDrive-API)
  5. [Working with Teams API](#Working-with-Microsoft-Teams-API)
  6. [Working with OneNote API](#Working-with-Microsoft-OneNote-API)
  7. [Working with Planner API](#Working-with-Microsoft-Planner-API)


  [![Downloads](https://pepy.tech/badge/office365-rest-python-client/month)](https://pepy.tech/project/office365-rest-python-client)
  [![PyPI](https://img.shields.io/pypi/v/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/Office365-REST-Python-Client.svg)](https://pypi.python.org/pypi/Office365-REST-Python-Client/)
  [![Build Status](https://travis-ci.com/vgrem/Office365-REST-Python-Client.svg?branch=master)](https://travis-ci.com/vgrem/Office365-REST-Python-Client)



  Use pip:

  ```
  pip install Office365-REST-Python-Client
  ```


  >

  >Alternatively the _latest_ version could be directly installed via GitHub:
  >```
  >pip install git+https://github.com/vgrem/Office365-REST-Python-Client.git
  >```


  For the following examples, relevant credentials can be found in the Azure Portal.

  Steps to access:
  1. Login to the home page of the Azure Portal
  2. Navigate to "Azure Active Directory" using the three bars in the top right corner of the portal
  3. Select "App registrations" in the navigation panel on the left
  4. Search for and select your relevant application
  5. In the application's "Overview" page, the client id can be found under "Application (client) id"
  6. In the application's "Certificates & Secrets" page, the client secret can be found under the "Value" of the "Client Secrets." If there is no client secret yet, create one here.



  The list of supported API versions:
  -   [SharePoint 2013 REST API](https://msdn.microsoft.com/en-us/library/office/jj860569.aspx) and above
  -   SharePoint Online & OneDrive for Business REST API



  The following auth flows are supported:

  - app principals flow:
    `ClientContext.with_credentials(client_credentials)`

    Usage:
    ```
    client_credentials = ClientCredential('{client_id}','{client_secret}')
    ctx = ClientContext('{url}').with_credentials(client_credentials)
    ```
    Documentation: refer [Granting access using SharePoint App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azureacs) for a details

    Example: [connect_with_app_principal.py](examples/sharepoint/connect_with_app_only_principal.py)

  - user credentials flow: `ClientContext.with_credentials(user_credentials)`

    Usage:
    ```
    user_credentials = UserCredential('{username}','{password}')
    ctx = ClientContext('{url}').with_credentials(user_credentials)
    ```
    Example: [connect_with_user_credential.py](examples/sharepoint/connect_with_user_credential.py)

  - certificate credentials flow: `ClientContext.with_certificate(tenant, client_id, thumbprint, cert_path)`

    Documentation: [Granting access via Azure AD App-Only](https://docs.microsoft.com/en-us/sharepoint/dev/solution-guidance/security-apponly-azuread)

    Example: [connect_with_client_certificate.py](examples/sharepoint/connect_with_client_certificate.py)



  There are **two approaches** available to perform API queries:

  1. `ClientContext class` - where you target SharePoint resources such as `Web`, `ListItem` and etc (recommended)

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web
  ctx.load(web)
  ctx.execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```
  or alternatively via method chaining (a.k.a Fluent Interface):

  ```python
  from office365.runtime.auth.user_credential import UserCredential
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  web = ctx.web.get().execute_query()
  print("Web title: {0}".format(web.properties['Title']))
  ```


  2. `RequestOptions class` - where you construct REST queries (and no model is involved)

     The example demonstrates how to read `Web` properties:

  ```python
  import json
  from office365.runtime.auth.user_credential import UserCredential
  from office365.runtime.http.request_options import RequestOptions
  from office365.sharepoint.client_context import ClientContext
  site_url = "https://{your-tenant-prefix}.sharepoint.com"
  ctx = ClientContext(site_url).with_credentials(UserCredential("{username}", "{password}"))
  request = RequestOptions("{0}/_api/web/".format(site_url))
  response = ctx.pending_request().execute_request_direct(request)
  json = json.loads(response.content)
  web_title = json['d']['Title']
  print("Web title: {0}".format(web_title))
  ```


  The list of examples:

  - Working with files
    - [download a file](examples/sharepoint/files/download_file.py)
    - [upload a file](examples/sharepoint/files/upload_file.py)

  - Working with lists and list items
    -  [create a list item](examples/sharepoint/lists/data_generator.py)
    -  [read a list item](examples/sharepoint/lists/read_large_list.py)
    -  [update a list item](examples/sharepoint/listitems/update_items_batch.py)
    -  [delete a list item](examples/sharepoint/listitems/delete_list_item.py)

  Refer [examples section](examples/sharepoint) for another scenarios



  The list of supported APIs:
  -   [Outlook Contacts REST API](https://msdn.microsoft.com/en-us/office/office365/api/contacts-rest-operations)
  -   [Outlook Calendar REST API](https://msdn.microsoft.com/en-us/office/office365/api/calendar-rest-operations)
  -   [Outlook Mail REST API](https://msdn.microsoft.com/en-us/office/office365/api/mail-rest-operations)


  Since Outlook REST APIs are available in both Microsoft Graph and the Outlook API endpoint,
  the following clients are available:

  - `GraphClient` which targets Outlook API `v2.0` version (*preferable* nowadays, refer [transition to Microsoft Graph-based Outlook REST API](https://docs.microsoft.com/en-us/outlook/rest/compare-graph-outlook) for a details)
  ~~- `OutlookClient` which targets Outlook API `v1.0` version (not recommended for usage since `v1.0` version is being deprecated.)~~




  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used as a default library to obtain tokens to call Microsoft Graph API.

  Using [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)

  > Note: access token is getting acquired via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)
  > in the provided examples. Other forms of token aquisition can be found here: https://msal-python.readthedocs.io/en/latest/

  ```python
  import msal
  from office365.graph_client import GraphClient

  def acquire_token():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token


  client = GraphClient(acquire_token)

  ```

  But in terms of Microsoft Graph API authentication, another OAuth spec compliant libraries
  such as [adal](https://github.com/AzureAD/azure-activedirectory-library-for-python)
  are supported as well.

  Using [ADAL Python](https://adal-python.readthedocs.io/en/latest/#)

  Usage

  ```python
  import adal
  from office365.graph_client import GraphClient

  def acquire_token_func():
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      auth_ctx = adal.AuthenticationContext(authority_url)
      token = auth_ctx.acquire_token_with_client_credentials(
          "https://graph.microsoft.com",
          "{client_id}",
          "{client_secret}")
      return token

  client = GraphClient(acquire_token_func)

  ```



  The example demonstrates how to send an email via [Microsoft Graph endpoint](https://docs.microsoft.com/en-us/graph/api/user-sendmail?view=graph-rest-1.0&tabs=http).

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)

  client.me.send_mail(
      subject="Meet for lunch?",
      body="The new cafeteria is open.",
      to_recipients=["fannyd@contoso.onmicrosoft.com"]
  ).execute_query()

  ```

  > How to enable sending emails on behalf of another user in your organization: https://learn.microsoft.com/en-us/microsoft-365/solutions/allow-members-to-send-as-or-send-on-behalf-of-group?view=o365-worldwide&viewFallbackFrom=o365-worldwide%3FWT.mc_id%3D365AdminCSH_globalsearch

  Additional examples:

  -  [download a message](examples/outlook/download_messages.py)
  -  [list messages](examples/outlook/list_message.py)
  -  [move messages to a different folder](examples/outlook/move_message.py)
  -  [search messages](examples/outlook/search_message.py)
  -  [send messages](examples/outlook/send_message.py)
  -  [send messages with attachments](examples/outlook/send_message_with_attachment.py)

  Refer to [examples section](examples/outlook) for other scenarios






  [OneDrive Graph API reference](https://docs.microsoft.com/en-us/graph/api/resources/onedrive?view=graph-rest-1.0)



  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token

  ```python
  import msal

  def acquire_token_func():
      """
      Acquire token via MSAL
      """
      authority_url = 'https://login.microsoftonline.com/{tenant_id_or_name}'
      app = msal.ConfidentialClientApplication(
          authority=authority_url,
          client_id='{client_id}',
          client_credential='{client_secret}'
      )
      token = app.acquire_token_for_client(scopes=["https://graph.microsoft.com/.default"])
      return token
  ```






  The example demonstrates how to enumerate and print drive's url
  which corresponds to [`list available drives` endpoint](https://docs.microsoft.com/en-us/onedrive/developer/rest-api/api/drive_list?view=odsp-graph-online)

  > Note: access token is getting acquired  via [Client Credential flow](https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow)

  ```python
  from office365.graph_client import GraphClient

  tenant_name = "contoso.onmicrosoft.com"
  client = GraphClient(acquire_token_func)
  drives = client.drives.get().execute_query()
  for drive in drives:
      print("Drive url: {0}".format(drive.web_url))
  ```




  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  drive = client.users["{user_id_or_principal_name}"].drive.get().execute_query()

  with tempfile.TemporaryDirectory() as path:
      download_files(drive.root, path)
  ```

  where

  ```python
  def download_files(remote_folder, local_path):
      drive_items = remote_folder.children.get().execute_query()
      for drive_item in drive_items:
          if drive_item.file is not None:  # is file?
              
              with open(os.path.join(local_path, drive_item.name), 'wb') as local_file:
                  drive_item.download(local_file).execute_query()
  ```

  Additional examples:

  -  [create list column](examples/onedrive/create_list_column.py)
  -  [download file](examples/onedrive/download_file_default.py)
  -  [export files](examples/onedrive/export_files.py)
  -  [import files](examples/onedrive/import_files.py)
  -  [list drives](examples/onedrive/list_drives.py)
  -  [list files](examples/onedrive/list_files.py)

  Refer to [OneDrive examples section](examples/onedrive) for more examples.






  [The Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/) which comes as a dependency
  is used to obtain token





  The example demonstrates how create a new team under a group
  which corresponds to [`Create team` endpoint](https://docs.microsoft.com/en-us/graph/api/team-put-teams?view=graph-rest-1.0&tabs=http)

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)
  new_team = client.groups["{group_id}"].add_team().execute_query_retry()
  ```

  Additional examples:

  -  [create a team](examples/teams/create_team.py)
  -  [create team from group](examples/teams/create_team_from_group.py)
  -  [list all teams](examples/teams/list_all_teams.py)
  -  [list my teams](examples/teams/list_my_teams.py)
  -  [send messages](examples/teams/send_message.py)

  Refer to [examples section](examples/teams) for other scenarios



  The library supports OneNote API in terms of calls to a user's OneNote notebooks, sections, and pages in a personal or organization account

  Example: Create a new page

  ```python
  from office365.graph_client import GraphClient
  client = GraphClient(acquire_token_func)

  files = {}
  with open("./MyPage.html", 'rb') as f, \
      open("./MyImage.png", 'rb') as img_f, \
      open("./MyDoc.pdf", 'rb') as pdf_f:
      files["imageBlock1"] = img_f
      files["fileBlock1"] = pdf_f
      page = client.me.onenote.pages.add(presentation_file=f, attachment_files=files).execute_query()
  ```



  The example demonstrates how to create a new planner task
  which corresponds to [`Create plannerTask` endpoint](https://docs.microsoft.com/en-us/graph/api/planner-post-tasks?view=graph-rest-1.0):

  ```python
  from office365.graph_client import GraphClient

  client = GraphClient(acquire_token_func)
  task = client.planner.tasks.add(title="New task", planId="--plan id goes here--").execute_query()
  ```


  The following libraries will be installed when you install the client library:
  * [requests](https://github.com/kennethreitz/requests)
  * [Microsoft Authentication Library (MSAL) for Python](https://pypi.org/project/msal/)

location_href:
  00009995-python-office365-rest-python-client/python-Office365-REST-Python-Client-help-2.4.0-1.noarch.rpm


pkgId: 43d0d0c961777cebb4cb12ab2bcead3fea5876bfa1443dc15dd50ed0c97abb0d
name: python-OnionBalance
arch: src
version: 0.2.1
epoch: 0
release: 1
url: https://github.com/asn-d6/onionbalance
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2ed53a85-e633-4a3a-8ab6-0160a35c2a95
location_href: 00004374-python-onionbalance/python-OnionBalance-0.2.1-1.src.rpm
checksum_type: sha256
summary:
  OnionBalance provides load-balancing and redundancy for Tor hidden services by distributing requests to multiple backend Tor instances.


pkgId: a0d9de8ffb000debf31cebb1a52612d0205abf90bc53e72889c5575322b05485
name: python-PTable
arch: src
version: 0.9.2
epoch: 0
release: 1
url: https://github.com/kxxoling/PTable
rpm_license: BSD (3 clause)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bfad3abb-0d9d-4c3c-a348-3136be928ebd
location_href: 00010319-python-ptable/python-PTable-0.9.2-1.src.rpm
checksum_type: sha256
summary:
  A simple Python library for easily displaying tabular data in a visually appealing ASCII table format


pkgId: ecfa2657892cf1c175726040a28911834377bd8441257fd36784e98e82e04c12
name: python-Pairtree
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Pairtree FS implementation.
url: http://packages.python.org/Pairtree/
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c3f15f3-b83a-4d82-b97f-57e16d23160f
location_href: 00013695-python-pairtree/python-Pairtree-0.8.1-1.src.rpm
checksum_type: sha256
description:
  From http://www.cdlib.org/inside/diglib/pairtree/pairtreespec.html : Pairtree, a filesystem hierarchy for holding objects that are located by mapping identifier strings to object directory (or folder) paths two characters at a time. If an object directory (folder) holds all the files, and nothing but the files, that comprise the object, a "pairtree" can be imported by a system that knows nothing about the nature or structure of the objects but can still deliver any object's files by requested identifier. The mapping is reversible, so the importing system can also walk the pairtree and reliably enumerate all the contained object identifiers. To the extent that object dependencies are stored inside the pairtree (e.g., fast indexes stored outside contain only derivative data), simple or complex collections built on top of pairtrees can recover from index failures and reconstruct a collection view simply by walking the trees. Pairtrees have the advantage that many object operations, including backup and restore, can be performed with native operating system tools.


pkgId: 4c17274558bf49e43913fbd45a763a0e4dd99b15449c03833eee0ef03315212f
name: python-Pallets-Sphinx-Themes
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Sphinx themes for Pallets and related projects.
url: https://github.com/pallets/pallets-sphinx-themes/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-545311f0-19b8-4bb8-90e0-4e0411d12f32
location_href: 00002866-python-Pallets-Sphinx-Themes/python-Pallets-Sphinx-Themes-2.0.3-1.src.rpm
checksum_type: sha256
description:
  Themes for the Pallets projects. If you're writing an extension, use the
  appropriate theme to make your documentation look consistent.
  Available themes:
  -   flask
  -   jinja
  -   werkzeug
  -   click
  Install this package:
      pip install Pallets-Sphinx-Themes
  Enable the extension and choose the theme in ``docs/conf.py``:
      extensions = [
          "pallets_sphinx_themes",
      ]
      html_theme = "flask"


pkgId: c309c3d856277e5d210b4b37de0457d5c0492dd1fe59b613bd1a7cac7b481597
name: python-Paste
arch: src
version: 3.5.2
epoch: 0
release: 1
summary: Tools for using a Web Server Gateway Interface stack
url: https://pythonpaste.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c93b7af5-7fd2-4d50-9551-0bc5c650b5ee
location_href: 00010079-python-paste/python-Paste-3.5.2-1.src.rpm
checksum_type: sha256
description:
  * A fixture for testing WSGI applications conveniently and in-process,
    in ``paste.fixture``
  * A fixture for testing command-line applications, also in
    ``paste.fixture``
  * Check components for WSGI-compliance in ``paste.lint``


pkgId: 688ee1c45bb815146b5addbb35b0a4774d91ddc1a7a43effe92ecf606df78600
name: python-PasteDeploy
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Load, configure, and compose WSGI applications and servers
url: https://docs.pylonsproject.org/projects/pastedeploy/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86502d01-e612-4368-ba1c-6176ce5df518
location_href: 00009501-python-pastedeploy/python-PasteDeploy-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This tool provides code to load WSGI applications and servers from
  URIs. These URIs can refer to Python eggs for INI-style configuration
  files.  `Paste Script <https://github.com/cdent/pastescript>`_ provides
  commands to serve applications based on this configuration file.

  The latest version is available on `GitHub
  <https://github.com/Pylons/pastedeploy/>`_ (or download a wheel or tarball from
  `PyPI <https://pypi.org/project/PasteDeploy/#files>`_).

  For the latest changes see the `news file
  <https://docs.pylonsproject.org/projects/pastedeploy/en/latest/news.html>`_.


pkgId: 4d1799bec08d6c27594ce9cb63d39de8b2f44ab0bb8d6ee7d58f8b1163617eb6
name: python-PasteScript
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: A pluggable command-line frontend, including commands to setup package file layouts
url: https://pastescript.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4103f724-66a9-4863-837d-08f5e6e8e94d
location_href: 00011282-python-pastescript/python-PasteScript-3.3.0-1.src.rpm
checksum_type: sha256
description:
  PasteScript is a pluggable command-line tool.

  **Note**: Paste Script is being maintained on life support. That
  means that critical bugs will be fixed, and support for new versions
  of Python will be handled, but other than that new features are not
  being considered.

  It includes some built-in features;

  * Create file layouts for packages.  For instance, ``paster create
    --template=basic_package MyPackage`` will create a `setuptools
    <https://pythonhosted.org/setuptools/>`_-ready
    file layout.

  * Serving up web applications, with configuration based on
    `paste.deploy <https://docs.pylonsproject.org/projects/pastedeploy>`_.

  The latest version is available in a `GitHub repository
  <https://github.com/cdent/pastescript/>`_.

  For the latest changes see the `news file
  <https://pastescript.readthedocs.io/en/latest/news.html>`_.


pkgId: 58b8abd93597bd97bbadd5f29b87292433dcf7b994329851bd29b78d582ceec0
name: python-Pebble
arch: src
version: 5.0.3
epoch: 0
release: 1
summary: Threading and multiprocessing eye-candy.
url: https://github.com/noxdafox/pebble
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4347922c-336d-4e80-9729-1a1e2f56f82f
location_href: 00004517-python-pebble/python-Pebble-5.0.3-1.src.rpm
checksum_type: sha256
description:
  Pebble provides a neat API to manage threads and processes within an application.
  |build badge| |docs badge| |downloads badge|


pkgId: f17ce7e7794b5dbaf12bbc24db6176cda1b18ebe518a1b2ceda58ab31599b322
name: python-Pillow
arch: src
version: 9.4.0
epoch: 0
release: 1
summary: Python Imaging Library (Fork)
url: https://python-pillow.org
rpm_license: HPND
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d0b2cfa9-ca40-431b-b11b-80b769591080
location_href: 00004548-python-pillow/python-Pillow-9.4.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img width="248" height="250" src="https://raw.githubusercontent.com/python-pillow/pillow-logo/main/pillow-logo-248x250.png" alt="Pillow logo">
  </p>





  Pillow is the friendly PIL fork by [Alex Clark and
  Contributors](https://github.com/python-pillow/Pillow/graphs/contributors).
  PIL is the Python Imaging Library by Fredrik Lundh and Contributors.
  As of 2019, Pillow development is
  [supported by Tidelift](https://tidelift.com/subscription/pkg/pypi-pillow?utm_source=pypi-pillow&utm_medium=readme&utm_campaign=enterprise).

  <table>
      <tr>
          <th>docs</th>
          <td>
              <a href="https://pillow.readthedocs.io/?badge=latest"><img
                  alt="Documentation Status"
                  src="https://readthedocs.org/projects/pillow/badge/?version=latest"></a>
          </td>
      </tr>
      <tr>
          <th>tests</th>
          <td>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/lint.yml"><img
                  alt="GitHub Actions build status (Lint)"
                  src="https://github.com/python-pillow/Pillow/workflows/Lint/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test.yml"><img
                  alt="GitHub Actions build status (Test Linux and macOS)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-windows.yml"><img
                  alt="GitHub Actions build status (Test Windows)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20Windows/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-mingw.yml"><img
                  alt="GitHub Actions build status (Test MinGW)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20MinGW/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-cygwin.yml"><img
                  alt="GitHub Actions build status (Test Cygwin)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20Cygwin/badge.svg"></a>
              <a href="https://github.com/python-pillow/Pillow/actions/workflows/test-docker.yml"><img
                  alt="GitHub Actions build status (Test Docker)"
                  src="https://github.com/python-pillow/Pillow/workflows/Test%20Docker/badge.svg"></a>
              <a href="https://ci.appveyor.com/project/python-pillow/Pillow"><img
                  alt="AppVeyor CI build status (Windows)"
                  src="https://img.shields.io/appveyor/build/python-pillow/Pillow/main.svg?label=Windows%20build"></a>
              <a href="https://github.com/python-pillow/pillow-wheels/actions"><img
                  alt="GitHub Actions wheels build status (Wheels)"
                  src="https://github.com/python-pillow/pillow-wheels/workflows/Wheels/badge.svg"></a>
              <a href="https://app.travis-ci.com/github/python-pillow/pillow-wheels"><img
                  alt="Travis CI wheels build status (aarch64)"
                  src="https://img.shields.io/travis/com/python-pillow/pillow-wheels/main.svg?label=aarch64%20wheels"></a>
              <a href="https://app.codecov.io/gh/python-pillow/Pillow"><img
                  alt="Code coverage"
                  src="https://codecov.io/gh/python-pillow/Pillow/branch/main/graph/badge.svg"></a>
              <a href="https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:pillow"><img
                  alt="Fuzzing Status"
                  src="https://oss-fuzz-build-logs.storage.googleapis.com/badges/pillow.svg"></a>
          </td>
      </tr>
      <tr>
          <th>package</th>
          <td>
              <a href="https://zenodo.org/badge/latestdoi/17549/python-pillow/Pillow"><img
                  alt="Zenodo"
                  src="https://zenodo.org/badge/17549/python-pillow/Pillow.svg"></a>
              <a href="https://tidelift.com/subscription/pkg/pypi-pillow?utm_source=pypi-pillow&utm_medium=badge"><img
                  alt="Tidelift"
                  src="https://tidelift.com/badges/package/pypi/Pillow?style=flat"></a>
              <a href="https://pypi.org/project/Pillow/"><img
                  alt="Newest PyPI version"
                  src="https://img.shields.io/pypi/v/pillow.svg"></a>
              <a href="https://pypi.org/project/Pillow/"><img
                  alt="Number of PyPI downloads"
                  src="https://img.shields.io/pypi/dm/pillow.svg"></a>
              <a href="https://bestpractices.coreinfrastructure.org/projects/6331"><img
                  alt="OpenSSF Best Practices"
                  src="https://bestpractices.coreinfrastructure.org/projects/6331/badge"></a>
          </td>
      </tr>
      <tr>
          <th>social</th>
          <td>
              <a href="https://gitter.im/python-pillow/Pillow?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img
                  alt="Join the chat at https://gitter.im/python-pillow/Pillow"
                  src="https://badges.gitter.im/python-pillow/Pillow.svg"></a>
              <a href="https://twitter.com/PythonPillow"><img
                  alt="Follow on https://twitter.com/PythonPillow"
                  src="https://img.shields.io/badge/tweet-on%20Twitter-00aced.svg"></a>
          </td>
      </tr>
  </table>



  The Python Imaging Library adds image processing capabilities to your Python interpreter.

  This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities.

  The core image library is designed for fast access to data stored in a few basic pixel formats. It should provide a solid foundation for a general image processing tool.



  - [Documentation](https://pillow.readthedocs.io/)
    - [Installation](https://pillow.readthedocs.io/en/latest/installation.html)
    - [Handbook](https://pillow.readthedocs.io/en/latest/handbook/index.html)
  - [Contribute](https://github.com/python-pillow/Pillow/blob/main/.github/CONTRIBUTING.md)
    - [Issues](https://github.com/python-pillow/Pillow/issues)
    - [Pull requests](https://github.com/python-pillow/Pillow/pulls)
  - [Release notes](https://pillow.readthedocs.io/en/stable/releasenotes/index.html)
  - [Changelog](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst)
    - [Pre-fork](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst#pre-fork)



  To report a security vulnerability, please follow the procedure described in the [Tidelift security policy](https://tidelift.com/docs/security).


