# packages

pkgId: 119e28becc54968871b3748fbd2398269a4be72c3094281884843cea04ba59cf
name: python-dataset
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Toolkit for Python-based database access.
url: http://github.com/pudo/dataset
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9156ebbb-f1e7-4098-b2a5-b262bef7a990
location_href: 00011660-python-dataset/python-dataset-1.6.0-1.src.rpm
checksum_type: sha256
description:
  ![build](https://github.com/pudo/dataset/workflows/build/badge.svg)
  In short, **dataset** makes reading and writing data in databases as simple as reading and writing JSON files.
  [Read the docs](https://dataset.readthedocs.io/)
  To install dataset, fetch it with ``pip``:
  ```bash
  $ pip install dataset
  ```
  **Note:** as of version 1.0, **dataset** is split into two packages, with the
  data export features now extracted into a stand-alone package, **datafreeze**.
  See the relevant repository [here](https://github.com/pudo/datafreeze).


pkgId: 49749048fdfcd6e529244747d53c1dbef1a0af08038faaeab37e3ada97bbc3f8
name: python-datasette
arch: src
version: 0.64.2
epoch: 0
release: 1
summary: An open source multi-tool for exploring and publishing data
url: https://datasette.io/
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e701a00a-7741-4ae1-ae66-76228ea6f099
location_href: 00011187-python-datasette/python-datasette-0.64.2-1.src.rpm
checksum_type: sha256
description:
  <img src="https://datasette.io/static/datasette-logo.svg" alt="Datasette">

  [![PyPI](https://img.shields.io/pypi/v/datasette.svg)](https://pypi.org/project/datasette/)
  [![Changelog](https://img.shields.io/github/v/release/simonw/datasette?label=changelog)](https://docs.datasette.io/en/stable/changelog.html)
  [![Python 3.x](https://img.shields.io/pypi/pyversions/datasette.svg?logo=python&logoColor=white)](https://pypi.org/project/datasette/)
  [![Tests](https://github.com/simonw/datasette/workflows/Test/badge.svg)](https://github.com/simonw/datasette/actions?query=workflow%3ATest)
  [![Documentation Status](https://readthedocs.org/projects/datasette/badge/?version=latest)](https://docs.datasette.io/en/latest/?badge=latest)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/datasette/blob/main/LICENSE)
  [![docker: datasette](https://img.shields.io/badge/docker-datasette-blue)](https://hub.docker.com/r/datasetteproject/datasette)
  [![discord](https://img.shields.io/discord/823971286308356157?label=discord)](https://discord.gg/ktd74dm5mw)

  *An open source multi-tool for exploring and publishing data*

  Datasette is a tool for exploring and publishing data. It helps people take data of any shape or size and publish that as an interactive, explorable website and accompanying API.

  Datasette is aimed at data journalists, museum curators, archivists, local governments, scientists, researchers and anyone else who has data that they wish to share with the world.

  [Explore a demo](https://global-power-plants.datasettes.com/global-power-plants/global-power-plants), watch [a video about the project](https://simonwillison.net/2021/Feb/7/video/) or try it out by [uploading and publishing your own CSV data](https://docs.datasette.io/en/stable/getting_started.html#try-datasette-without-installing-anything-using-glitch).

  * [datasette.io](https://datasette.io/) is the official project website
  * Latest [Datasette News](https://datasette.io/news)
  * Comprehensive documentation: https://docs.datasette.io/
  * Examples: https://datasette.io/examples
  * Live demo of current `main` branch: https://latest.datasette.io/
  * Questions, feedback or want to talk about the project? Join our [Discord](https://discord.gg/ktd74dm5mw)

  Want to stay up-to-date with the project? Subscribe to the [Datasette newsletter](https://datasette.substack.com/) for tips, tricks and news on what's new in the Datasette ecosystem.



  If you are on a Mac, [Homebrew](https://brew.sh/) is the easiest way to install Datasette:

      brew install datasette

  You can also install it using `pip` or `pipx`:

      pip install datasette

  Datasette requires Python 3.7 or higher. We also have [detailed installation instructions](https://docs.datasette.io/en/stable/installation.html) covering other options such as Docker.



      datasette serve path/to/database.db

  This will start a web server on port 8001 - visit http://localhost:8001/ to access the web interface.

  `serve` is the default subcommand, you can omit it if you like.

  Use Chrome on OS X? You can run datasette against your browser history like so:

       datasette ~/Library/Application\ Support/Google/Chrome/Default/History --nolock

  Now visiting http://localhost:8001/History/downloads will show you a web interface to browse your downloads data:

  ![Downloads table rendered by datasette](https://static.simonwillison.net/static/2017/datasette-downloads.png)



  If you want to include licensing and source information in the generated datasette website you can do so using a JSON file that looks something like this:

      {
          "title": "Five Thirty Eight",
          "license": "CC Attribution 4.0 License",
          "license_url": "http://creativecommons.org/licenses/by/4.0/",
          "source": "fivethirtyeight/data on GitHub",
          "source_url": "https://github.com/fivethirtyeight/data"
      }

  Save this in `metadata.json` and run Datasette like so:

      datasette serve fivethirtyeight.db -m metadata.json

  The license and source information will be displayed on the index page and in the footer. They will also be included in the JSON produced by the API.



  If you have [Heroku](https://heroku.com/) or [Google Cloud Run](https://cloud.google.com/run/) configured, Datasette can deploy one or more SQLite databases to the internet with a single command:

      datasette publish heroku database.db

  Or:

      datasette publish cloudrun database.db

  This will create a docker image containing both the datasette application and the specified SQLite database files. It will then deploy that image to Heroku or Cloud Run and give you a URL to access the resulting website and API.

  See [Publishing data](https://docs.datasette.io/en/stable/publish.html) in the documentation for more details.



  [Datasette Lite](https://lite.datasette.io/) is Datasette packaged using WebAssembly so that it runs entirely in your browser, no Python web application server required. Read more about that in the [Datasette Lite documentation](https://github.com/simonw/datasette-lite/blob/main/README.md).


pkgId: 40273085be07cd3a0b876f7bce78d0cec558b229de4d09fdb12a09e407a70f5e
name: python-dateutils
arch: src
version: 0.6.12
epoch: 0
release: 1
summary: Various utilities for working with date and datetime objects
url: https://github.com/jmcantrell/python-dateutils
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b769f454-3337-4757-b4bf-b879c397c7cd
location_href: 00003398-python-dateutils/python-dateutils-0.6.12-1.src.rpm
checksum_type: sha256
description:
  The main purpose of this package is to provide more complex arithmetic
  operations on dates/times. Heavy use is made of the relativedelta type from
  Labix's dateutil library. Much of this package is just a light wrapper on top
  of this with some added features such as range generation and business day
  calculation.


pkgId: b4b3c6f403718741c788b513fabc6ba4f3348125c22be838d7e98d535f9defca
name: python-dbf
arch: src
version: 0.99.3
epoch: 0
release: 1
url: https://github.com/ethanfurman/dbf
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f661666f-674d-4afa-b7fa-499d74046672
location_href: 00003400-python-dbf/python-dbf-0.99.3-1.src.rpm
checksum_type: sha256
summary:
  Pure python package for reading/writing dBase, FoxPro, and Visual FoxPro .dbf files (including memos)

description:
  Currently supports dBase III, Clipper, FoxPro, and Visual FoxPro tables. Text is returned as unicode, and codepage settings in tables are honored. Memos and Null fields are supported.  Documentation needs work, but author is very responsive to e-mails.

  Not supported: index files (but can create tempory non-file indexes), auto-incrementing fields, and Varchar fields.

  Installation:  `pip install dbf`


pkgId: 7c13906c757a642f8815f2e3d4ffe41a859360b5bb925c82c5d873025da7e834
name: python-dbfread
arch: src
version: 2.0.7
epoch: 0
release: 1
summary: Read DBF Files with Python
url: https://dbfread.readthedocs.io/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3f31a9bb-fe0d-415f-be32-50029ebd5a21
location_href: 00003401-python-dbfread/python-dbfread-2.0.7-1.src.rpm
checksum_type: sha256
description:
  DBF is a file format used by databases such dBase, Visual FoxPro, and
  FoxBase+. This library reads DBF files and returns the data as native
  Python data types for further processing. It is primarily intended for
  batch jobs and one-off scripts.
      >>> from dbfread import DBF
      >>> for record in DBF('people.dbf'):
      OrderedDict([('NAME', 'Alice'), ('BIRTHDATE', datetime.date(1987, 3, 1))])
      OrderedDict([('NAME', 'Bob'), ('BIRTHDATE', datetime.date(1980, 11, 12))])
  By default records are streamed directly from the file.  If you have
  enough memory you can instead load them into a list. This allows for
  random access::
      >>> table = DBF('people.dbf', load=True)
      >>> print(table.records[1]['NAME'])
      Bob
      >>> print(table.records[0]['NAME'])
      Alice
  Full documentation at https://dbfread.readthedocs.io/
  See docs/changes.rst for a full list of changes in each version.


pkgId: a2f317bad0c4c65ce1113908506b04be5c74c89211db9864165a40e9b7f84839
name: python-ddlparse
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: DDL parase and Convert to BigQuery JSON schema
url: http://github.com/shinichi-takii/ddlparse
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4184a48-825f-4389-9829-deab1c8f4a4c
location_href: 00009314-python-ddlparse/python-ddlparse-1.10.0-1.src.rpm
checksum_type: sha256
description:
  - DDL parse and get table schema information.
  - Currently, only the `CREATE TABLE` statement is supported.
  - Convert to [BigQuery JSON schema](https://cloud.google.com/bigquery/docs/schemas#creating_a_json_schema_file) and [BigQuery DDL statements](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language).
  - Supported databases are MySQL/MariaDB, PostgreSQL, Oracle, Redshift.

  1. Python >= 3.5
  1. [pyparsing](https://github.com/pyparsing/pyparsing)


  pip install:
  ```bash
  $ pip install ddlparse
  ```
  command install:
  ```bash
  $ python setup.py install
  ```

  pip update:
  ```bash
  $ pip install ddlparse --upgrade
  ```


  ```python
  import json
  from ddlparse import DdlParse
  sample_ddl = """
  CREATE TABLE My_Schema.Sample_Table (
    Id integer PRIMARY KEY COMMENT 'User ID',
    Name varchar(100) NOT NULL COMMENT 'User name',
    Total bigint NOT NULL,
    Avg decimal(5,1) NOT NULL,
    Point int(10) unsigned,
    Zerofill_Id integer unsigned zerofill NOT NULL,
    Created_At date, -- Oracle 'DATE' -> BigQuery 'DATETIME'
    UNIQUE (NAME)
  );
  """

  table = DdlParse().parse(sample_ddl)

  table = DdlParse().parse(ddl=sample_ddl, source_database=DdlParse.DATABASE.oracle)

  parser = DdlParse(sample_ddl)
  table = parser.parse()
  print("* BigQuery Fields * : normal")
  print(table.to_bigquery_fields())

  parser = DdlParse(ddl=sample_ddl, source_database=DdlParse.DATABASE.oracle)
  table = parser.parse()

  parser = DdlParse()
  parser.ddl = sample_ddl
  table = parser.parse()

  parser = DdlParse()
  parser.source_database = DdlParse.DATABASE.oracle
  parser.ddl = sample_ddl
  table = parser.parse()
  print("* BigQuery Fields * : Oracle")
  print(table.to_bigquery_fields())
  print("* TABLE *")
  print("schema = {} : name = {} : is_temp = {}".format(table.schema, table.name, table.is_temp))
  print("* BigQuery Fields *")
  print(table.to_bigquery_fields())
  print("* BigQuery Fields - column name to lower case / upper case *")
  print(table.to_bigquery_fields(DdlParse.NAME_CASE.lower))
  print(table.to_bigquery_fields(DdlParse.NAME_CASE.upper))
  print("* COLUMN *")
  for col in table.columns.values():
      col_info = {}
      col_info["name"]                  = col.name
      col_info["data_type"]             = col.data_type
      col_info["length"]                = col.length
      col_info["precision(=length)"]    = col.precision
      col_info["scale"]                 = col.scale
      col_info["is_unsigned"]           = col.is_unsigned
      col_info["is_zerofill"]           = col.is_zerofill
      col_info["constraint"]            = col.constraint
      col_info["not_null"]              = col.not_null
      col_info["PK"]                    = col.primary_key
      col_info["unique"]                = col.unique
      col_info["auto_increment"]        = col.auto_increment
      col_info["distkey"]               = col.distkey
      col_info["sortkey"]               = col.sortkey
      col_info["encode"]                = col.encode
      col_info["default"]               = col.default
      col_info["character_set"]         = col.character_set
      col_info["bq_legacy_data_type"]   = col.bigquery_legacy_data_type
      col_info["bq_standard_data_type"] = col.bigquery_standard_data_type
      col_info["comment"]               = col.comment
      col_info["description(=comment)"] = col.description
      col_info["bigquery_field"]        = json.loads(col.to_bigquery_field())
      print(json.dumps(col_info, indent=2, ensure_ascii=False))
  print("* DDL (CREATE TABLE) statements *")
  print(table.to_bigquery_ddl())
  print("* DDL (CREATE TABLE) statements - dataset name, table name and column name to lower case / upper case *")
  print(table.to_bigquery_ddl(DdlParse.NAME_CASE.lower))
  print(table.to_bigquery_ddl(DdlParse.NAME_CASE.upper))
  print("* Get Column object (case insensitive) *")
  print(table.columns["total"])
  print(table.columns["total"].data_type)
  ```

  [BSD 3-Clause License](https://github.com/shinichi-takii/ddlparse/blob/master/LICENSE.md)

  Shinichi Takii <shinichi.takii@shaketh.com>

  - Repository : https://github.com/shinichi-takii/ddlparse
  - PyPI Package : https://pypi.org/project/ddlparse/

  - pyparsing : https://github.com/pyparsing/pyparsing


pkgId: b770efe0d681cf61811e0a1cec7ea6a1a3eb4edd642171b7a4643c8178d3bd23
name: python-deap
arch: src
version: 1.3.3
epoch: 0
release: 1
summary: Distributed Evolutionary Algorithms in Python
url: https://www.github.com/deap
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5831452-3e0b-434c-b8a5-124c33779c63
location_href: 00003405-python-deap/python-deap-1.3.3-1.src.rpm
checksum_type: sha256
description:
  [![Build status](https://travis-ci.org/DEAP/deap.svg?branch=master)](https://travis-ci.org/DEAP/deap) [![Download](https://img.shields.io/pypi/dm/deap.svg)](https://pypi.python.org/pypi/deap) [![Join the chat at https://gitter.im/DEAP/deap](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/DEAP/deap?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![Build Status](https://dev.azure.com/fderainville/DEAP/_apis/build/status/DEAP.deap?branchName=master)](https://dev.azure.com/fderainville/DEAP/_build/latest?definitionId=1&branchName=master) [![Documentation Status](https://readthedocs.org/projects/deap/badge/?version=master)](https://deap.readthedocs.io/en/master/?badge=master)

  DEAP is a novel evolutionary computation framework for rapid prototyping and testing of
  ideas. It seeks to make algorithms explicit and data structures transparent. It works in perfect harmony with parallelisation mechanisms such as multiprocessing and [SCOOP](https://github.com/soravux/scoop).

  DEAP includes the following features:

    * Genetic algorithm using any imaginable representation
      * List, Array, Set, Dictionary, Tree, Numpy Array, etc.
    * Genetic programming using prefix trees
      * Loosely typed, Strongly typed
      * Automatically defined functions
    * Evolution strategies (including CMA-ES)
    * Multi-objective optimisation (NSGA-II, NSGA-III, SPEA2, MO-CMA-ES)
    * Co-evolution (cooperative and competitive) of multiple populations
    * Parallelization of the evaluations (and more)
    * Hall of Fame of the best individuals that lived in the population
    * Checkpoints that take snapshots of a system regularly
    * Benchmarks module containing most common test functions
    * Genealogy of an evolution (that is compatible with [NetworkX](https://github.com/networkx/networkx))
    * Examples of alternative algorithms : Particle Swarm Optimization, Differential Evolution, Estimation of Distribution Algorithm



  Following acceptance of [PEP 438](http://www.python.org/dev/peps/pep-0438/) by the Python community, we have moved DEAP's source releases on [PyPI](https://pypi.python.org).

  You can find the most recent releases at: https://pypi.python.org/pypi/deap/.


  See the [DEAP User's Guide](http://deap.readthedocs.org/) for DEAP documentation.

  In order to get the tip documentation, change directory to the `doc` subfolder and type in `make html`, the documentation will be under `_build/html`. You will need [Sphinx](http://sphinx.pocoo.org) to build the documentation.


  Also checkout our new [notebook examples](https://github.com/DEAP/notebooks). Using [Jupyter notebooks](http://jupyter.org)  you'll be able to navigate and execute each block of code individually and tell what every line is doing. Either, look at the notebooks online using the notebook viewer links at the botom of the page or download the notebooks, navigate to the you download directory and run

  ```bash
  jupyter notebook
  ```


  We encourage you to use easy_install or pip to install DEAP on your system. Other installation procedure like apt-get, yum, etc. usually provide an outdated version.
  ```bash
  pip install deap
  ```

  The latest version can be installed with
  ```bash
  pip install git+https://github.com/DEAP/deap@master
  ```

  If you wish to build from sources, download or clone the repository and type

  ```bash
  python setup.py install
  ```


  DEAP build status is available on Travis-CI https://travis-ci.org/DEAP/deap.


  The most basic features of DEAP requires Python2.6. In order to combine the toolbox and the multiprocessing module Python2.7 is needed for its support to pickle partial functions. CMA-ES requires Numpy, and we recommend matplotlib for visualization of results as it is fully compatible with DEAP's API.

  Since version 0.8, DEAP is compatible out of the box with Python 3.



  The following code gives a quick overview how simple it is to implement the Onemax problem optimization with genetic algorithm using DEAP.  More examples are provided [here](http://deap.readthedocs.org/en/master/examples/index.html).

  ```python
  import random
  from deap import creator, base, tools, algorithms

  creator.create("FitnessMax", base.Fitness, weights=(1.0,))
  creator.create("Individual", list, fitness=creator.FitnessMax)

  toolbox = base.Toolbox()

  toolbox.register("attr_bool", random.randint, 0, 1)
  toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=100)
  toolbox.register("population", tools.initRepeat, list, toolbox.individual)

  def evalOneMax(individual):
      return sum(individual),

  toolbox.register("evaluate", evalOneMax)
  toolbox.register("mate", tools.cxTwoPoint)
  toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
  toolbox.register("select", tools.selTournament, tournsize=3)

  population = toolbox.population(n=300)

  NGEN=40
  for gen in range(NGEN):
      offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
      fits = toolbox.map(toolbox.evaluate, offspring)
      for fit, ind in zip(fits, offspring):
          ind.fitness.values = fit
      population = toolbox.select(offspring, k=len(population))
  top10 = tools.selBest(population, k=10)
  ```


  Authors of scientific papers including results generated using DEAP are encouraged to cite the following paper.

  ```xml
  @article{DEAP_JMLR2012,
      author    = " F\'elix-Antoine Fortin and Fran\c{c}ois-Michel {De Rainville} and Marc-Andr\'e Gardner and Marc Parizeau and Christian Gagn\'e ",
      title     = { {DEAP}: Evolutionary Algorithms Made Easy },
      pages    = { 2171--2175 },
      volume    = { 13 },
      month     = { jul },
      year      = { 2012 },
      journal   = { Journal of Machine Learning Research }
  }
  ```



    * François-Michel De Rainville, Félix-Antoine Fortin, Marc-André Gardner, Marc Parizeau and Christian Gagné, "DEAP -- Enabling Nimbler Evolutions", SIGEVOlution, vol. 6, no 2, pp. 17-26, February 2014. [Paper](http://goo.gl/tOrXTp)
    * Félix-Antoine Fortin, François-Michel De Rainville, Marc-André Gardner, Marc Parizeau and Christian Gagné, "DEAP: Evolutionary Algorithms Made Easy", Journal of Machine Learning Research, vol. 13, pp. 2171-2175, jul 2012. [Paper](http://goo.gl/amJ3x)
    * François-Michel De Rainville, Félix-Antoine Fortin, Marc-André Gardner, Marc Parizeau and Christian Gagné, "DEAP: A Python Framework for Evolutionary Algorithms", in !EvoSoft Workshop, Companion proc. of the Genetic and Evolutionary Computation Conference (GECCO 2012), July 07-11 2012. [Paper](http://goo.gl/pXXug)


    * Ribaric, T., & Houghten, S. (2017, June). Genetic programming for improved cryptanalysis of elliptic curve cryptosystems. In 2017 IEEE Congress on Evolutionary Computation (CEC) (pp. 419-426). IEEE.
    * Ellefsen, Kai Olav, Herman Augusto Lepikson, and Jan C. Albiez. "Multiobjective coverage path planning: Enabling automated inspection of complex, real-world structures." Applied Soft Computing 61 (2017): 264-282.
    * S. Chardon, B. Brangeon, E. Bozonnet, C. Inard (2016), Construction cost and energy performance of single family houses : From integrated design to automated optimization, Automation in Construction, Volume 70, p.1-13.
    * B. Brangeon, E. Bozonnet, C. Inard (2016), Integrated refurbishment of collective housing and optimization process with real products databases, Building Simulation Optimization, pp. 531–538 Newcastle, England.
    * Randal S. Olson, Ryan J. Urbanowicz, Peter C. Andrews, Nicole A. Lavender, La Creis Kidd, and Jason H. Moore (2016). Automating biomedical data science through tree-based pipeline optimization. Applications of Evolutionary Computation, pages 123-137.
    * Randal S. Olson, Nathan Bartley, Ryan J. Urbanowicz, and Jason H. Moore (2016). Evaluation of a Tree-based Pipeline Optimization Tool for Automating Data Science. Proceedings of GECCO 2016, pages 485-492.
    * Van Geit W, Gevaert M, Chindemi G, Rössert C, Courcol J, Muller EB, Schürmann F, Segev I and Markram H (2016). BluePyOpt: Leveraging open source software and cloud infrastructure to optimise model parameters in neuroscience. Front. Neuroinform. 10:17. doi: 10.3389/fninf.2016.00017 https://github.com/BlueBrain/BluePyOpt
    * Lara-Cabrera, R., Cotta, C. and Fernández-Leiva, A.J. (2014). Geometrical vs topological measures for the evolution of aesthetic maps in a rts game, Entertainment Computing,
    * Macret, M. and Pasquier, P. (2013). Automatic Tuning of the OP-1 Synthesizer Using a Multi-objective Genetic Algorithm. In Proceedings of the 10th Sound and Music Computing Conference (SMC). (pp 614-621).
    * Fortin, F. A., Grenier, S., & Parizeau, M. (2013, July). Generalizing the improved run-time complexity algorithm for non-dominated sorting. In Proceeding of the fifteenth annual conference on Genetic and evolutionary computation conference (pp. 615-622). ACM.
    * Fortin, F. A., & Parizeau, M. (2013, July). Revisiting the NSGA-II crowding-distance computation. In Proceeding of the fifteenth annual conference on Genetic and evolutionary computation conference (pp. 623-630). ACM.
    * Marc-André Gardner, Christian Gagné, and Marc Parizeau. Estimation of Distribution Algorithm based on Hidden Markov Models for Combinatorial Optimization. in Comp. Proc. Genetic and Evolutionary Computation Conference (GECCO 2013), July 2013.
    * J. T. Zhai, M. A. Bamakhrama, and T. Stefanov. "Exploiting Just-enough Parallelism when Mapping Streaming Applications in Hard Real-time Systems". Design Automation Conference (DAC 2013), 2013.
    * V. Akbarzadeh, C. Gagné, M. Parizeau, M. Argany, M. A Mostafavi, "Probabilistic Sensing Model for Sensor Placement Optimization Based on Line-of-Sight Coverage", Accepted in IEEE Transactions on Instrumentation and Measurement, 2012.
    * M. Reif, F. Shafait, and A. Dengel. "Dataset Generation for Meta-Learning". Proceedings of the German Conference on Artificial Intelligence (KI'12). 2012.
    * M. T. Ribeiro, A. Lacerda, A. Veloso, and N. Ziviani. "Pareto-Efficient Hybridization for Multi-Objective Recommender Systems". Proceedings of the Conference on Recommanders Systems (!RecSys'12). 2012.
    * M. Pérez-Ortiz, A. Arauzo-Azofra, C. Hervás-Martínez, L. García-Hernández and L. Salas-Morera. "A system learning user preferences for multiobjective optimization of facility layouts". Pr,oceedings on the Int. Conference on Soft Computing Models in Industrial and Environmental Applications (SOCO'12). 2012.
    * Lévesque, J.C., Durand, A., Gagné, C., and Sabourin, R., Multi-Objective Evolutionary Optimization for Generating Ensembles of Classifiers in the ROC Space, Genetic and Evolutionary Computation Conference (GECCO 2012), 2012.
    * Marc-André Gardner, Christian Gagné, and Marc Parizeau, "Bloat Control in Genetic Programming with Histogram-based Accept-Reject Method", in Proc. Genetic and Evolutionary Computation Conference (GECCO 2011), 2011.
    * Vahab Akbarzadeh, Albert Ko, Christian Gagné, and Marc Parizeau, "Topography-Aware Sensor Deployment Optimization with CMA-ES", in Proc. of Parallel Problem Solving from Nature (PPSN 2010), Springer, 2010.
    * DEAP is used in [TPOT](https://github.com/rhiever/tpot), an open source tool that uses genetic programming to optimize machine learning pipelines.
    * DEAP is also used in ROS as an optimization package http://www.ros.org/wiki/deap.
    * DEAP is an optional dependency for [PyXRD](https://github.com/mathijs-dumon/PyXRD), a Python implementation of the matrix algorithm developed for the X-ray diffraction analysis of disordered lamellar structures.
    * DEAP is used in [glyph](https://github.com/Ambrosys/glyph), a library for symbolic regression with applications to [MLC](https://en.wikipedia.org/wiki/Machine_learning_control).
    * DEAP is used in [Sklearn-genetic-opt](https://github.com/rodrigo-arenas/Sklearn-genetic-opt), an open source tool that uses evolutionary programming to fine tune machine learning hyperparameters.

  If you want your project listed here, send us a link and a brief description and we'll be glad to add it.


pkgId: 0bff0b7b9036eac835e90e762879bf47faab5ed7140a3c47eeba19683ea055e0
name: python-deap-debuginfo
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug information for package python-deap
url: https://www.github.com/deap
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a5831452-3e0b-434c-b8a5-124c33779c63
rpm_sourcerpm: python-deap-1.3.3-1.src.rpm
location_href: 00003405-python-deap/python-deap-debuginfo-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-deap.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a441a8cbfe637305c68227ab209eb9f201ce1797749d795b6e40d6dc5dec4bd7
name: python-deap-debugsource
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug sources for package python-deap
url: https://www.github.com/deap
rpm_license: LGPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a5831452-3e0b-434c-b8a5-124c33779c63
rpm_sourcerpm: python-deap-1.3.3-1.src.rpm
location_href: 00003405-python-deap/python-deap-debugsource-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-deap.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 322e7459bb61d86889e561b7e9b232c002e04460b44463a5179f276804357cd7
name: python-debrepo
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Inspect and compare Debian repositories
url: https://pagure.io/debrepo
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6b0c52b6-d3a3-431a-9a50-13acdf4ae41d
location_href: 00003409-python-debrepo/python-debrepo-0.0.3-1.src.rpm
checksum_type: sha256
description:
  **debrepo** is a library for inspecting composes of Debian repositories and
  their elements, including package archives. It includes classes capable of
  reading compose, repository, and package data from the filesystem, and methods
  to compare the data between different versions. To this end, the
  composes.


pkgId: 105c84a6a17a2711b7804c48a07a22e5985e5fe558a22eab226ebf79028be5df
name: python-debtcollector
arch: src
version: 2.5.0
epoch: 0
release: 1
url: https://docs.openstack.org/debtcollector/latest
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d10a184a-1975-47f9-abf6-36bb63a3eae2
location_href: 00003410-python-debtcollector/python-debtcollector-2.5.0-1.src.rpm
checksum_type: sha256
summary:
  A collection of Python deprecation patterns and strategies that help you collect your technical debt in a non-destructive manner.


pkgId: bbdfddaf98a854ded604cfef8a4ce8f5f7586c3340d6e7d32e22e81ea55e0d27
name: python-debugpy
arch: src
version: 1.6.7
epoch: 0
release: 1
summary: An implementation of the Debug Adapter Protocol for Python
url: https://aka.ms/debugpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbba11cb-2e35-4f62-ad13-760ed7d0117b
location_href: 00009037-python-debugpy/python-debugpy-1.6.7-1.src.rpm
checksum_type: sha256
description:
  debugpy is an implementation of the Debug Adapter Protocol for Python.

  The source code and the issue tracker is [hosted on GitHub](https://github.com/microsoft/debugpy/).


pkgId: a5b1b3774275386281ebd55787052088eb97c138c1b865ebbacf5cdda2b8626c
name: python-debugpy-debuginfo
arch: aarch64
version: 1.6.7
epoch: 0
release: 1
summary: Debug information for package python-debugpy
url: https://aka.ms/debugpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cbba11cb-2e35-4f62-ad13-760ed7d0117b
rpm_sourcerpm: python-debugpy-1.6.7-1.src.rpm
location_href: 00009037-python-debugpy/python-debugpy-debuginfo-1.6.7-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-debugpy.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: ffe9debb2a7337f300187d6125a475d1173be052e8f287f1db45e034455ce6fb
name: python-debugpy-debugsource
arch: aarch64
version: 1.6.7
epoch: 0
release: 1
summary: Debug sources for package python-debugpy
url: https://aka.ms/debugpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-cbba11cb-2e35-4f62-ad13-760ed7d0117b
rpm_sourcerpm: python-debugpy-1.6.7-1.src.rpm
location_href: 00009037-python-debugpy/python-debugpy-debugsource-1.6.7-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-debugpy.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: f2cf9593d9ad6176467658eefef619067e3b591dd3427df0d588248183531e33
name: python-decopatch
arch: src
version: 1.4.10
epoch: 0
release: 1
summary: Create decorators easily in python.
url: https://github.com/smarie/python-decopatch
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb3f5f23-6326-4c7d-aa50-d571e5783ce9
location_href: 00003413-python-decopatch/python-decopatch-1.4.10-1.src.rpm
checksum_type: sha256
description:
  [![Python versions](https://img.shields.io/pypi/pyversions/decopatch.svg)](https://pypi.python.org/pypi/decopatch/) [![Build Status](https://github.com/smarie/python-decopatch/actions/workflows/base.yml/badge.svg)](https://github.com/smarie/python-decopatch/actions/workflows/base.yml) [![Tests Status](https://smarie.github.io/python-decopatch/reports/junit/junit-badge.svg?dummy=8484744)](https://smarie.github.io/python-decopatch/reports/junit/report.html) [![Coverage Status](https://smarie.github.io/python-decopatch/reports/coverage/coverage-badge.svg?dummy=8484744)](https://smarie.github.io/python-decopatch/reports/coverage/index.html) [![codecov](https://codecov.io/gh/smarie/python-decopatch/branch/main/graph/badge.svg)](https://codecov.io/gh/smarie/python-decopatch) [![Flake8 Status](https://smarie.github.io/python-decopatch/reports/flake8/flake8-badge.svg?dummy=8484744)](https://smarie.github.io/python-decopatch/reports/flake8/index.html)

  [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-decopatch/) [![PyPI](https://img.shields.io/pypi/v/decopatch.svg)](https://pypi.python.org/pypi/decopatch/) [![Downloads](https://pepy.tech/badge/decopatch)](https://pepy.tech/project/decopatch) [![Downloads per week](https://pepy.tech/badge/decopatch/week)](https://pepy.tech/project/decopatch) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-decopatch.svg)](https://github.com/smarie/python-decopatch/stargazers)

  *python decorators made easy.*

  The documentation for users is available here: [https://smarie.github.io/python-decopatch/](https://smarie.github.io/python-decopatch/)

  A readme for developers is available here: [https://github.com/smarie/python-decopatch](https://github.com/smarie/python-decopatch)


pkgId: 426476089045c928bc650aa61ea3dcbd287dc7af7d1962a0ae27bc1c24b7ff5d
name: python-decorator
arch: src
version: 5.1.1
epoch: 0
release: 1
summary: Decorators for Humans
url: https://github.com/micheles/decorator
rpm_license: new BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ba3e46ab-67e5-455e-8ce7-8f1d7082fbdd
location_href: 00008928-python-decorator/python-decorator-5.1.1-1.src.rpm
checksum_type: sha256
description:
  The goal of the decorator module is to make it easy to define
  signature-preserving function decorators and decorator factories.
  It also includes an implementation of multiple dispatch and other niceties
  (please check the docs). It is released under a two-clauses
  BSD license, i.e. basically you can do whatever you want with it but I am not
  responsible.


pkgId: 11833f52a2cdc6236ed65f29f417b76128f2473b54a48e93eec94d8df471dd69
name: python-deep_merge
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A simple utility for merging python dictionaries.
url: https://github.com/halfak/deep_merge
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f1c7b567-4d14-4187-ba58-56e068131c57
location_href: 00011197-python-deep-merge/python-deep_merge-0.0.4-1.src.rpm
checksum_type: sha256
description:
  This library contains a simple utility for deep-merging dictionaries and the
  data structures they contain.

  * **Installation:** ``pip install deep_merge``
  * **Documentation:** https://pythonhosted.org/deep_merge
  * **Repositiory:** https://github.com/halfak/deep_merge
  * **License:** MIT



      >>> import deep_merge
      >>>
      >>> print(deep_merge.merge({'a': {'b': 10}}, {'a': {'c': 5}}))
      {'a': {'b': 10, 'c': 5}}

  Note that the first parameter is modified and will be assigned the return value.

      >>> d1 = {}
      >>> d2 = {'a': 1}
      >>> deep_merge.merge(d1, d2)
      >>> print(d1)
      {'a': 1}


  * Aaron Halfaker -- https://github.com/halfak


pkgId: bf7c381728984fa6b0c7a1c567444807ae099728275662866bbdb579a2b9a6eb
name: python-deepdiff
arch: src
version: 6.2.3
epoch: 0
release: 1
url: https://github.com/seperman/deepdiff
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3ec35eee-8b36-41ed-bf35-ca5a574acfb3
location_href: 00003414-python-deepdiff/python-deepdiff-6.2.3-1.src.rpm
checksum_type: sha256
summary:
  Deep Difference and Search of any Python object/data. Recreate objects by adding adding deltas to each other.

description:
  ![Downloads](https://img.shields.io/pypi/dm/deepdiff.svg?style=flat)
  ![Python Versions](https://img.shields.io/pypi/pyversions/deepdiff.svg?style=flat)
  ![License](https://img.shields.io/pypi/l/deepdiff.svg?version=latest)
  [![Build Status](https://github.com/seperman/deepdiff/workflows/Unit%20Tests/badge.svg)](https://github.com/seperman/deepdiff/actions)
  [![codecov](https://codecov.io/gh/seperman/deepdiff/branch/master/graph/badge.svg?token=KkHZ3siA3m)](https://codecov.io/gh/seperman/deepdiff)



  - DeepDiff: Deep Difference of dictionaries, iterables, strings and other objects. It will recursively look for all the changes.
  - DeepSearch: Search for objects within other objects.
  - DeepHash: Hash any object based on their content.

  Tested on Python 3.7+ and PyPy3.

  - **[Documentation](https://zepworks.com/deepdiff/6.2.3/)**



  Please check the [ChangeLog](CHANGELOG.md) file for the detailed information.

  DeepDiff 6-2-0

  - Major improvement in the diff report for lists when items are all hashable and the order of items is important.

  DeepDiff 6-1-0

  - DeepDiff.affected_paths can be used to get the list of all paths where a change, addition, or deletion was reported for.
  - DeepDiff.affected_root_keys can be used to get the list of all paths where a change, addition, or deletion was reported for.
  - Bugfix: ValueError when using Decimal 0.x #339  by [Enric Pou](https://github.com/epou)
  - Serialization of UUID

  DeepDiff 6-0-0

  - [Exclude obj callback strict](https://github.com/seperman/deepdiff/pull/320/files) parameter is added to DeepDiff by Mikhail Khviyuzov [mskhviyu](https://github.com/mskhviyu).
  - A fix for diffing using `iterable_compare_func` with nested objects by [dtorres-sf](https://github.com/dtorres-sf) who originally contributed this feature.

  Note: There are no breaking changes in DeepDiff 6 compared to the latest DeepDiff 5 releases.





  `pip install deepdiff`

  If you want to use DeepDiff from commandline:

  `pip install "deepdiff[cli]"`



  ```python
  >>> from deepdiff import DeepDiff  # For Deep Difference of 2 objects
  >>> from deepdiff import grep, DeepSearch  # For finding if item exists in an object
  >>> from deepdiff import DeepHash  # For hashing objects based on their contents
  ```

  Note: if you want to use DeepDiff via commandline, make sure to run `pip install "deepdiff[cli]"`. Then you can access the commands via:

  - DeepDiff
      - `$ deep diff --help`
  - Delta
      - `$ deep patch --help`
  - grep
      - `$ deep grep --help`
  - extract
      - `$ deep extract --help`



  DeepDiff gets the difference of 2 objects.

  > - Please take a look at the [DeepDiff docs](https://zepworks.com/deepdiff/6.2.3/diff.html)
  > - The full documentation of all modules can be found on <https://zepworks.com/deepdiff/6.2.3/>
  > - Tutorials and posts about DeepDiff can be found on <https://zepworks.com/tags/deepdiff/>



  > Note: This is just a brief overview of what DeepDiff can do. Please visit <https://zepworks.com/deepdiff/6.2.3/> for full documentation.



  ```python
  >>> t1 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 2, 3]}}
  >>> t2 = {1:1, 2:2, 3:3, 4:{"a":"hello", "b":[1, 3, 2, 3]}}
  >>> ddiff = DeepDiff(t1, t2, ignore_order=True)
  >>> print (ddiff)
  {}
  ```



  This flag ONLY works when ignoring order is enabled.

  ```python
  t1 = [1, 3, 1, 4]
  t2 = [4, 4, 1]
  ddiff = DeepDiff(t1, t2, ignore_order=True, report_repetition=True)
  print(ddiff)
  ```

  which will print you:

  ```python
  {'iterable_item_removed': {'root[1]': 3},
    'repetition_change': {'root[0]': {'old_repeat': 2,
                                      'old_indexes': [0, 2],
                                      'new_indexes': [2],
                                      'value': 1,
                                      'new_repeat': 1},
                          'root[3]': {'old_repeat': 1,
                                      'old_indexes': [3],
                                      'new_indexes': [0, 1],
                                      'value': 4,
                                      'new_repeat': 2}}}
  ```



  ```python
  >>> l1 = logging.getLogger("test")
  >>> l2 = logging.getLogger("test2")
  >>> t1 = {"log": l1, 2: 1337}
  >>> t2 = {"log": l2, 2: 1337}
  >>> print(DeepDiff(t1, t2, exclude_types={logging.Logger}))
  {}
  ```



  ```python
  >>> t1 = {"for life": "vegan", "ingredients": ["no meat", "no eggs", "no dairy"]}
  >>> t2 = {"for life": "vegan", "ingredients": ["veggies", "tofu", "soy sauce"]}
  >>> print (DeepDiff(t1, t2, exclude_paths={"root['ingredients']"}))
  {}
  ```




  You can also exclude using regular expressions by using `exclude_regex_paths` and pass a set or list of path regexes to exclude. The items in the list could be raw regex strings or compiled regex objects.

  ```python
  >>> t1 = [{'a': 1, 'b': 2}, {'c': 4, 'b': 5}]
  >>> t2 = [{'a': 1, 'b': 3}, {'c': 4, 'b': 5}]
  >>> print(DeepDiff(t1, t2, exclude_regex_paths={r"root\[\d+\]\['b'\]"}))
  {}
  >>> exclude_path = re.compile(r"root\[\d+\]\['b'\]")
  >>> print(DeepDiff(t1, t2, exclude_regex_paths=[exclude_path]))
  {}
  ```



  Digits **after** the decimal point. Internally it uses "{:.Xf}".format(Your Number) to compare numbers where X=significant_digits

  ```python
  >>> t1 = Decimal('1.52')
  >>> t2 = Decimal('1.57')
  >>> DeepDiff(t1, t2, significant_digits=0)
  {}
  >>> DeepDiff(t1, t2, significant_digits=1)
  {'values_changed': {'root': {'old_value': Decimal('1.52'), 'new_value': Decimal('1.57')}}}
  ```



  ```py
  >>> from deepdiff import DeepDiff
  >>> from pprint import pprint
  >>> t1 = [1, 2, 3]
  >>> t2 = [1.0, 2.0, 3.0]
  >>> ddiff = DeepDiff(t1, t2)
  >>> pprint(ddiff, indent=2)
  { 'type_changes': { 'root[0]': { 'new_type': <class 'float'>,
                           'new_value': 1.0,
                           'old_type': <class 'int'>,
                           'old_value': 1},
              'root[1]': { 'new_type': <class 'float'>,
                           'new_value': 2.0,
                           'old_type': <class 'int'>,
                           'old_value': 2},
              'root[2]': { 'new_type': <class 'float'>,
                           'new_value': 3.0,
                           'old_type': <class 'int'>,
                           'old_value': 3}}}
  >>> ddiff = DeepDiff(t1, t2, ignore_type_in_groups=[(int, float)])
  {}
  ```



  Starting with DeepDiff v 3, there are two different views into your diffed data: text view (original) and tree view (new).



  Text view is the original and currently the default view of DeepDiff.

  It is called text view because the results contain texts that represent the path to the data:

  Example of using the text view.

  ```python
  >>> from deepdiff import DeepDiff
  >>> t1 = {1:1, 3:3, 4:4}
  >>> t2 = {1:1, 3:3, 5:5, 6:6}
  >>> ddiff = DeepDiff(t1, t2)
  >>> print(ddiff)
  {'dictionary_item_added': {'root[5]', 'root[6]'}, 'dictionary_item_removed': {'root[4]'}}
  ```

  So for example `ddiff['dictionary_item_removed']` is a set if strings thus this is called the text view.

      The following examples are using the *default text view.*
      The Tree View is introduced in DeepDiff v3
      and provides traversing capabilities through your diffed data and more!
      Read more about the Tree View at the [tree view section](#tree-view) of this page.




  Starting the version v3 You can choose the view into the deepdiff results.
  The tree view provides you with tree objects that you can traverse through to find the parents of the objects that are diffed and the actual objects that are being diffed.




  ```python
  >>> from deepdiff import DeepDiff
  >>> from pprint import pprint
  >>> t1 = {1:1, 2:2, 3:3}
  >>> t2 = {1:1, 2:4, 3:3}
  >>> ddiff_verbose0 = DeepDiff(t1, t2, verbose_level=0, view='tree')
  >>> ddiff_verbose0
  {'values_changed': {<root[2]>}}
  >>>
  >>> ddiff_verbose1 = DeepDiff(t1, t2, verbose_level=1, view='tree')
  >>> ddiff_verbose1
  {'values_changed': {<root[2] t1:2, t2:4>}}
  >>> set_of_values_changed = ddiff_verbose1['values_changed']
  >>> # since set_of_values_changed includes only one item in a set
  >>> # in order to get that one item we can:
  >>> (changed,) = set_of_values_changed
  >>> changed  # Another way to get this is to do: changed=list(set_of_values_changed)[0]
  <root[2] t1:2, t2:4>
  >>> changed.t1
  2
  >>> changed.t2
  4
  >>> # You can traverse through the tree, get to the parents!
  >>> changed.up
  <root t1:{1: 1, 2: 2,...}, t2:{1: 1, 2: 4,...}>
  ```



  In order to convert the DeepDiff object into a normal Python dictionary, use the to_dict() method.
  Note that to_dict will use the text view even if you did the diff in tree view.

  Example:

  ```python
  >>> t1 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": [1, 2, 3]}}
  >>> t2 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": "world\n\n\nEnd"}}
  >>> ddiff = DeepDiff(t1, t2, view='tree')
  >>> ddiff.to_dict()
  {'type_changes': {"root[4]['b']": {'old_type': <class 'list'>, 'new_type': <class 'str'>, 'old_value': [1, 2, 3], 'new_value': 'world\n\n\nEnd'}}}
  ```

  In order to do safe json serialization, use the to_json() method.

  Example:

  ```python
  >>> t1 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": [1, 2, 3]}}
  >>> t2 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": "world\n\n\nEnd"}}
  >>> ddiff = DeepDiff(t1, t2, view='tree')
  >>> ddiff.to_json()
  '{"type_changes": {"root[4][\'b\']": {"old_type": "list", "new_type": "str", "old_value": [1, 2, 3], "new_value": "world\\n\\n\\nEnd"}}}'
  ```


  > - Please take a look at the [DeepDiff docs](https://zepworks.com/deepdiff/6.2.3/diff.html)
  > - The full documentation can be found on <https://zepworks.com/deepdiff/6.2.3/>




  DeepDiff comes with a utility to find the path to the item you are looking for.
  It is called DeepSearch and it has a similar interface to DeepDiff.

  Let's say you have a huge nested object and want to see if any item with the word `somewhere` exists in it.
  Just grep through your objects as you would in shell!

  ```py
  from deepdiff import grep
  obj = {"long": "somewhere", "string": 2, 0: 0, "somewhere": "around"}
  ds = obj | grep("somewhere")
  print(ds)
  ```

  Which will print:

  ```py
  {'matched_paths': {"root['somewhere']"},
   'matched_values': {"root['long']"}}
  ```

  And you can pass all the same kwargs as DeepSearch to grep too:

  ```py
  >>> obj | grep(item, verbose_level=2)
  {'matched_paths': {"root['somewhere']": 'around'}, 'matched_values': {"root['long']": 'somewhere'}}
  ```

  > - Please take a look at the [DeepSearch docs](https://zepworks.com/deepdiff/6.2.3/dsearch.html)
  > - The full documentation can be found on <https://zepworks.com/deepdiff/6.2.3/>


  (New in v4-0-0)

  DeepHash is designed to give you hash of ANY python object based on its contents even if the object is not considered hashable!
  DeepHash is supposed to be deterministic in order to make sure 2 objects that contain the same data, produce the same hash.

  > - Please take a look at the [DeepHash docs](https://zepworks.com/deepdiff/6.2.3/deephash.html)
  > - The full documentation can be found on <https://zepworks.com/deepdiff/6.2.3/>

  Let's say you have a dictionary object.

  ```py
  >>> from deepdiff import DeepHash
  >>>
  >>> obj = {1: 2, 'a': 'b'}
  ```

  If you try to hash it:

  ```py
  >>> hash(obj)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'dict'
  ```

  But with DeepHash:

  ```py
  >>> from deepdiff import DeepHash
  >>> obj = {1: 2, 'a': 'b'}
  >>> DeepHash(obj)
  {4355639248: 2468916477072481777512283587789292749, 4355639280: -35787773492556653776377555218122431491, 4358636128: -88390647972316138151822486391929534118, 4358009664: 8833996863197925870419376694314494743, 4357467952: 34150898645750099477987229399128149852}
  ```

  So what is exactly the hash of obj in this case?
  DeepHash is calculating the hash of the obj and any other object that obj contains.
  The output of DeepHash is a dictionary of object IDs to their hashes.
  In order to get the hash of obj itself, you need to use the object (or the id of object) to get its hash:

  ```py
  >>> hashes = DeepHash(obj)
  >>> hashes[obj]
  34150898645750099477987229399128149852
  ```

  Which you can write as:

  ```py
  >>> hashes = DeepHash(obj)[obj]
  ```

  At first it might seem weird why DeepHash(obj)[obj] but remember that DeepHash(obj) is a dictionary of hashes of all other objects that obj contains too.


  > - Please take a look at the [DeepHash docs](https://zepworks.com/deepdiff/6.2.3/deephash.html)
  > - The full documentation can be found on <https://zepworks.com/deepdiff/6.2.3/>




  `result` is the output of the function that is being tests.
  `expected` is the expected output of the function.

  ```python
  self.assertEqual(DeepDiff(expected, result), {})
  ```

  or if you are using Pytest:


  ```python
  assert not DeepDiff(expected, result)
  ```

  In other words, assert that there is no diff between the expected and the result.



  Unlike [Json Patch](https://tools.ietf.org/html/rfc6902) which is designed only for Json objects, DeepDiff is designed specifically for almost all Python types. In addition to that, DeepDiff checks for type changes and attribute value changes that Json Patch does not cover since there are no such things in Json. Last but not least, DeepDiff gives you the exact path of the item(s) that were changed in Python syntax.

  Example in Json Patch for replacing:

  `{ "op": "replace", "path": "/a/b/c", "value": 42 }`

  Example in DeepDiff for the same operation:

  ```python
  >>> item1 = {'a':{'b':{'c':'foo'}}}
  >>> item2 = {'a':{'b':{'c':42}}}
  >>> DeepDiff(item1, item2)
  {'type_changes': {"root['a']['b']['c']": {'old_type': <type 'str'>, 'new_value': 42, 'old_value': 'foo', 'new_type': <type 'int'>}}}
  ```




  <https://zepworks.com/deepdiff/current/>




  I was honored to give a talk about the basics of how DeepDiff does what it does at Pycon 2016. Please check out the video and let me know what you think:

  [Diff It To Dig It Video](https://www.youtube.com/watch?v=J5r99eJIxF4)
  And here is more info: <http://zepworks.com/blog/diff-it-to-digg-it/>



  Please take a look at the [CHANGELOG](CHANGELOG.md) file.



  We use bump2version to bump and tag releases.

  ```bash
  git checkout master && git pull
  bumpversion {patch|minor|major}
  git push && git push --tags
  ```



  1. Please make your PR against the dev branch
  2. Please make sure that your PR has tests. Since DeepDiff is used in many sensitive data driven projects, we strive to maintain around 100% test coverage on the code.

  Please run `pytest --cov=deepdiff --runslow` to see the coverage report. Note that the `--runslow` flag will run some slow tests too. In most cases you only want to run the fast tests which so you wont add the `--runslow` flag.

  Or to see a more user friendly version, please run: `pytest --cov=deepdiff --cov-report term-missing --runslow`.

  Thank you!



  How to cite this library (APA style):

      Dehpour, S. (2022). DeepDiff (Version 6.2.3) [Software]. Available from https://github.com/seperman/deepdiff.

  How to cite this library (Chicago style):

      Dehpour, Sep. 2022. DeepDiff (version 6.2.3).



  Please take a look at the [AUTHORS](AUTHORS.md) file.


pkgId: d9f98c707a3de7f62895075a2ce3a9fce5844e854101b98ed1f747619974ab43
name: python-deepdiff
arch: src
version: 6.3.0
epoch: 0
release: 1
url: https://github.com/seperman/deepdiff
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-45b6ec69-48c1-46aa-8fd2-427f3fd68fa2
location_href: 00006774-python-deepdiff/python-deepdiff-6.3.0-1.src.rpm
checksum_type: sha256
summary:
  Deep Difference and Search of any Python object/data. Recreate objects by adding adding deltas to each other.

description:
  ![Downloads](https://img.shields.io/pypi/dm/deepdiff.svg?style=flat)
  ![Python Versions](https://img.shields.io/pypi/pyversions/deepdiff.svg?style=flat)
  ![License](https://img.shields.io/pypi/l/deepdiff.svg?version=latest)
  [![Build Status](https://github.com/seperman/deepdiff/workflows/Unit%20Tests/badge.svg)](https://github.com/seperman/deepdiff/actions)
  [![codecov](https://codecov.io/gh/seperman/deepdiff/branch/master/graph/badge.svg?token=KkHZ3siA3m)](https://codecov.io/gh/seperman/deepdiff)



  - [DeepDiff](https://zepworks.com/deepdiff/current/diff.html): Deep Difference of dictionaries, iterables, strings, and ANY other object.
  - [DeepSearch](https://zepworks.com/deepdiff/current/dsearch.html): Search for objects within other objects.
  - [DeepHash](https://zepworks.com/deepdiff/current/deephash.html): Hash any object based on their content.
  - [Delta](https://zepworks.com/deepdiff/current/delta.html): Store the difference of objects and apply them to other objects.
  - [Extract](https://zepworks.com/deepdiff/current/extract.html): Extract an item from a nested Python object using its path.
  - [commandline](https://zepworks.com/deepdiff/current/commandline.html): Use DeepDiff from commandline.

  Tested on Python 3.7+ and PyPy3.

  - **[Documentation](https://zepworks.com/deepdiff/6.3.0/)**



  Please check the [ChangeLog](CHANGELOG.md) file for the detailed information.

  DeepDiff 6-3-0

  - `PrefixOrSuffixOperator`: This operator will skip strings that are suffix or prefix of each other.
  - `include_obj_callback` and `include_obj_callback_strict` are added by [Håvard Thom](https://github.com/havardthom).
  - Fixed a corner case where numpy's `np.float32` nans are not ignored when using `ignore_nan_equality` by [Noam Gottlieb](https://github.com/noamgot)
  - `orjson` becomes optional again.
  - Fix for `ignore_type_in_groups` with numeric values so it does not report number changes when the number types are different.

  DeepDiff 6-2-0

  - Major improvement in the diff report for lists when items are all hashable and the order of items is important.






  `pip install deepdiff`

  If you want to use DeepDiff from commandline:

  `pip install "deepdiff[cli]"`

  If you want to improve the performance of DeepDiff with certain functionalities such as improved json serialization:

  `pip install "deepdiff[optimize]"`



  <https://zepworks.com/deepdiff/current/>



  Please take a look at the [CHANGELOG](CHANGELOG.md) file.



  1. Please make your PR against the dev branch
  2. Please make sure that your PR has tests. Since DeepDiff is used in many sensitive data driven projects, we strive to maintain around 100% test coverage on the code.

  Please run `pytest --cov=deepdiff --runslow` to see the coverage report. Note that the `--runslow` flag will run some slow tests too. In most cases you only want to run the fast tests which so you wont add the `--runslow` flag.

  Or to see a more user friendly version, please run: `pytest --cov=deepdiff --cov-report term-missing --runslow`.

  Thank you!



  How to cite this library (APA style):

      Dehpour, S. (2022). DeepDiff (Version 6.3.0) [Software]. Available from https://github.com/seperman/deepdiff.

  How to cite this library (Chicago style):

      Dehpour, Sep. 2022. DeepDiff (version 6.3.0).



  Please take a look at the [AUTHORS](AUTHORS.md) file.


pkgId: c4fbeb2182446cdb3a2776eacc5cc84ccb968a9a694d8e0270ed18b2f827509d
name: python-deepface
arch: src
version: 0.0.79
epoch: 0
release: 1
url: https://github.com/serengil/deepface
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fd1a63ae-671a-4bc8-9215-8d86d886b0f9
location_href: 00014084-python-deepface/python-deepface-0.0.79-1.src.rpm
checksum_type: sha256
summary:
  A Lightweight Face Recognition and Facial Attribute Analysis Framework (Age, Gender, Emotion, Race) for Python

description:
  <div align="center">

  [![PyPI Downloads](https://static.pepy.tech/personalized-badge/deepface?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pypi%20downloads)](https://pepy.tech/project/deepface)
  [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/deepface?color=green&label=conda%20downloads)](https://anaconda.org/conda-forge/deepface)
  [![Stars](https://img.shields.io/github/stars/serengil/deepface?color=yellow&style=flat)](https://github.com/serengil/deepface/stargazers)
  [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/deepface/blob/master/LICENSE)
  [![Support me on Patreon](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dserengil%26type%3Dpatrons&style=flat)](https://www.patreon.com/serengil?repo=deepface)
  [![GitHub Sponsors](https://img.shields.io/github/sponsors/serengil?logo=GitHub&color=lightgray)](https://github.com/sponsors/serengil)

  [![DOI](http://img.shields.io/:DOI-10.1109/ASYU50717.2020.9259802-blue.svg?style=flat)](https://doi.org/10.1109/ASYU50717.2020.9259802)
  [![DOI](http://img.shields.io/:DOI-10.1109/ICEET53442.2021.9659697-blue.svg?style=flat)](https://doi.org/10.1109/ICEET53442.2021.9659697)
  [![DOI](http://img.shields.io/:DOI-10.33774/coe--2023--18rcn-blue.svg?style=flat)](https://doi.org/10.33774/coe-2023-18rcn)

  [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
  [![YouTube](https://img.shields.io/youtube/channel/subscribers/UCKEKCFtCsvypj2x1Vd_WWXQ?logo=youtube&style=flat)](https://youtube.com/@sefiks)
  [![Twitter](https://img.shields.io/:follow-@serengil-blue.svg?style=flat&logo=twitter)](https://twitter.com/serengil)

  </div>

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/deepface-icon-labeled.png" width="200" height="240"></p>

  Deepface is a lightweight [face recognition](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/) and facial attribute analysis ([age](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [gender](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [emotion](https://sefiks.com/2018/01/01/facial-expression-recognition-with-keras/) and [race](https://sefiks.com/2019/11/11/race-and-ethnicity-prediction-in-keras/)) framework for python. It is a hybrid face recognition framework wrapping **state-of-the-art** models: [`VGG-Face`](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/), [`Google FaceNet`](https://sefiks.com/2018/09/03/face-recognition-with-facenet-in-keras/), [`OpenFace`](https://sefiks.com/2019/07/21/face-recognition-with-openface-in-keras/), [`Facebook DeepFace`](https://sefiks.com/2020/02/17/face-recognition-with-facebook-deepface-in-keras/), [`DeepID`](https://sefiks.com/2020/06/16/face-recognition-with-deepid-in-keras/), [`ArcFace`](https://sefiks.com/2020/12/14/deep-face-recognition-with-arcface-in-keras-and-python/), [`Dlib`](https://sefiks.com/2020/07/11/face-recognition-with-dlib-in-python/) and `SFace`.

  Experiments show that human beings have 97.53% accuracy on facial recognition tasks whereas those models already reached and passed that accuracy level.



  The easiest way to install deepface is to download it from [`PyPI`](https://pypi.org/project/deepface/). It's going to install the library itself and its prerequisites as well.

  ```shell
  $ pip install deepface
  ```

  Secondly, DeepFace is also available at [`Conda`](https://anaconda.org/conda-forge/deepface). You can alternatively install the package via conda.

  ```shell
  $ conda install -c conda-forge deepface
  ```

  Thirdly, you can install deepface from its source code.

  ```shell
  $ git clone https://github.com/serengil/deepface.git
  $ cd deepface
  $ pip install -e .
  ```

  Then you will be able to import the library and use its functionalities.

  ```python
  from deepface import DeepFace
  ```

  **Facial Recognition** - [`Demo`](https://youtu.be/WnUVYQP4h44)

  A modern [**face recognition pipeline**](https://sefiks.com/2020/05/01/a-gentle-introduction-to-face-recognition-in-deep-learning/) consists of 5 common stages: [detect](https://sefiks.com/2020/08/25/deep-face-detection-with-opencv-in-python/), [align](https://sefiks.com/2020/02/23/face-alignment-for-face-recognition-in-python-within-opencv/), [normalize](https://sefiks.com/2020/11/20/facial-landmarks-for-face-recognition-with-dlib/), [represent](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/) and [verify](https://sefiks.com/2020/05/22/fine-tuning-the-threshold-in-face-recognition/). While Deepface handles all these common stages in the background, you don’t need to acquire in-depth knowledge about all the processes behind it. You can just call its verification, find or analysis function with a single line of code.

  **Face Verification** - [`Demo`](https://youtu.be/KRCvkNCOphE)

  This function verifies face pairs as same person or different persons. It expects exact image paths as inputs. Passing numpy or base64 encoded images is also welcome. Then, it is going to return a dictionary and you should check just its verified key.

  ```python
  result = DeepFace.verify(img1_path = "img1.jpg", img2_path = "img2.jpg")
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/stock-1.jpg" width="95%" height="95%"></p>

  Verification function can also handle many faces in the face pairs. In this case, the most similar faces will be compared.

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/verify-many-faces.jpg" width="95%" height="95%"></p>

  **Face recognition** - [`Demo`](https://youtu.be/Hrjp-EStM_s)

  [Face recognition](https://sefiks.com/2020/05/25/large-scale-face-recognition-for-deep-learning/) requires applying face verification many times. Herein, deepface has an out-of-the-box find function to handle this action. It's going to look for the identity of input image in the database path and it will return list of pandas data frame as output. Meanwhile, facial embeddings of the facial database are stored in a pickle file to be searched faster in next time. Result is going to be the size of faces appearing in the source image. Besides, target images in the database can have many faces as well.


  ```python
  dfs = DeepFace.find(img_path = "img1.jpg", db_path = "C:/workspace/my_db")
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/stock-6-v2.jpg" width="95%" height="95%"></p>

  **Embeddings**

  Face recognition models basically represent facial images as multi-dimensional vectors. Sometimes, you need those embedding vectors directly. DeepFace comes with a dedicated representation function. Represent function returns a list of embeddings. Result is going to be the size of faces appearing in the image path.

  ```python
  embedding_objs = DeepFace.represent(img_path = "img.jpg")
  ```

  This function returns an array as embedding. The size of the embedding array would be different based on the model name. For instance, VGG-Face is the default model and it represents facial images as 2622 dimensional vectors.

  ```python
  embedding = embedding_objs[0]["embedding"]
  assert isinstance(embedding, list)
  assert model_name = "VGG-Face" and len(embedding) == 2622
  ```

  Here, embedding is also [plotted](https://sefiks.com/2020/05/01/a-gentle-introduction-to-face-recognition-in-deep-learning/) with 2622 slots horizontally. Each slot is corresponding to a dimension value in the embedding vector and dimension value is explained in the colorbar on the right. Similar to 2D barcodes, vertical dimension stores no information in the illustration.

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/embedding.jpg" width="95%" height="95%"></p>

  **Face recognition models** - [`Demo`](https://youtu.be/i_MOwvhbLdI)

  Deepface is a **hybrid** face recognition package. It currently wraps many **state-of-the-art** face recognition models: [`VGG-Face`](https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/) , [`Google FaceNet`](https://sefiks.com/2018/09/03/face-recognition-with-facenet-in-keras/), [`OpenFace`](https://sefiks.com/2019/07/21/face-recognition-with-openface-in-keras/), [`Facebook DeepFace`](https://sefiks.com/2020/02/17/face-recognition-with-facebook-deepface-in-keras/), [`DeepID`](https://sefiks.com/2020/06/16/face-recognition-with-deepid-in-keras/), [`ArcFace`](https://sefiks.com/2020/12/14/deep-face-recognition-with-arcface-in-keras-and-python/), [`Dlib`](https://sefiks.com/2020/07/11/face-recognition-with-dlib-in-python/) and `SFace`. The default configuration uses VGG-Face model.

  ```python
  models = [
    "VGG-Face",
    "Facenet",
    "Facenet512",
    "OpenFace",
    "DeepFace",
    "DeepID",
    "ArcFace",
    "Dlib",
    "SFace",
  ]


  result = DeepFace.verify(img1_path = "img1.jpg",
        img2_path = "img2.jpg",
        model_name = models[0]
  )


  dfs = DeepFace.find(img_path = "img1.jpg",
        db_path = "C:/workspace/my_db",
        model_name = models[1]
  )


  embedding_objs = DeepFace.represent(img_path = "img.jpg",
        model_name = models[2]
  )
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/model-portfolio-v8.jpg" width="95%" height="95%"></p>

  FaceNet, VGG-Face, ArcFace and Dlib are [overperforming](https://youtu.be/i_MOwvhbLdI) ones based on experiments. You can find out the scores of those models below on both [Labeled Faces in the Wild](https://sefiks.com/2020/08/27/labeled-faces-in-the-wild-for-face-recognition/) and YouTube Faces in the Wild data sets declared by its creators.

  | Model | LFW Score | YTF Score |
  | ---   | --- | --- |
  | Facenet512 | 99.65% | - |
  | SFace | 99.60% | - |
  | ArcFace | 99.41% | - |
  | Dlib | 99.38 % | - |
  | Facenet | 99.20% | - |
  | VGG-Face | 98.78% | 97.40% |
  | *Human-beings* | *97.53%* | - |
  | OpenFace | 93.80% | - |
  | DeepID | - | 97.05% |

  **Similarity**

  Face recognition models are regular [convolutional neural networks](https://sefiks.com/2018/03/23/convolutional-autoencoder-clustering-images-with-neural-networks/) and they are responsible to represent faces as vectors. We expect that a face pair of same person should be [more similar](https://sefiks.com/2020/05/22/fine-tuning-the-threshold-in-face-recognition/) than a face pair of different persons.

  Similarity could be calculated by different metrics such as [Cosine Similarity](https://sefiks.com/2018/08/13/cosine-similarity-in-machine-learning/), Euclidean Distance and L2 form. The default configuration uses cosine similarity.

  ```python
  metrics = ["cosine", "euclidean", "euclidean_l2"]


  result = DeepFace.verify(img1_path = "img1.jpg",
            img2_path = "img2.jpg",
            distance_metric = metrics[1]
  )


  dfs = DeepFace.find(img_path = "img1.jpg",
            db_path = "C:/workspace/my_db",
            distance_metric = metrics[2]
  )
  ```

  Euclidean L2 form [seems](https://youtu.be/i_MOwvhbLdI) to be more stable than cosine and regular Euclidean distance based on experiments.

  **Facial Attribute Analysis** - [`Demo`](https://youtu.be/GT2UeN85BdA)

  Deepface also comes with a strong facial attribute analysis module including [`age`](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [`gender`](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/), [`facial expression`](https://sefiks.com/2018/01/01/facial-expression-recognition-with-keras/) (including angry, fear, neutral, sad, disgust, happy and surprise) and [`race`](https://sefiks.com/2019/11/11/race-and-ethnicity-prediction-in-keras/) (including asian, white, middle eastern, indian, latino and black) predictions. Result is going to be the size of faces appearing in the source image.

  ```python
  objs = DeepFace.analyze(img_path = "img4.jpg",
          actions = ['age', 'gender', 'race', 'emotion']
  )
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/stock-2.jpg" width="95%" height="95%"></p>

  Age model got ± 4.65 MAE; gender model got 97.44% accuracy, 96.29% precision and 95.05% recall as mentioned in its [tutorial](https://sefiks.com/2019/02/13/apparent-age-and-gender-prediction-in-keras/).


  **Face Detectors** - [`Demo`](https://youtu.be/GZ2p2hj2H5k)

  Face detection and alignment are important early stages of a modern face recognition pipeline. Experiments show that just alignment increases the face recognition accuracy almost 1%. [`OpenCV`](https://sefiks.com/2020/02/23/face-alignment-for-face-recognition-in-python-within-opencv/), [`SSD`](https://sefiks.com/2020/08/25/deep-face-detection-with-opencv-in-python/), [`Dlib`](https://sefiks.com/2020/07/11/face-recognition-with-dlib-in-python/),  [`MTCNN`](https://sefiks.com/2020/09/09/deep-face-detection-with-mtcnn-in-python/), [`RetinaFace`](https://sefiks.com/2021/04/27/deep-face-detection-with-retinaface-in-python/) and [`MediaPipe`](https://sefiks.com/2022/01/14/deep-face-detection-with-mediapipe/) detectors are wrapped in deepface.

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/detector-portfolio-v3.jpg" width="95%" height="95%"></p>

  All deepface functions accept an optional detector backend input argument. You can switch among those detectors with this argument. OpenCV is the default detector.

  ```python
  backends = [
    'opencv',
    'ssd',
    'dlib',
    'mtcnn',
    'retinaface',
    'mediapipe'
  ]


  obj = DeepFace.verify(img1_path = "img1.jpg",
          img2_path = "img2.jpg",
          detector_backend = backends[0]
  )


  dfs = DeepFace.find(img_path = "img.jpg",
          db_path = "my_db",
          detector_backend = backends[1]
  )


  embedding_objs = DeepFace.represent(img_path = "img.jpg",
          detector_backend = backends[2]
  )


  demographies = DeepFace.analyze(img_path = "img4.jpg",
          detector_backend = backends[3]
  )


  face_objs = DeepFace.extract_faces(img_path = "img.jpg",
          target_size = (224, 224),
          detector_backend = backends[4]
  )
  ```

  Face recognition models are actually CNN models and they expect standard sized inputs. So, resizing is required before representation. To avoid deformation, deepface adds black padding pixels according to the target size argument after detection and alignment.

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/deepface-detectors-v3.jpg" width="90%" height="90%"></p>

  [RetinaFace](https://sefiks.com/2021/04/27/deep-face-detection-with-retinaface-in-python/) and [MTCNN](https://sefiks.com/2020/09/09/deep-face-detection-with-mtcnn-in-python/) seem to overperform in detection and alignment stages but they are much slower. If the speed of your pipeline is more important, then you should use opencv or ssd. On the other hand, if you consider the accuracy, then you should use retinaface or mtcnn.

  The performance of RetinaFace is very satisfactory even in the crowd as seen in the following illustration. Besides, it comes with an incredible facial landmark detection performance. Highlighted red points show some facial landmarks such as eyes, nose and mouth. That's why, alignment score of RetinaFace is high as well.

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/retinaface-results.jpeg" width="90%" height="90%">
  <br><em>The Yellow Angels - Fenerbahce Women's Volleyball Team</em>
  </p>

  You can find out more about RetinaFace on this [repo](https://github.com/serengil/retinaface).

  **Real Time Analysis** - [`Demo`](https://youtu.be/-c9sSJcx6wI)

  You can run deepface for real time videos as well. Stream function will access your webcam and apply both face recognition and facial attribute analysis. The function starts to analyze a frame if it can focus a face sequentially 5 frames. Then, it shows results 5 seconds.

  ```python
  DeepFace.stream(db_path = "C:/User/Sefik/Desktop/database")
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/stock-3.jpg" width="90%" height="90%"></p>

  Even though face recognition is based on one-shot learning, you can use multiple face pictures of a person as well. You should rearrange your directory structure as illustrated below.

  ```bash
  user
  ├── database
  │   ├── Alice
  │   │   ├── Alice1.jpg
  │   │   ├── Alice2.jpg
  │   ├── Bob
  │   │   ├── Bob.jpg
  ```

  **API** - [`Demo`](https://youtu.be/HeKCQ6U9XmI)

  DeepFace serves an API as well. You can clone [`/api`](https://github.com/serengil/deepface/tree/master/api) folder and run the api via gunicorn server. This will get a rest service up. In this way, you can call deepface from an external system such as mobile app or web.

  ```shell
  cd scripts
  ./service.sh
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/deepface-api.jpg" width="90%" height="90%"></p>

  Face recognition, facial attribute analysis and vector representation functions are covered in the API. You are expected to call these functions as http post methods. Default service endpoints will be `http://localhost:5000/verify` for face recognition, `http://localhost:5000/analyze` for facial attribute analysis, and `http://localhost:5000/represent` for vector representation. You can pass input images as exact image paths on your environment, base64 encoded strings or images on web. [Here](https://github.com/serengil/deepface/tree/master/api), you can find a postman project to find out how these methods should be called.

  **Dockerized Service**

  You can deploy the deepface api on a kubernetes cluster with docker. The following [shell script](https://github.com/serengil/deepface/blob/master/scripts/dockerize.sh) will serve deepface on `localhost:5000`. You need to re-configure the [Dockerfile](https://github.com/serengil/deepface/blob/master/Dockerfile) if you want to change the port. Then, even if you do not have a development environment, you will be able to consume deepface services such as verify and analyze. You can also access the inside of the docker image to run deepface related commands. Please follow the instructions in the [shell script](https://github.com/serengil/deepface/blob/master/scripts/dockerize.sh).

  ```shell
  cd scripts
  ./dockerize.sh
  ```

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/deepface-dockerized-v2.jpg" width="50%" height="50%"></p>

  **Command Line Interface**

  DeepFace comes with a command line interface as well. You are able to access its functions in command line as shown below. The command deepface expects the function name as 1st argument and function arguments thereafter.

  ```shell

  $ deepface verify -img1_path tests/dataset/img1.jpg -img2_path tests/dataset/img2.jpg


  $ deepface analyze -img_path tests/dataset/img1.jpg
  ```

  You can also run these commands if you are running deepface with docker. Please follow the instructions in the [shell script](https://github.com/serengil/deepface/blob/master/scripts/dockerize.sh#L17).

  **Tech Stack** - [`Vlog`](https://youtu.be/R8fHsL7u3eE), [`Tutorial`](https://sefiks.com/2021/03/31/tech-stack-recommendations-for-face-recognition/)

  Face recognition models represent facial images as vector embeddings. The idea behind facial recognition is that vectors should be more similar for same person than different persons. The question is that where and how to store facial embeddings in a large scale system. Tech stack is vast to store vector embeddings. To determine the right tool, you should consider your task such as face verification or face recognition, priority such as speed or confidence, and also data size.

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/tech-stack-v2.jpg" width="90%" height="90%"></p>



  You can use deepface not just for facial recognition tasks. It's very common to use DeepFace for entertainment purposes. For instance, celebrity look-alike prediction and parental look-alike prediction tasks can be done with DeepFace!

  **Parental Look-Alike Prediction** - [`Vlog`](https://youtu.be/nza4tmi9vhE), [`Tutorial`](https://sefiks.com/2022/12/22/decide-whom-your-child-looks-like-with-facial-recognition-mommy-or-daddy/)

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/parental-look-alike-v2.jpg" width="90%" height="90%"></p>

  **Celebrity Look-Alike Prediction** - [`Vlog`](https://youtu.be/jaxkEn-Kieo), [`Tutorial`](https://sefiks.com/2019/05/05/celebrity-look-alike-face-recognition-with-deep-learning-in-keras/)

  <p align="center"><img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/look-alike-v3.jpg" width="90%" height="90%"></p>



  Pull requests are more than welcome! You should run the unit tests locally by running [`test/unit_tests.py`](https://github.com/serengil/deepface/blob/master/tests/unit_tests.py) before creating a PR. Once a PR sent, GitHub test workflow will be run automatically and unit test results will be available in [GitHub actions](https://github.com/serengil/deepface/actions) before approval. Besides, workflow will evaluate the code with pylint as well.



  There are many ways to support a project - starring⭐️ the GitHub repo is just one 🙏

  You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=deepface) or [GitHub Sponsors](https://github.com/sponsors/serengil).

  <a href="https://www.patreon.com/serengil?repo=deepface">
  <img src="https://raw.githubusercontent.com/serengil/deepface/master/icon/patreon.png" width="30%" height="30%">
  </a>



  Please cite deepface in your publications if it helps your research. Here are its BibTex entries:

  <!-- If you use deepface for facial recogntion purposes, please cite the this publication. -->

  ```BibTeX
  @inproceedings{serengil2020lightface,
    title        = {LightFace: A Hybrid Deep Face Recognition Framework},
    author       = {Serengil, Sefik Ilkin and Ozpinar, Alper},
    booktitle    = {2020 Innovations in Intelligent Systems and Applications Conference (ASYU)},
    pages        = {23-27},
    year         = {2020},
    doi          = {10.1109/ASYU50717.2020.9259802},
    url          = {https://doi.org/10.1109/ASYU50717.2020.9259802},
    organization = {IEEE}
  }
  ```

  <!-- If you use deepface for facial attribute analysis purposes such as age, gender, emotion or ethnicity prediction, please cite the this publication. -->

  ```BibTeX
  @inproceedings{serengil2021lightface,
    title        = {HyperExtended LightFace: A Facial Attribute Analysis Framework},
    author       = {Serengil, Sefik Ilkin and Ozpinar, Alper},
    booktitle    = {2021 International Conference on Engineering and Emerging Technologies (ICEET)},
    pages        = {1-4},
    year         = {2021},
    doi          = {10.1109/ICEET53442.2021.9659697},
    url          = {https://doi.org/10.1109/ICEET53442.2021.9659697},
    organization = {IEEE}
  }
  ```

  ```BibTeX
  @misc{serengil2023db,
    author       = {Serengil, Sefik Ilkin and Ozpinar, Alper},
    title        = {An Evaluation of SQL and NoSQL Databases for Facial Recognition Pipelines},
    year         = {2023},
    publisher    = {Cambridge Open Engage},
    doi          = {10.33774/coe-2023-18rcn},
    url          = {https://doi.org/10.33774/coe-2023-18rcn},
    howpublished = {https://www.cambridge.org/engage/coe/article-details/63f3e5541d2d184063d4f569},
    note         = {Preprint}
  ```

  Also, if you use deepface in your GitHub projects, please add `deepface` in the `requirements.txt`.



  Deepface is licensed under the MIT License - see [`LICENSE`](https://github.com/serengil/deepface/blob/master/LICENSE) for more details. However, the library wraps some external face recognition models: [VGG-Face](http://www.robots.ox.ac.uk/~vgg/software/vgg_face/), [Facenet](https://github.com/davidsandberg/facenet/blob/master/LICENSE.md), [OpenFace](https://github.com/iwantooxxoox/Keras-OpenFace/blob/master/LICENSE), [DeepFace](https://github.com/swghosh/DeepFace), [DeepID](https://github.com/Ruoyiran/DeepID/blob/master/LICENSE.md), [ArcFace](https://github.com/leondgarse/Keras_insightface/blob/master/LICENSE), [Dlib](https://github.com/davisking/dlib/blob/master/dlib/LICENSE.txt), and [SFace](https://github.com/opencv/opencv_zoo/blob/master/models/face_recognition_sface/LICENSE). Besides, age, gender and race / ethnicity models are based on VGG-Face. Licence types will be inherited if you are going to use those models. Please check the license types of those models for production purposes.

  Deepface [logo](https://thenounproject.com/term/face-recognition/2965879/) is created by [Adrien Coquet](https://thenounproject.com/coquet_adrien/) and it is licensed under [Creative Commons: By Attribution 3.0 License](https://creativecommons.org/licenses/by/3.0/).


pkgId: b1a73990945bc19244fda47a5cde8592917f80dc2eab46141a01f36ed992f359
name: python-deepspeed
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: DeepSpeed library
url: http://deepspeed.ai
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6e4271b-e857-4b98-b631-8c55498e64f1
location_href: 00013230-python-deepspeed/python-deepspeed-0.8.3-1.src.rpm
checksum_type: sha256
description:
  [DeepSpeed](https://www.deepspeed.ai/) is an easy-to-use deep learning optimization software suite that enables unprecedented scale and speed for Deep Learning Training and Inference. With DeepSpeed you can:
  * Train/Inference dense or sparse models with billions or trillions of parameters
  * Achieve excellent system throughput and efficiently scale to thousands of GPUs
  * Train/Inference on resource constrained GPU systems
  * Achieve unprecedented low latency and high throughput for inference


pkgId: b995f6d6f483eeb6e47fbc83940585c9b5c9ff25691c664746a779b13acde7c8
name: python-defcon
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: A set of flexible objects for representing UFO data.
url: https://github.com/robotools/defcon
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4e7527d9-96a0-4d2c-8b3b-8f9821202103
location_href: 00003415-python-defcon/python-defcon-0.10.2-1.src.rpm
checksum_type: sha256
description:
  Defcon is a set of UFO based objects optimized for use in font editing
  applications. The objects are built to be lightweight, fast and
  flexible. The objects are very bare-bones and they are not meant to be
  end-all, be-all objects. Rather, they are meant to provide base
  functionality so that you can focus on your application’s behavior, not
  object observing or maintaining cached data. Defcon implements UFO3 as
  described by the `UFO font format <http://unifiedfontobject.org>`_. If
  needed, the
  `ufo2-deprecated <https://github.com/typesupply/defcon/tree/ufo2-deprecated>`_
  branch has the older, UFO2, version of Defcon.
  Install
  ~~~~~~~
  To download and install the latest stable release of defcon from the
  `Python Package Index <https://pypi.python.org/pypi/defcon>`_, use the
  `pip <https://pip.pypa.io/en/stable/installing/>`_ command line tool:
    pip install --upgrade defcon
  To install with the `fontPens <https://github.com/robofab-developers/fontPens>`_ package —used for ``Glyph.correctDirection()`` and ``Contour.contourInside()``— do:
    pip install --upgrade defcon[pens]
  To optionally install defcon with support for `lxml <https://github.com/lxml/lxml>`_,
  a faster XML reader and writer library, you can do:
    pip install --upgrade defcon[lxml]
  You can separate multiple extras using a comma: ``defcon[pens,lxml]``.
  Documentation
  ~~~~~~~~~~~~~
  Documentation for Defcon lives at
  `defcon.robotools.dev <http://defcon.robotools.dev/en/latest/>`_.
  Copyrights
  ~~~~~~~~~~
  This package is distributed under the MIT license. See the
  `license <License.txt>`_. Defcon is built in
  `Python <http://www.python.org>`_. Parts of RoboFab use
  `fontTools <https://github.com/behdad/fonttools>`_, an OpenSource font
  toolkit started by Just van Rossum. Parts of Defcon implement the
  Property List file format in XML, copyright
  `Apple Computer <http://www.apple.com>`_. Parts of Defcon implement tables and
  names from PostScript and the OpenType FDK, copyright
  `Adobe <http://www.adobe.com>`_.


pkgId: 687f642c5da4c123a020e804a6420c6cbca84bd6efcf414133faf9bb93097c14
name: python-delighted
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Delighted API Python Client.
url: https://delighted.com/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fde18bbf-067e-4adf-bb4e-bd1c9e95ea92
location_href: 00011025-python-delighted/python-delighted-4.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/delighted/delighted-python.svg?branch=master)](https://travis-ci.org/delighted/delighted-python)



  Official Python client for the [Delighted API](https://delighted.com/docs/api).



  ```
  pip install --upgrade delighted
  ```

  or

  ```
  easy_install --upgrade delighted
  ```



  If you previously used the python package named `delighted-python`, please note that the package name is now just `delighted`.



  To get started, you need to configure the client with your secret API key.

  ```python
  import delighted
  delighted.api_key = 'YOUR_API_KEY'
  ```

  For further options, read the [advanced configuration section](#advanced-configuration).

  **Note:** Your API key is secret, and you should treat it like a password. You can find your API key in your Delighted account, under *Settings* > *API*.



  Adding/updating people and scheduling surveys:

  ```python

  person1 = delighted.Person.create(email='foo+test1@delighted.com')


  person2 = delighted.Person.create(email='foo+test2@delighted.com', delay=60)


  person3 = delighted.Person.create(email='foo+test3@delighted.com', send=False)



  person4 = delighted.Person.create(
          email='foo+test4@delighted.com',
          name='Joe Bloggs',
          properties={'customer_id': 123, 'country': 'USA',
                      'question_product_name': 'The London Trench'},
          delay=30)



  updated_person1 = delighted.Person.create(email='foo+test1@delighted.com',
                                            name='James Scott', send=False)
  ```

  Unsubscribing people:

  ```python

  delighted.Unsubscribe.create(person_email='foo+test1@delighted.com')
  ```

  Listing people:

  ```python


  people = delighted.Person.list()
  while True:
      try:
          for person in people.auto_paging_iter():
              
      except TooManyRequestsError as e:
          
          e.retry_after
          continue


  people = delighted.Person.list(auto_handle_rate_limits=True)
  for person in people.auto_paging_iter():
      
  ```

  Listing people who have unsubscribed:

  ```python

  delighted.Unsubscribe.all()
  delighted.Unsubscribe.all(page=2)
  ```

  Listing people whose emails have bounced:

  ```python

  delighted.Bounce.all()
  delighted.Bounce.all(page=2)
  ```

  Deleting a person and all of the data associated with them:

  ```python

  delighted.Person.delete(id=42)

  delighted.Person.delete(email='test@example.com')

  delighted.Person.delete(phone_number='+14155551212')
  ```

  Deleting pending survey requests

  ```python

  delighted.SurveyRequest.delete_pending(person_email='foo+test1@delighted.com')
  ```

  Adding survey responses:

  ```python

  survey_response1 = delighted.SurveyResponse.create(person=person1.id,
                                                     score=10)


  survey_response2 = delighted.SurveyResponse.create(person=person1.id,
                                                     score=5,
                                                     comment='Really nice.')
  ```

  Retrieving a survey response:

  ```python

  survey_response3 = delighted.SurveyResponse.retrieve('123')
  ```

  Updating survey responses:

  ```python

  survey_response4 = delighted.SurveyResponse.retrieve('234')
  survey_response4.score = 10
  survey_response4.save()



  survey_response4.person_properties = {'segment': 'Online'}
  survey_response4.save()



  survey_response4.person = '321'
  survey_response4.save()

  ```

  Listing survey responses:

  ```python

  survey_responses_page1 = delighted.SurveyResponse.all()
  survey_responses_page2 = delighted.SurveyResponse.all(page=2)


  survey_responses_page1_expanded = delighted.SurveyResponse.all(expand=['person'])
  survey_responses_page1_expanded[0].person



  survey_responses_page1_trend = delighted.SurveyResponse.all(trend='123')


  survey_responses_page1_desc = delighted.SurveyResponse.all(order='desc')


  import pytz
  timezone = pytz.timezone('America/Chicago')
  filtered_survey_responses = delighted.SurveyResponse.all(
      page=5,
      per_page=100,
      since=timezone.localize(datetime.datetime(2014, 3, 1)),
      until=timezone.localize(datetime.datetime(2014, 4, 30))
  )
  ```

  Retrieving metrics:

  ```python

  metrics = delighted.Metrics.retrieve()



  metrics = delighted.Metrics.retrieve(trend='123')


  import pytz
  timezone = pytz.timezone('America/Chicago')
  metrics = delighted.Metrics.retrieve(
      since=timezone.localize(datetime.datetime(2013, 10, 1)),
      until=timezone.localize(datetime.datetime(2013, 11, 1))
  )
  ```

  Managing Autopilot:

  ```python

  autopilot = delighted.AutopilotConfiguration.retrieve('email')


  people_autopilot = delighted.AutopilotMembership.forEmail().list(auto_handle_rate_limits=True)
  for person in people_autopilot.auto_paging_iter():
    


  autopilot = delighted.AutopilotMembership.forEmail().create(person_email='test@example.com')


  properties = {'customer_id': 123, 'country': 'USA', 'question_product_name': 'The London Trench'}
  autopilot = delighted.AutopilotMembership.forSms().create(person_phone_number='+14155551212', properties=properties)


  delighted.AutopilotMembership.forSms().delete(person_id=42)


  delighted.AutopilotMembership.forEmail().delete(person_email='test@example.com')


  delighted.AutopilotMembership.forSms().delete(person_phone_number='+14155551212')
  ```



  If a request is rate limited, a `TooManyRequestsError` exception is raised. You can rescue that exception to implement exponential backoff or retry strategies. The exception provides a `retry_after` attribute to tell you how many seconds you should wait before retrying. For example:

  ```python
  try:
      metrics = delighted.Metrics.retrieve()
  except delighted.errors.TooManyRequestsError as err:
      retry_after_seconds = err.retry_after
      
      
  ```



  The following options are configurable for the client:

  ```python
  delighted.api_key
  delighted.api_base_url # default: 'https://api.delighted.com/v1/'
  delighted.http_adapter # default: delighted.HTTPAdapter
  ```

  By default, a shared instance of `delighted.Client` is created lazily in `delighted.get_shared_client()`. If you want to create your own client, perhaps for test or if you have multiple API keys, you can:

  ```python

  import delighted
  from delighted import Client
  client = Client(api_key='API_KEY',
                  api_base_url='https://api.delighted.com/v1/',
                  http_adapter=HTTPAdapter())
  metrics_from_custom_client = delighted.Metrics.retrieve(client=client)


  delighted.shared_client = delighted.Client(
      api_key='API_KEY',
      api_base_url='https://api.delighted.com/v1/',
      http_adapter=delighted.HTTPAdapter()
  )
  metrics_from_custom_shared_client = delighted.Metrics.retrieve()
  ```



  - 2.6+, 3.3+ (PyPy supported)



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



  1. Bump the version in `delighted/__init__.py`.
  2. Update the README and CHANGELOG as needed.
  3. Tag the commit for release.
  4. Create the distribution `python setup.py sdist`
  5. Update the package against PyPI's test server with [twine](https://pypi.org/project/twine/)
  `twine upload --repository-url https://test.pypi.org/legacy/ dist/TEST_PACKAGE_NAME`.
  6. If (4 and 5) work, repeat all steps, then push to PyPI's live servers with `twine upload dist/PACKAGE_NAME`.



  Originally by [Jason Pearson](https://github.com/kaeawc). Graciously transfered and now officially maintained by Delighted.


pkgId: 023a40a58c59fe71166d5112bf81df3da8b732288430b89028f3e813ca3b067c
name: python-delta-sharing
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: Python Connector for Delta Sharing
url: https://github.com/delta-io/delta-sharing/
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df31b305-652f-4c1d-8c49-08097c682649
location_href: 00012443-python-delta-sharing/python-delta-sharing-0.6.3-1.src.rpm
checksum_type: sha256
description:
  [Delta Sharing](https://delta.io/sharing) is an open protocol for secure real-time exchange of large datasets, which enables secure data sharing across different computing platforms. It lets organizations share access to existing [Delta Lake](https://delta.io) and [Apache Parquet](https://parquet.apache.org) tables with other organizations, who can then directly read the table in Pandas, Apache Spark, or any other software that implements the open protocol.

  This is the Python client library for Delta Sharing, which lets you load shared tables as [pandas](https://pandas.pydata.org/) DataFrames or as [Apache Spark](http://spark.apache.org/) DataFrames if running in PySpark with the [Apache Spark Connector library](https://github.com/delta-io/delta-sharing#set-up-apache-spark).



  1. Install using `pip install delta-sharing`.
  2. To use the Python Connector, see [the project docs](https://github.com/delta-io/delta-sharing) for details.



  This README only contains basic information about the Delta Sharing Python Connector. Please read [the project documentation](https://github.com/delta-io/delta-sharing) for full usage details.


pkgId: 3af7448dd20048859f19e4b8f919ce8a0f309f9b306ffa55a83fccbf09ec2696
name: python-demjson
arch: src
version: 2.2.4
epoch: 0
release: 1
summary: encoder, decoder, and lint/validator for JSON (JavaScript Object Notation) compliant with RFC 7159
url: http://deron.meranda.us/python/demjson/
rpm_license: GNU LGPL 3.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22966c68-eac0-4720-9839-6b0b8df6114a
location_href: 00003416-python-demjson/python-demjson-2.2.4-1.src.rpm
checksum_type: sha256
description:
  The "demjson" module, and the included "jsonlint" script, provide methods
  for encoding and decoding JSON formatted data, as well as checking JSON
  data for errors and/or portability issues.  The jsonlint command/script
  can be used from the command line without needing any programming.

  Although the standard Python library now includes basic JSON support
  (which it did not when demjson was first written), this module
  provides a much more comprehensive implementation with many features
  not found elsewhere.  It is especially useful for error checking or
  for parsing JavaScript data which may not strictly be valid JSON data.


pkgId: a5fcd2082de5a9954dd16c6e6ca79aee4fcc865fbf49cdbeeb1275b60d06b35d
name: python-dependency-injector
arch: src
version: 4.41.0
epoch: 0
release: 1
summary: Dependency injection framework for Python
url: https://github.com/ets-labs/python-dependency-injector
rpm_license: BSD New
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-58cec383-352f-4046-b880-d7e5d343a8bb
location_href: 00009859-python-dependency-injector/python-dependency-injector-4.41.0-1.src.rpm
checksum_type: sha256
description:
  ``Dependency Injector`` is a dependency injection framework for Python.
  It helps implement the dependency injection principle.
  Key features of the ``Dependency Injector``:
  - **Providers**. Provides ``Factory``, ``Singleton``, ``Callable``, ``Coroutine``, ``Object``,
    ``List``, ``Dict``, ``Configuration``, ``Resource``, ``Dependency``, and ``Selector`` providers
    that help assemble your objects.
    See `Providers <https://python-dependency-injector.ets-labs.org/providers/index.html>`_.
  - **Overriding**. Can override any provider by another provider on the fly. This helps in testing
    and configuring dev/stage environment to replace API clients with stubs etc. See
    `Provider overriding <https://python-dependency-injector.ets-labs.org/providers/overriding.html>`_.
  - **Configuration**. Reads configuration from ``yaml``, ``ini``, and ``json`` files, ``pydantic`` settings,
    environment variables, and dictionaries.
    See `Configuration provider <https://python-dependency-injector.ets-labs.org/providers/configuration.html>`_.
  - **Resources**. Helps with initialization and configuring of logging, event loop, thread
    or process pool, etc. Can be used for per-function execution scope in tandem with wiring.
    See `Resource provider <https://python-dependency-injector.ets-labs.org/providers/resource.html>`_.
  - **Containers**. Provides declarative and dynamic containers.
    See `Containers <https://python-dependency-injector.ets-labs.org/containers/index.html>`_.
  - **Wiring**. Injects dependencies into functions and methods. Helps integrate with
    other frameworks: Django, Flask, Aiohttp, Sanic, FastAPI, etc.
    See `Wiring <https://python-dependency-injector.ets-labs.org/wiring.html>`_.
  - **Asynchronous**. Supports asynchronous injections.
    See `Asynchronous injections <https://python-dependency-injector.ets-labs.org/providers/async.html>`_.
  - **Typing**. Provides typing stubs, ``mypy``-friendly.
    See `Typing and mypy <https://python-dependency-injector.ets-labs.org/providers/typing_mypy.html>`_.
  - **Performance**. Fast. Written in ``Cython``.
  - **Maturity**. Mature and production-ready. Well-tested, documented, and supported.
     from dependency_injector import containers, providers
     from dependency_injector.wiring import Provide, inject
     class Container(containers.DeclarativeContainer):
         config = providers.Configuration()
         api_client = providers.Singleton(
             ApiClient,
             api_key=config.api_key,
             timeout=config.timeout,
         )
         service = providers.Factory(
             Service,
             api_client=api_client,
         )
     @inject
     def main(service: Service = Provide[Container.service]) -> None:
     if __name__ == "__main__":
         container = Container()
         container.config.api_key.from_env("API_KEY", required=True)
         container.config.timeout.from_env("TIMEOUT", as_=int, default=5)
         container.wire(modules=[__name__])
         main()  # <-- dependency is injected automatically
         with container.api_client.override(mock.Mock()):
             main()  # <-- overridden dependency is injected automatically
  When you call the ``main()`` function the ``Service`` dependency is assembled and injected automatically.
  When you do testing, you call the ``container.api_client.override()`` method to replace the real API
  client with a mock. When you call ``main()``, the mock is injected.
  You can override any provider with another provider.
  It also helps you in a re-configuring project for different environments: replace an API client
  with a stub on the dev or stage.
  With the ``Dependency Injector``, object assembling is consolidated in a container. Dependency injections are defined explicitly.
  This makes it easier to understand and change how an application works.
  Visit the docs to know more about the
  `Dependency injection and inversion of control in Python <https://python-dependency-injector.ets-labs.org/introduction/di_in_python.html>`_.


pkgId: 7e844a0f05a7358cbd2f1f3284e740c595b01c70f9c62f4b6e9fcd502f27ea81
name: python-dependency-injector-debuginfo
arch: aarch64
version: 4.41.0
epoch: 0
release: 1
summary: Debug information for package python-dependency-injector
url: https://github.com/ets-labs/python-dependency-injector
rpm_license: BSD New
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-58cec383-352f-4046-b880-d7e5d343a8bb
rpm_sourcerpm: python-dependency-injector-4.41.0-1.src.rpm
location_href: 00009859-python-dependency-injector/python-dependency-injector-debuginfo-4.41.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-dependency-injector.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 31d80c2974e802f34c39569290fed6a4f79f918f86355cc95bba8aa76c05d27f
name: python-dependency-injector-debugsource
arch: aarch64
version: 4.41.0
epoch: 0
release: 1
summary: Debug sources for package python-dependency-injector
url: https://github.com/ets-labs/python-dependency-injector
rpm_license: BSD New
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-58cec383-352f-4046-b880-d7e5d343a8bb
rpm_sourcerpm: python-dependency-injector-4.41.0-1.src.rpm
location_href: 00009859-python-dependency-injector/python-dependency-injector-debugsource-4.41.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-dependency-injector.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 1f92e128712da9ecaa944465b67247fd56020a5657ec6c7b1ba6dd4f047dc43f
name: python-deprecation
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: A library to handle automated deprecations
url: http://deprecation.readthedocs.io/
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c52c1712-094a-4dac-83d4-1e97887284e3
location_href: 00003417-python-deprecation/python-deprecation-2.1.0-1.src.rpm
checksum_type: sha256
description:
  The ``deprecation`` library provides a ``deprecated`` decorator and a
  ``fail_if_not_removed`` decorator for your tests. Together, the two
  enable the automation of several things:
  1. The docstring of a deprecated method gets the deprecation details
     appended to the end of it. If you generate your API docs direct
     from your source, you don't need to worry about writing your own
     notification. You also don't need to worry about forgetting to
     write it. It's done for you.
  2. Rather than having code live on forever because you only deprecated
     it but never actually moved on from it, you can have your tests
     tell you when it's time to remove the code. The ``@deprecated``
     decorator can be told when it's time to entirely remove the code,
     which causes ``@fail_if_not_removed`` to raise an ``AssertionError``,
     causing either your unittest or py.test tests to fail.
  See http://deprecation.readthedocs.io/ for the full documentation.


pkgId: 9560caf7ebd86b7bac76bcacfec09617b2168e476995ad13dbd1335b2c669bc5
name: python-descartes
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Use geometric objects as matplotlib paths and patches
url: http://bitbucket.org/sgillies/descartes/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6eaddad6-a14f-4bc4-b421-c8216db46b26
location_href: 00003418-python-descartes/python-descartes-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Use Shapely_ or GeoJSON-like geometric objects as matplotlib paths and patches
  Requires: matplotlib, numpy, and optionally Shapely 1.2+.
  Example::
    from matplotlib import pyplot
    from shapely.geometry import LineString
    from descartes import PolygonPatch
    BLUE = '#6699cc'
    GRAY = '#999999'
    def plot_line(ax, ob):
        x, y = ob.xy
        ax.plot(x, y, color=GRAY, linewidth=3, solid_capstyle='round', zorder=1)
    line = LineString([(0, 0), (1, 1), (0, 2), (2, 2), (3, 1), (1, 0)])
    fig = pyplot.figure(1, figsize=(10, 4), dpi=180)
    
    ax = fig.add_subplot(121)
    plot_line(ax, line)
    dilated = line.buffer(0.5)
    patch1 = PolygonPatch(dilated, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
    ax.add_patch(patch1)
    
    ax = fig.add_subplot(122)
    patch2a = PolygonPatch(dilated, fc=GRAY, ec=GRAY, alpha=0.5, zorder=1)
    ax.add_patch(patch2a)
    eroded = dilated.buffer(-0.3)
    
    polygon = eroded.__geo_interface__
    
    
    
    
    patch2b = PolygonPatch(polygon, fc=BLUE, ec=BLUE, alpha=0.5, zorder=2)
    ax.add_patch(patch2b)
    pyplot.show()
  See also: examples/patches.py.
  Descartes is not associated with the identically named and apparently defunct
  project at http://descartes.sourceforge.net/.


pkgId: 8e6aab3443ed6615eeb03b0203465777f629cd44f308bbd08cb13c7bf5b84271
name: python-devolo-home-control-api
arch: src
version: 0.18.2
epoch: 0
release: 1
summary: devolo Home Control API in Python
url: https://github.com/2Fake/devolo_home_control_api
rpm_license: GPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e7a1047-2d30-4918-965b-ff0e5ce53984
location_href: 00003422-python-devolo-home-control-api/python-devolo-home-control-api-0.18.2-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/2Fake/devolo_home_control_api/Python%20package)](https://github.com/2Fake/devolo_home_control_api/actions?query=workflow%3A%22Python+package%22)
  [![PyPI - Downloads](https://img.shields.io/pypi/dd/devolo-home-control-api)](https://pypi.org/project/devolo-home-control-api/)
  [![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/2Fake/devolo_home_control_api)](https://codeclimate.com/github/2Fake/devolo_home_control_api)
  [![Coverage Status](https://coveralls.io/repos/github/2Fake/devolo_home_control_api/badge.svg?branch=master)](https://coveralls.io/github/2Fake/devolo_home_control_api?branch=master)

  This project implements parts of the devolo Home Control API in Python. It is based on reverse engineering and therefore may fail with any new devolo update. If you discover a breakage, please feel free to [report an issue](https://github.com/2Fake/devolo_home_control_api/issues).



  Defining the system requirements with exact versions typically is difficult. But there is a tested environment:

  * Linux
  * Python 3.7.12
  * pip 22.0.1
  * requests 2.27.1
  * websocket_client 1.3.1
  * zeroconf 0.38.4

  Other versions and even other operating systems might work. Feel free to tell us about your experience. If you want to run our unit tests, you also need:

  * pytest 7.0.1
  * pytest-mock 3.7.0



  In our versioning we follow [Semantic Versioning](https://semver.org/).



  The Python Package Index takes care for you. Just use pip.

  ```bash
  pip install devolo-home-control-api
  ```



  First, you need to get the sources.

  ```bash
  git clone git@github.com:2Fake/devolo_home_control_api.git
  ```

  Then you need to take care of the requirements.

  ```bash
  cd devolo_home_control_api
  python setup.py install
  ```

  If you want to run out tests, install the extra requirements and start pytest.

  ```bash
  pip install -e .[test]
  pytest
  ```



  To see that basic functionality, please look at our [small example](https://github.com/2Fake/devolo_home_control_api/blob/master/example.py). For this example, a working Home Control Central Unit must be attached to your my devolo account. After entering your my devolo username and password, simply run it:

  ```bash
  python3 example.py
  ```

  You will see changes to any BinarySwitch device (e.g. state or consumption) reported to your console. If the executing device is in the same LAN as the Home Control Central Unit, it will be discovered via Zeroconf. In this case, data will be collected from the Central Unit directly; otherwise data will be collected via cloud from my devolo.



  If you do not know your gateway ID, you can ask my devolo. For now, no other functionality is implemented, that you would need to access directly. If you discover other use cases, feel free to file a feature request.

  ```python
  mydevolo = Mydevolo.get_instance()
  mydevolo.user = "username"
  mydevolo.password = "password"
  for gateway_id in mydevolo.get_gateway_ids():
      print(gateway_id)
  ```



  There are two ways of getting data:

  1. Let the websocket push data into your object, but still poll the object
  1. Subscribe to the publisher and let it push (preferred)



  When using websocket events, messages will keep the object up to date. Nevertheless, no further action is triggered. So you have to ask yourself. The following example will list the current state of all binary switches. If the state changes, you will not notice unless you ask again.

  ```python
  homecontrol = HomeControl(gateway_id=gateway_id, mydevolo_instance=mydevolo)
  for binary_switch in mprm.binary_switch_devices:
      for state in binary_switch.binary_switch_property:
          print (f"State of {binary_switch.name} ({binary_switch.binary_switch_property[state].element_uid}): {binary_switch.binary_switch_property[state].state}")
  ```

  To execute this example, you again need a configured instance of Mydevolo.



  This preferred usage is shown in our [small example](https://github.com/2Fake/devolo_home_control_api/blob/master/example.py). On every websocket event, ```update()``` will be called. That way you can react to changes right away.



  You will find snippets discribing other use cases in our [wiki](https://github.com/2Fake/devolo_home_control_api/wiki).


pkgId: 71a2100c654c771cd07711cd87c52c0748b3591332ae0aa956ad5d8c33a81dab
name: python-dfdatetime
arch: src
version: 20230225
epoch: 0
release: 1
summary: Digital Forensics date and time (dfDateTime).
url: https://github.com/log2timeline/dfdatetime
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e6859668-7ee0-4819-ae5e-ae99091bae2d
location_href: 00003424-python-dfdatetime/python-dfdatetime-20230225-1.src.rpm
checksum_type: sha256
description:
  dfDateTime, or Digital Forensics date and time, provides date and time objects to preserve accuracy and precision.


pkgId: 0adb2e7245958eb42934c61a3f1fdc3bb0dba3f03910efa2171b3bf49cf52644
name: python-dgaintel
arch: src
version: 2.3
epoch: 0
release: 1
url: https://github.com/sudo-rushil/dgaintel
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0ca46b4c-4ae7-422c-9a6b-710484ef7ea5
location_href: 00013909-python-dgaintel/python-dgaintel-2.3-1.src.rpm
checksum_type: sha256
summary:
  Extremely fast and accurate predictions of whether a domain name is genuine or DGA with deep learning.

description:
  Using deep learning to detect DGA domains.


  The DGAIntel Python module allows you to utilize a powerful CNN-LSTM model to predict whether a given domain name was generated by a domain generation algorithm (DGA) or corresponds to a genuine domain. The prediction features are also accesible through [this website](http://www.dgaintel.com/), but this package allows for direct integration into your workflow.



  DGAIntel is designed for use with Python 3. It has only two requirements:

      - TensorFlow 2.x
      - Numpy



  To download dgaintel, simply use Pypi via pip.
  ```sh
  $ pip install dgaintel
  ```

  Alternatively, you could install from source.
  ```sh
  $ git clone https://github.com/sudo-rushil/dgaintel
  $ cd dgaintel
  $ python setup.py install
  ```

  Verify your installation by running
  ```Python
  >>> import dgaintel
  >>> dgaintel.get_prediction('microsoft.com')
  'microsoft.com is genuine with probability 0.00050'
  ```




  This is simple way of determining whether any given domain, such as `'microsoft.com'` is DGA or not, mainly intended for cyber security analysts.

  ```Python
  from dgaintel import get_prediction

  get_prediction('microsoft.com')
  ```
  > 'microsoft.com is genuine with probability 0.00050'


  This allows for getting the probability, or probabilities, that a domain or list of domains is DGA or not, which is more useful to data scientists.

  ```Python
  from dgaintel import get_prob


  prob = get_prob('microsoft.com')
  print(prob)


  probs = get_prob(['microsoft.com', 'wikipedia.com', 'vlurgpeddygdy.com'])
  print(probs)


  raw_probs = list(get_prob(['microsoft.com', 'wikipedia.com', 'vlurgpeddygdy.com'], raw=True))
  print(raw_probs)
  ```

  > 0.00050

  > [('microsoft.com', 0.00050), ('wikipedia.com', 0.00033), ('vlurgpeddygdy.com', 0.97601)]

  > [0.00050845, 0.00033092, 0.00144754]


  This is for inputing a file containing a list of domains to get predictions on all of them at once, which is helpful for data analysts.

  Say you have a domain file `domains.txt`.
  ```
  microsoft.com
  wikipedia.com
  vlurgpeddygdy.com
  ```

  Then, you can run the following code in the same directory.
  ```Python
  from dgaintel import get_prediction


  get_prediction('domains.txt')


  get_prediction('domains.txt', to_file='domain_predictions.txt')
  ```

  > microsoft.com is genuine with probability 0.00050

  > wikipedia.com is genuine with probability 0.00033

  > vlurgpeddygdy.com is DGA with probability 0.97601

  If you read the new file `domain_predictions.txt`, you will see the following.

  ```
  microsoft.com is genuine with probability 0.0005084535223431885
  wikipedia.com is genuine with probability 0.00033092446392402053
  vlurgpeddygdy.com is DGA with probability 0.9760094285011292
  ```


  This is an example function that integrates dgaintel with [whois](https://pypi.org/project/whois/) for performing basic prediction analysis, which is important for cyber security investigators.

  ```Python
  from dgaintel import get_prob
  from whois import query

  def analyze(domain, out=True):
      prob = get_prob(domain)
      whois = query(domain)
      dga = False
      if prob >= 0.5: dga = True

      domain_analysis = {'domain_name': domain,
                         'dga': dga,
                         'registrar': whois.registrar if whois else None,
                         'creation date' : whois.creation_date if whois else None,
                         'expiration date': whois.expiration_date if whois else None}

      if out:
          print()
          for key, val in domain_analysis.items():
              print('{}: {}'.format(key, val))
          print()
          return None

      return domain_analysis

  analyze('microsoft.com')


  analysis = analyze('microsoft.com', out=False)
  ```

  > name: microsoft.com

  > dga: False

  > registrar: MarkMonitor Inc.

  > creation date: 1991-05-02 04:00:00

  > expiration date: 2021-05-03 04:00:00



  This example shows how the class interface to DGAIntel allows for certain TLDs to be whitelisted, preventing them from raising errors in a given ecosystem.

  ```Python
  from dgaintel import Intel

  intel = Intel(['cloud.com'])

  print(intel.get_prob(['www.cloud.com',
                          'dfsadkcda.cloud.com',
                          'www.cloud.org',
                          'www.dkfjsdakfj.org']))
  ```

  > [('www.cloud.com', 0.0), ('dfsadkcda.cloud.com', 0.0), ('www.cloud.org', 0.00045579672), ('www.dkfjsdakfj.org', 0.99884665)]



  DGAIntel has support for polymorphism; to input domains to run predictions on, you can use a single domain name, a list of domain names, or a text file with line-separated domain names. The text file has the format

  ```
  microsoft.com
  wikipedia.com
  vlurgpeddygdy.com
  ...
  ```

  Additionally, the Tensorflow Keras model running in the backend supports input batching, meaning there is a significant increase in speed for running predictions on lists or files rather than individual domains. This was tested in Jupyter.

  ```Python
  from dgaintel import get_prob


  l = ['microsoft.com', 'squarespace.com', 'hsfkjdshfjasdhfk.com', 'fdkhakshfda.com', 'foilfencersarebad.com', 'foilfencersarebad.com', 'foilfencersarebad.com', 'discojjfdsf.com', 'fasddafhkj.com', 'wikipedai.com']
  ```

  ```Python

  %timeit
  get_prob(l[0])
  ```

  > 286 ms ± 4.99 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

  ```Python

  %timeit
  get_prob(l)
  ```

  > 290 ms ± 7.23 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

  ```Python

  %timeit
  get_prob(l*10)
  ```

  > 333 ms ± 4.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

  ```Python

  %timeit
  get_prob(l*100)
  ```

  > 584 ms ± 14.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

  This demonstrates that increasing the number of domain names one runs the prediction by 1000x only increases the inference time by less than 2x. Therefore, this model is easily adaptable to large-scale predictions.


  The `get_prediction` function will either print the predictions or write them to a user-specified file.
  ```Python
  from dgaintel import get_prediction

  get_prediction('microsoft.com')
  get_prediction(['microsoft.com', 'wikipedia.com', 'vlurgpeddygdy.com'])
  get_prediction('domains.txt')
  get_prediction('domains.txt', to_file='domain_predictions.txt')
  ```

  The `get_prob` function will perform the inference and provide the prediction floats. It is helpful if you want to use the prediction scores directly in your workflow.
  ```Python
  from dgaintel import get_prob

  get_prob('microsoft.com') # 0.00050851
  get_prob(['microsoft.com', 'wikipedia.com', 'vlurgpeddygdy.com']) # [('microsoft.com', 0.00050), ('wikipedia.com', 0.00033), ('vlurgpeddygdy.com', 0.0.97601)]
  get_prob('domains.txt') # [('microsoft.com', 0.00050), ('wikipedia.com', 0.00033), ('vlurgpeddygdy.com', 0.97601)]
  get_prob(['microsoft.com', 'wikipedia.com', 'google.com'], raw=True) # array([0.00050, 0.00033, 0.0.97601], dtype=float32)
  ```

  The `Intel` interface allows DGAIntel to avoid checking certain domains with known TLDs to ensure enterprise functions are not compromised.
  ```Python
  from dgaintel import Intel

  intel = Intel(['microsoft.com'])
  intel.get_prob('microsoft.com') # 0.0
  intel.get_prob(['microsoft.com', 'wikipedia.com', 'vlurgpeddygdy.com']) # [('microsoft.com', 0.0), ('wikipedia.com', 0.00033), ('vlurgpeddygdy.com', 0.0.97601)]
  intel.get_prob('domains.txt') # [('microsoft.com', 0.0), ('wikipedia.com', 0.00033), ('vlurgpeddygdy.com', 0.97601)]
  intel.get_prob(['microsoft.com', 'wikipedia.com', 'google.com'], raw=True) # array([0.0, 0.00033, 0.0.97601], dtype=float32)
  ```


pkgId: 3d2c22fbedcd1a8ba52657cc7261a74fbeac5d07fc0965bf803e43347583870d
name: python-dhooks
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: An (a)sync wrapper for discord webhooks
url: https://github.com/4rqm/dhooks/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-791c1d1f-9a1f-40b9-9f23-ce961ab81ff8
location_href: 00010825-python-dhooks/python-dhooks-1.1.4-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Discord Webhooks</h1>

  <div align="center">
    <strong><i>Interact with discord webhooks using python.</i></strong>
    <br>
    <br>

    <a href="https://travis-ci.com/kyb3r/dhooks">
      <img src="https://img.shields.io/travis/com/kyb3r/dhooks/master.svg?style=for-the-badge&colorB=06D6A0" alt="Travis" />
    </a>

    <a href="https://test-dhooks-doc.readthedocs.io/en/latest/?badge=latest">
      <img src="https://img.shields.io/readthedocs/dhooks.svg?style=for-the-badge&colorB=E8BE5D" alt="Documentation Status" />
    </a>

    <a href="https://github.com/kyb3r/dhooks/">
      <img src="https://img.shields.io/pypi/pyversions/dhooks.svg?style=for-the-badge&colorB=F489A3" alt="Py Versions" />
    </a>

    <a href="https://pypi.org/project/dhooks/">
      <img src="https://img.shields.io/pypi/v/dhooks.svg?style=for-the-badge&colorB=61829F" alt="PyPi" />
    </a>

    <a href="https://github.com/kyb3r/dhooks/blob/master/LICENSE">
      <img src="https://img.shields.io/github/license/kyb3r/dhooks.svg?style=for-the-badge&colorB=7289DA" alt="LICENSE" />
    </a>
  </div>
  <br>

  <div align="center">
    This <strong>simple</strong> library enables you to easily interact with discord webhooks, allowing you to easily format discord messages and discord embeds, retrieve webhook information, modify and delete webhooks. Asynchronous usage is also supported.
  </div>



  To install the library simply use pip.

  ```commandline
  pip install dhooks
  ```

  If you would also like to get the latest version of dhooks from GitHub, build docs, run tests or run examples, you may want to install
  dhooks with the optional extended dependencies.

  ```commandline
  git clone https://github.com/kyb3r/dhooks.git
  cd dhooks
  pip install .[tests,docs,examples]
  ```





  ```python
  from dhooks import Webhook

  hook = Webhook('url')

  hook.send("Hello there! I'm a webhook :open_mouth:")
  ```

  <img src='https://i.imgur.com/8wu283y.png' width=300>



  You can easily format and send embeds using this library.

  <img src='https://i.imgur.com/8Ms4OID.png' width=400>

  Note: `Embed` objects from `discord.py` are also compatible with this library.

  ```python
  from dhooks import Webhook, Embed

  hook = Webhook('url')

  embed = Embed(
      description='This is the **description** of the embed! :smiley:',
      color=0x5CDBF0,
      timestamp='now'  # sets the timestamp to current time
      )

  image1 = 'https://i.imgur.com/rdm3W9t.png'
  image2 = 'https://i.imgur.com/f1LOr4q.png'

  embed.set_author(name='Author Goes Here', icon_url=image1)
  embed.add_field(name='Test Field', value='Value of the field :open_mouth:')
  embed.add_field(name='Another Field', value='1234 :smile:')
  embed.set_footer(text='Here is my footer text', icon_url=image1)

  embed.set_thumbnail(image1)
  embed.set_image(image2)

  hook.send(embed=embed)
  ```



  You can easily send files as shown.

  ```python
  from dhooks import Webhook, File
  from io import BytesIO
  import requests

  hook = Webhook('url')

  file = File('path/to/file.png', name='cat.png')  # optional name for discord

  hook.send('Look at this:', file=file)
  ```

  You can also pass a file-like object:

  ```python
  response = requests.get('https://i.imgur.com/rdm3W9t.png')
  file = File(BytesIO(response.content), name='wow.png')

  hook.send('Another one:', file=file)
  ```



  You can get some basic information related to the webhook through Discord's API.

  ```python
  hook.get_info()
  ```

  The following attributes will be populated with data from discord:

  - `hook.guild_id`
  - `hook.channel_id`
  - `hook.default_name`
  - `hook.default_avatar_url`



  You can change the default name and avatar of a webhook easily.

  ```python
  with open('img.png', rb) as f:
      img = f.read()  # bytes

  hook.modify(name='Bob', avatar=img)

  hook.delete()  # webhook deleted permanently
  ```



  To asynchronously make requests using `aiohttp`, simply use `Webhook.Async` to create the object. An example is as follows. Simply use the `await` keyword when calling API methods.

  ```python
  from dhooks import Webhook

  async def main():
      hook = Webhook.Async('url')

      await hook.send('hello')
      await hook.modify('bob')
      await hook.get_info()
      await hook.delete()

      await hook.close()  # close the client session
  ```

  Alternatively you can use an `async with` block (asynchronous context manager) to automatically close the session once finished.

  ```python
  async def main():
      async with Webhook.Async('url') as hook:
          await hook.send('hello')
  ```



  You can find the full API reference [here](https://dhooks.readthedocs.io).



  This project is licensed under MIT.



  Feel free to contribute to this project, a helping hand is always appreciated.

  [Join our discord server](https://discord.gg/etJNHCQ).


pkgId: bc54d1dfa89323fe9200942d20997864775c9c820002ae636abc8acf13fca8d6
name: python-diagrams
arch: src
version: 0.23.3
epoch: 0
release: 1
summary: Diagram as Code
url: https://diagrams.mingrammer.com
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c44b123-76e9-4be3-94b5-6c5ad28f15ea
location_href: 00012811-python-diagrams/python-diagrams-0.23.3-1.src.rpm
checksum_type: sha256
description:
  ![diagrams logo](assets/img/diagrams.png)



  [![license](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)
  [![pypi version](https://badge.fury.io/py/diagrams.svg)](https://badge.fury.io/py/diagrams)
  ![python version](https://img.shields.io/badge/python-%3E%3D%203.6-blue?logo=python)
  ![Run tests](https://github.com/mingrammer/diagrams/workflows/Run%20tests/badge.svg?branch=master)
  [![todos](https://badgen.net/https/api.tickgit.com/badgen/github.com/mingrammer/diagrams?label=todos)](https://www.tickgit.com/browse?repo=github.com/mingrammer/diagrams)
  ![contributors](https://img.shields.io/github/contributors/mingrammer/diagrams)

  <a href="https://www.buymeacoffee.com/mingrammer" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>

  **Diagram as Code**.

  Diagrams lets you draw the cloud system architecture **in Python code**. It was born for **prototyping** a new system architecture design without any design tools. You can also describe or visualize the existing system architecture as well. Diagrams currently supports main major providers including: `AWS`, `Azure`, `GCP`, `Kubernetes`, `Alibaba Cloud`, `Oracle Cloud` etc... It also supports `On-Premise` nodes, `SaaS` and major `Programming` frameworks and languages.

  **Diagram as Code** also allows you to **track** the architecture diagram changes in any **version control** system.

  >  NOTE: It does not control any actual cloud resources nor does it generate cloud formation or terraform code. It is just for drawing the cloud system architecture diagrams.



  ![aws provider](https://img.shields.io/badge/AWS-orange?logo=amazon-aws&color=ff9900)
  ![azure provider](https://img.shields.io/badge/Azure-orange?logo=microsoft-azure&color=0089d6)
  ![gcp provider](https://img.shields.io/badge/GCP-orange?logo=google-cloud&color=4285f4)
  ![ibm provider](https://img.shields.io/badge/IBM-orange?logo=ibm&color=052FAD)
  ![kubernetes provider](https://img.shields.io/badge/Kubernetes-orange?logo=kubernetes&color=326ce5)
  ![alibaba cloud provider](https://img.shields.io/badge/AlibabaCloud-orange?logo=alibaba-cloud&color=ff6a00)
  ![oracle cloud provider](https://img.shields.io/badge/OracleCloud-orange?logo=oracle&color=f80000)
  ![openstack provider](https://img.shields.io/badge/OpenStack-orange?logo=openstack&color=da1a32)
  ![firebase provider](https://img.shields.io/badge/Firebase-orange?logo=firebase&color=FFCA28)
  ![digital ocean provider](https://img.shields.io/badge/DigitalOcean-0080ff?logo=digitalocean&color=0080ff)
  ![elastic provider](https://img.shields.io/badge/Elastic-orange?logo=elastic&color=005571)
  ![outscale provider](https://img.shields.io/badge/OutScale-orange?color=5f87bf)
  ![on premise provider](https://img.shields.io/badge/OnPremise-orange?color=5f87bf)
  ![generic provider](https://img.shields.io/badge/Generic-orange?color=5f87bf)
  ![programming provider](https://img.shields.io/badge/Programming-orange?color=5f87bf)
  ![saas provider](https://img.shields.io/badge/SaaS-orange?color=5f87bf)
  ![c4 provider](https://img.shields.io/badge/C4-orange?color=5f87bf)



  It requires **Python 3.6** or higher, check your Python version first.

  It uses [Graphviz](https://www.graphviz.org/) to render the diagram, so you need to [install Graphviz](https://graphviz.gitlab.io/download/) to use **diagrams**. After installing graphviz (or already have it), install the **diagrams**.

  > macOS users can download the Graphviz via `brew install graphviz` if you're using [Homebrew](https://brew.sh).

  ```shell

  $ pip install diagrams


  $ pipenv install diagrams


  $ poetry add diagrams
  ```

  You can start with [quick start](https://diagrams.mingrammer.com/docs/getting-started/installation#quick-start). Check out [guides](https://diagrams.mingrammer.com/docs/guides/diagram) for more details, and you can find all available nodes list in [here](https://diagrams.mingrammer.com/docs/nodes/aws).



  | Event Processing                                             | Stateful Architecture                                        | Advanced Web Service                                         |
  | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
  | ![event processing](https://diagrams.mingrammer.com/img/event_processing_diagram.png) | ![stateful architecture](https://diagrams.mingrammer.com/img/stateful_architecture_diagram.png) | ![advanced web service with on-premise](https://diagrams.mingrammer.com/img/advanced_web_service_with_on-premise.png) |

  You can find all the examples on the [examples](https://diagrams.mingrammer.com/docs/getting-started/examples) page.



  To contribute to diagram, check out [contribution guidelines](CONTRIBUTING.md).

  > Let me know if you are using diagrams! I'll add you in showcase page. (I'm working on it!) :)



  [GitPitch](https://gitpitch.github.io/gitpitch) is the perfect slide deck solution for Tech Conferences, Training, Developer Advocates, and Educators. Diagrams is now available as a dedicated [Cloud Diagram Markdown Widget](https://gitpitch.github.io/gitpitch/#/diagrams/cloud-architecture) so you can use Diagrams directly on any slide for conferences, meetups, and training.

  [Cloudiscovery](https://github.com/Cloud-Architects/cloudiscovery) helps you to analyze resources in your cloud (AWS/GCP/Azure/Alibaba/IBM) account. It allows you to create a diagram of analyzed cloud resource map based on this Diagrams library, so you can draw your existing cloud infrastructure with Cloudiscovery.

  [Airflow Diagrams](https://github.com/feluelle/airflow-diagrams) is an Airflow plugin that aims to easily visualise your Airflow DAGs on service level from providers like AWS, GCP, Azure, etc. via diagrams.



  - If you are familiar with Go, you can use [go-diagrams](https://github.com/blushft/go-diagrams) as well.



  [MIT](LICENSE)


pkgId: 1dd063a8da3f4ed5c2abcc66466d7a730b4aa6d15fe5bb0c2013518df2dffdf5
name: python-dictdumper
arch: src
version: 0.8.4.post2
epoch: 0
release: 1
summary: Python dict formatted dumper.
url: https://github.com/JarryShaw/dictdumper#dictdumper
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d8d25a68-e4d9-4d93-9fd4-de5729c2b40a
location_href: 00003428-python-dictdumper/python-dictdumper-0.8.4.post2-1.src.rpm
checksum_type: sha256
description:
  &emsp; Currently, it supports following formats --
   - `dictdumper.Dumper` -- abstract base class of all dumpers
   - `dictdumper.JSON` -- dump JavaScript object notation (`JSON`) format file
   - `dictdumper.PLIST` -- dump Apple property list (`PLIST`) format file
   - `dictdumper.Tree` -- dump tree-view text (`TXT`) format file
   - `dictdumper.XML` -- dump extensible markup language (`XML`) file (__base class__)
   - `dictdumper.HTML` -- dump JavaScript file under `Vue.js` framework (__DEPRECATED__)
  ![](https://github.com/JarryShaw/dictdumper/blob/master/doc/dictdumper.png)
  &nbsp;

  > Note that `dictdumper` supports Python versions __2.7__ and all versions __since 3.0__
  ```
  pip install dictdumper
  ```
  &nbsp;

  &emsp; `dictdumper` is quite easy to use. After installation, importation, and initialisation, you can simple call the instance to dump contents.
  > Take `dictdumper.Tree` for example
  ```python
  import dictdumper
  dumper = dictdumper.Tree('out.txt')
  test_1 = dict(
      foo=-1,
      bar='Hello, world!',
      boo=dict(
          foo_again=True,
          bar_again=memoryview(b'bytes'),
          boo_again=None,
      ),
  )
  dumper(test_1, name='test_1')
  ```
  ```
  $ cat out.txt
  test_1
    |-- foo -> -1
    |-- bar -> Hello, world!
    |-- boo
          |-- foo_again -> True
          |-- bar_again
          |     |-- type -> memoryview
          |     |-- value -> 62 79 74 65 73
          |     |-- text -> bytes
          |-- boo_again -> NIL
  ```
  ```python
  import datetime
  test_2 = dict(
      foo=[1, 2.0, 3],
      bar=(1.0, bytearray(b'a long long bytes'), 3.0),
      boo=dict(
          foo_again=b'bytestring',
          bar_again=datetime.datetime(2020, 1, 31, 20, 15, 10, 163010),
          boo_again=float('-inf'),
      ),
  )
  dumper(test_2, name='test_2')
  ```
  ```
  $ cat out.txt
  test_1
    |-- foo -> -1
    |-- bar -> Hello, world!
    |-- boo
          |-- foo_again -> True
          |-- bar_again
          |     |-- type -> memoryview
          |     |-- value -> 62 79 74 65 73
          |     |-- text -> bytes
          |-- boo_again -> NIL
  test_2
    |-- foo
    |     |--> 1
    |     |--> 2.0
    |     |--> 3
    |-- bar
    |     |-- type -> tuple
    |     |-- value
    |           |--> 1.0
    |           |--> --
    |           |     |-- type -> bytearray
    |           |     |-- value
    |           |     |     |--> 61 20 6c 6f 6e 67 20 6c 6f 6e 67 20 62 79 74 65
    |           |     |          73
    |           |     |-- text -> a long long bytes
    |           |--> 3.0
    |-- boo
          |-- foo_again -> 62 79 74 65 73 74 72 69 6e 67
          |-- bar_again -> 2020-01-31T20:15:10.163010
          |-- boo_again -> -Infinity
  ```
  ```python
  test_3 = dict(
      foo="stringstringstringstringstringstringstringstringstringstring",
      bar=[
          "s1", False, "s3",
      ],
      boo=[
          "s4", dict(s="5", j="5"), "s6"
      ],
      far=dict(
          far_foo=["s1", "s2", "s3"],
          far_var="s4",
      ),
      biu=float('nan'),
  )
  dumper(test_3, name='test_3')
  ```
  ```
  $ cat out.txt
  test_1
    |-- foo -> -1
    |-- bar -> Hello, world!
    |-- boo
          |-- foo_again -> True
          |-- bar_again
          |     |-- type -> memoryview
          |     |-- value -> 62 79 74 65 73
          |     |-- text -> bytes
          |-- boo_again -> NIL
  test_2
    |-- foo
    |     |--> 1
    |     |--> 2.0
    |     |--> 3
    |-- bar
    |     |-- type -> tuple
    |     |-- value
    |           |--> 1.0
    |           |--> --
    |           |     |-- type -> bytearray
    |           |     |-- value
    |           |     |     |--> 61 20 6c 6f 6e 67 20 6c 6f 6e 67 20 62 79 74 65
    |           |     |          73
    |           |     |-- text -> a long long bytes
    |           |--> 3.0
    |-- boo
          |-- foo_again -> 62 79 74 65 73 74 72 69 6e 67
          |-- bar_again -> 2020-01-31T20:15:10.163010
          |-- boo_again -> -Infinity
  test_3
    |-- foo
    |     |--> stringstringstringstringstringstringstri
    |          ngstringstringstring
    |-- bar
    |     |--> s1
    |     |--> False
    |     |--> s3
    |-- boo
    |     |--> s4
    |     |--> --
    |     |     |-- s -> 5
    |     |     |-- j -> 5
    |     |--> s6
    |-- far
    |     |-- far_foo
    |     |     |--> s1
    |     |     |--> s2
    |     |     |--> s3
    |     |-- far_var -> s4
    |-- biu -> NaN
  ```


pkgId: 737b53f24e18a50e598b9291664f1d4cd57a42d660437fdb545d61a67bd39f7c
name: python-dictor
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: an elegant dictionary and JSON handler
url: https://github.com/perfecto25/dictor
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ce346a90-0bb1-436c-917b-7540980def0d
location_href: 00012055-python-dictor/python-dictor-0.1.11-1.src.rpm
checksum_type: sha256
description:
      pip install dictor

  sample.json
  ```json
  {
    "characters": {
      "Lonestar": {
        "id": 55923,
        "role": "renegade",
        "items": ["space winnebago", "leather jacket"]
      },
      "Barfolomew": {
        "id": 55924,
        "role": "mawg",
        "items": ["peanut butter jar", "waggy tail"]
      },
      "Dark Helmet": {
        "id": 99999,
        "role": "Good is dumb",
        "items": ["Shwartz", "helmet"]
      },
      "Skroob": {
        "id": 12345,
        "role": "Spaceballs CEO",
        "items": ["luggage"]
      }
    }
  }
  ```
  now lets get info on all Characters
  ```python
  from dictor import dictor
  with open('sample.json') as data:
      data = json.load(data)
  print(dictor(data, 'characters'))
  {u'Lonestar': {u'items': [u'space winnebago', u'leather jacket'], u'role': u'renegade', u'id': 55923}, u'Dark Helmet': {u'items': [u'Shwartz', u'helmet'], u'role': u'Good is dumb', u'id': 99999}, u'Barfolomew': {u'items': [u'peanut butter jar', u'waggy tail'], u'role': u'mawg', u'id': 55924}, u'Skroob': {u'items': [u'luggage'], u'role': u'Spaceballs CEO', u'id': 12345}}


pkgId: c85a3178ec6d5f35d4b428d9d85ea8cd49a33d53a4f6d3d72e6c673fadcf6ec3
name: python-dicttoxml
arch: src
version: 1.7.16
epoch: 0
release: 1
summary: Converts a Python dictionary or other native data type into a valid XML string.
description: Converts a Python dictionary or other native data type into a valid XML string.
url: https://github.com/quandyfactory/dicttoxml
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3841bb4f-f187-4633-9134-e44838e1d631
location_href: 00003429-python-dicttoxml/python-dicttoxml-1.7.16-1.src.rpm
checksum_type: sha256
rpm_license:
  GNU GENERAL PUBLIC LICENSE  Version 2, June 1991  Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA  Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.  To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.  We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.  Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.  Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.  The precise terms and conditions for copying, distribution and modification follow. 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.


pkgId: 3e4d393cbb48d5b7000365abf545232beb837ee97d880d0070673ae69c2886c8
name: python-diff-cover
arch: src
version: 7.5.0
epoch: 0
release: 1
summary: Run coverage and linting reports on diffs
url: https://github.com/Bachmann1234/diff-cover
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8c2963b5-0bbe-48d1-8c60-c70166f06c79
location_href: 00003431-python-diff-cover/python-diff-cover-7.5.0-1.src.rpm
checksum_type: sha256
description:
  Automatically find diff lines that need test coverage.
  Also finds diff lines that have violations (according to tools such
  as pycodestyle, pyflakes, flake8, or pylint).
  This is used as a code quality metric during code reviews.


pkgId: 6d7c2209ccbd4ee880b16a6461bc6915c2993706bc2e29b92917ce5ca34995b8
name: python-diff-match-patch
arch: src
version: 20200713
epoch: 0
release: 1
url: https://github.com/diff-match-patch-python/diff-match-patch
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-735ff223-8f07-4acf-a965-2c759129d942
location_href: 00003432-python-diff-match-patch/python-diff-match-patch-20200713-1.src.rpm
checksum_type: sha256
summary:
  Repackaging of Google's Diff Match and Patch libraries. Offers robust algorithms to perform the operations required for synchronizing plain text.

description:
  Google's [Diff Match and Patch][DMP] library, packaged for modern Python.

  [![build status](https://travis-ci.org/diff-match-patch-python/diff-match-patch.svg?branch=master)](https://travis-ci.org/diff-match-patch-python/diff-match-patch)
  [![version](https://img.shields.io/pypi/v/diff-match-patch.svg)](https://pypi.org/project/diff-match-patch)
  [![license](https://img.shields.io/pypi/l/diff-match-patch.svg)](https://github.com/diff-match-patch-python/diff-match-patch/blob/master/LICENSE)



  diff-match-patch is supported on Python 2.7 or Python 3.4 or newer.
  You can install it from PyPI:

  ```shell
  python -m pip install diff-match-patch
  ```



  Generating a patchset (analogous to unified diff) between two texts:

  ```python
  from diff_match_patch import diff_match_patch

  dmp = diff_match_patch()
  patches = dmp.patch_make(text1, text2)
  diff = dmp.patch_toText(patches)
  ```

  Applying a patchset to a text can then be done with:

  ```python
  from diff_match_patch import diff_match_patch

  dmp = diff_match_patch()
  patches = dmp.patch_fromText(diff)
  new_text, _ = dmp.patch_apply(patches, text)
  ```


  The Diff Match and Patch libraries offer robust algorithms to perform the
  operations required for synchronizing plain text.

  1. Diff:
     * Compare two blocks of plain text and efficiently return a list of differences.
     * [Diff Demo](https://neil.fraser.name/software/diff_match_patch/demos/diff.html)
  2. Match:
     * Given a search string, find its best fuzzy match in a block of plain text. Weighted for both accuracy and location.
     * [Match Demo](https://neil.fraser.name/software/diff_match_patch/demos/match.html)
  3. Patch:
     * Apply a list of patches onto plain text. Use best-effort to apply patch even when the underlying text doesn't match.
     * [Patch Demo](https://neil.fraser.name/software/diff_match_patch/demos/patch.html)

  Originally built in 2006 to power Google Docs, this library is now available in C++, C#, Dart, Java, JavaScript, Lua, Objective C, and Python.



  * [API](https://github.com/google/diff-match-patch/wiki/API) - Common API across all languages.
  * [Line or Word Diffs](https://github.com/google/diff-match-patch/wiki/Line-or-Word-Diffs) - Less detailed diffs.
  * [Plain Text vs. Structured Content](https://github.com/google/diff-match-patch/wiki/Plain-Text-vs.-Structured-Content) - How to deal with data like XML.
  * [Unidiff](https://github.com/google/diff-match-patch/wiki/Unidiff) - The patch serialization format.
  * [Support](https://groups.google.com/forum/#!forum/diff-match-patch) - Newsgroup for developers.


  Although each language port of Diff Match Patch uses the same API, there are some language-specific notes.

  * [C++](https://github.com/google/diff-match-patch/wiki/Language:-Cpp)
  * [C#](https://github.com/google/diff-match-patch/wiki/Language:-C%23)
  * [Dart](https://github.com/google/diff-match-patch/wiki/Language:-Dart)
  * [Java](https://github.com/google/diff-match-patch/wiki/Language:-Java)
  * [JavaScript](https://github.com/google/diff-match-patch/wiki/Language:-JavaScript)
  * [Lua](https://github.com/google/diff-match-patch/wiki/Language:-Lua)
  * [Objective-C](https://github.com/google/diff-match-patch/wiki/Language:-Objective-C)
  * [Python](https://github.com/google/diff-match-patch/wiki/Language:-Python)

  A standardized speed test tracks the [relative performance of diffs](https://docs.google.com/spreadsheets/d/1zpZccuBpjMZTvL1nGDMKJc7rWL_m_drF4XKOJvB27Kc/edit#gid=0) in each language.


  This library implements [Myer's diff algorithm](https://neil.fraser.name/writing/diff/myers.pdf) which is generally considered to be the best general-purpose diff. A layer of [pre-diff speedups and post-diff cleanups](https://neil.fraser.name/writing/diff/) surround the diff algorithm, improving both performance and output quality.

  This library also implements a [Bitap matching algorithm](https://neil.fraser.name/writing/patch/bitap.ps) at the heart of a [flexible matching and patching strategy](https://neil.fraser.name/writing/patch/).

  [DMP]: https://github.com/google/diff-match-patch
  [API]: https://github.com/google/diff-match-patch/wiki/API


pkgId: 3428e6805f19fbc9b1dd86ee7ddeebb9c6650d122c64ae1a3eb8cec9defcc872
name: python-dijitso
arch: src
version: 2017.1.0
epoch: 0
release: 1
summary: Distributed just-in-time building of shared libraries
url: https://bitbucket.org/fenics-project/dijitso/
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f53b3b6e-5db2-4cdc-a7f1-8753b0d610dd
location_href: 00003434-python-dijitso/python-dijitso-2017.1.0-1.src.rpm
checksum_type: sha256
description:
  *A Python module for distributed just-in-time shared library building*
  Authors:
  - Martin Sandve Alnæs (martinal@simula.no)
  - Garth N. Wells (gnw20@cam.ac.uk)
  - Johannes Ring (johannr@simula.no)
  Contributors:
  - Jan Blechta (blechta@karlin.mff.cuni.cz)


pkgId: 9c028f3f60ede7e43e7cbcf33477506ce4de3ee727573e3e85b9278129838e3c
name: python-dingz
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Python API for interacting with Dingz devices
url: https://github.com/home-assistant-ecosystem/python-dingz
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9c435095-7c62-4afe-945e-d1e2b529b28d
location_href: 00003436-python-dingz/python-dingz-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Python API for interacting with `Dingz <https://dingz.ch>`_ devices.
  This module is not official, developed, supported or endorsed by iolo AG or
  myStrom AG. For questions and other inquiries, use the issue tracker in this
  repository please.
  Without the support of iolo AG and myStrom AG it would have taken much longer
  to create this module which is the base for the integration into
  `Home Assistant <https://home-assistant.io>`_. Both companies have provided
  and are still providing hardware, valuable feedback and advice. Their
  continuous support make further development of this module possible.
  See `api.dingz.ch <https://api.dingz.ch/>`_ for the API details.


pkgId: 88f2f524ae87f644b60f9cb3a516394bd52e051e2a85c11cccc7b37b385c5dc1
name: python-dirq
arch: src
version: 1.8
epoch: 0
release: 1
summary: Directory based queue
url: https://github.com/cern-mig/python-dirq
rpm_license: ASL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-292f610a-3f67-41e4-8b90-2fd9ab0106b9
location_href: 00003439-python-dirq/python-dirq-1.8-1.src.rpm
checksum_type: sha256
description:
  A port of Perl module Directory::Queue
  http://search.cpan.org/dist/Directory-Queue/

  The goal of this module is to offer a queue system using the underlying
  filesystem for storage, security and to prevent race conditions via atomic
  operations. It focuses on simplicity, robustness and scalability.

  This module allows multiple concurrent readers and writers to interact with
  the same queue.


pkgId: 86dbe21f951b673b282e03bda944da584a69aacf6beb942c5441f9424bae8eb5
name: python-discord-together
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: Utilize the BETA Discord VC Party Games feature!
url: https://github.com/apurv-r/discord-together
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-10b06136-eb9a-449e-9c70-211670d9cf90
location_href: 00013795-python-discord-together/python-discord-together-1.2.6-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://pypi.org/project/discord-together"><img src="https://i.ibb.co/nCr7dnf/DT-Logo-New.png" alt="discord-together logo" height="128" style="border-radius: 50%"></a>
      <div>
          <h1><strong>Discord Together</strong></h1>
      </div>
      <div>
          <a href="https://pypi.org/project/discord-together"><img src="https://img.shields.io/pypi/dm/discord-together?color=%23EF0BB9&label= downloads&logo=git lfs&logoColor=fc2a95&?style=flat" alt="discord-together downloads"></a>
          <a href="https://pypi.org/project/discord-together"><img src="https://img.shields.io/pypi/v/discord-together?color=%23EF0BB9&label=version&logo=buffer&?style=flat&logoColor=fc2a95" alt="discord-together version"></a>
          <a href="https://discord.com/invite/2fbyXn2hJV"><img src="https://img.shields.io/discord/860227711402246154.svg?color=%23EF0BB9&label=support server&logo=discord&style=flat&logoColor=fc2a95"></a>
          <a href="https://docs.discord-together.ml"><img src="https://img.shields.io/website?down_color=lightgrey&down_message=offline&label=docs&logo=Read%20the%20Docs&up_color=%23EF0BB9&up_message=online&url=https%3A%2F%2Fdocs.discord-together.ml&logoColor=fc2a95"></a>
      </div>
  </div>

  <h3>Discord has released a BETA feature that they call Discord Party Games or Activities, which allows members to play a large variety of games within a server voice channel. While this feature has officially only been provided to certain hand-picked servers, this module allows you to temporarily enable such features for your servers!</h3>



  <h4>As of the latest release, this BETA feature is only supported on web and updated PC app versions of Discord and is not supported on mobile.</h4>
  <br>



  ```
  pip install discord-together
  ```


  <br>


  - No specific API wrapper dependencies, works with discord.py and any of its forks
  - Easy to use and lightweight
  - Actively maintained and updated with latest activites
  - Debug mode for invalid invites

  <br>


  This is a simple example of code using this package (with discord.py 1.7.2) to create an invite for a YouTube Watch Together in the channel that the command invoker is currently in.

  ```py
  from discord.ext import commands
  from discord_together import DiscordTogether

  client = commands.Bot(command_prefix="~")

  @client.event
  async def on_ready():
      client.togetherControl = await DiscordTogether("BOT_TOKEN_HERE")
      print('Bot is online!')

  @client.command()
  async def start(ctx):
      link = await client.togetherControl.create_link(ctx.author.voice.channel.id, 'youtube')
      await ctx.send(f"Click the blue link!\n{link}")

  client.run("BOT_TOKEN_HERE")
  ```
  View the **[docs](https://docs.discord-together.ml/)** for more detailed/advanced examples (like cogs) and explanations!
  <br>
  <br>



  ![Invite link](https://cdn.discordapp.com/attachments/678298437854298122/860210951222460446/msedge_Gntg4yflYw.png)

  <h3>⚠️ Advisory Note:</h3>
  At least one person needs to click on the <strong>BLUE LINK</strong>, not the 'Play' button, in order to start the activity! Once the activity is started, people can join by clicking 'Play'.
  <br>
  <br>

  ![YouTube Together](https://cdn.discordapp.com/attachments/678298437854298122/860210751448547328/msedge_HpqALcJCcD.png)

  <br>



  **This package is under MIT license.** Appropriately tested PR's are more than welcome.

  *Note: This package is not affiliated with Discord or YouTube.*

  If you have any problems or enquiries, join the [discord-together Support Server](https://discord.gg/2fbyXn2hJV) or you can contact me personally on Discord: `Bxllistic#4444`.

  This project was converted to support python from the npm package [discord-together](https://www.npmjs.com/package/discord-together)

  <br>
  <hr>


   Credits to [@RemyK888](https://github.com/RemyK888) for initial foundations


pkgId: b4676a0d3523e0f03cf208e9d4a32bd9db07704e86fd3f39916864338ebbc9ee
name: python-discord-webhook
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: execute discord webhooks
url: https://github.com/lovvskillz/python-discord-webhook
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4d697415-a48d-4d62-a610-7f265080888d
location_href: 00009235-python-discord-webhook/python-discord-webhook-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://raw.githubusercontent.com/lovvskillz/python-discord-webhook/master/LICENSE)
  [![PyPI version](https://badge.fury.io/py/discord-webhook.svg)](https://badge.fury.io/py/discord-webhook)
  [![Downloads](https://pepy.tech/badge/discord-webhook)](https://pepy.tech/project/discord-webhook)

  Execute Discord Webhooks (also has [async support](#async-support))



  Install via pip:
  ```
  pip install discord-webhook
  ```



  * [Basic Webhook](#basic-webhook)
  * [Create Multiple Instances / Use multiple URLs](#create-multiple-instances)
  * [Manage Being Rate Limited](#manage-being-rate-limited)
  * [Embedded Content](#webhook-with-embedded-content)
  * [Edit Webhook Message](#edit-webhook-messages)
  * [Delete Webhook Message](#delete-webhook-messages)
  * [Send Files](#send-files)
  * [Remove Embeds and Files](#remove-embeds-and-files)
  * [Allowed Mentions](#allowed-mentions)
  * [Use Proxies](#use-proxies)
  * [Timeout](#timeout)
  * [Async Support](#async-support)



  ```python
  from discord_webhook import DiscordWebhook

  webhook = DiscordWebhook(url='your webhook url', content='Webhook Message')
  response = webhook.execute()
  ```


  If you want to use multiple URLs you need to create multiple instances.

  ```python
  from discord_webhook import DiscordWebhook


  webhook1, webhook2 = DiscordWebhook.create_batch(urls=['first url', 'second url'], content='Webhook Message')
  response1 = webhook1.execute()
  response2 = webhook2.execute()
  ```
  ![Image](img/multiple_urls.png "Multiple Urls Result")



  ```python
  from discord_webhook import DiscordWebhook




  webhook = DiscordWebhook(url='your webhook url', rate_limit_retry=True,
                           content='Webhook Message')
  response = webhook.execute()
  ```

  ![Image](img/basic_webhook.png "Basic Example Result")



  ```python
  from discord_webhook import DiscordWebhook, DiscordEmbed

  webhook = DiscordWebhook(url='your webhook url')



  embed = DiscordEmbed(title='Your Title', description='Lorem ipsum dolor sit', color='03b2f8')


  webhook.add_embed(embed)

  response = webhook.execute()
  ```

  ![Image](img/simple_embed.png "Basic Embed Example Result")

  ```python
  from discord_webhook import DiscordWebhook, DiscordEmbed

  webhook = DiscordWebhook(url='your webhook url')


  embed = DiscordEmbed(title='Your Title', description='Lorem ipsum dolor sit', color='03b2f8')


  embed.set_author(name='Author Name', url='author url', icon_url='author icon url')


  embed.set_image(url='your image url')


  embed.set_thumbnail(url='your thumbnail url')


  embed.set_footer(text='Embed Footer Text', icon_url='URL of icon')


  embed.set_timestamp()


  embed.add_embed_field(name='Field 1', value='Lorem ipsum')
  embed.add_embed_field(name='Field 2', value='dolor sit')


  webhook.add_embed(embed)

  response = webhook.execute()
  ```

  ![Image](img/extended_embed.png "Basic Embed Example Result")

  This is another example with embedded content

  ```python
  from discord_webhook import DiscordWebhook, DiscordEmbed

  webhook = DiscordWebhook(url='your webhook url', username="New Webhook Username")

  embed = DiscordEmbed(title='Embed Title', description='Your Embed Description', color='03b2f8')
  embed.set_author(name='Author Name', url='https://github.com/lovvskillz', icon_url='https://avatars0.githubusercontent.com/u/14542790')
  embed.set_footer(text='Embed Footer Text')
  embed.set_timestamp()
  embed.add_embed_field(name='Field 1', value='Lorem ipsum')
  embed.add_embed_field(name='Field 2', value='dolor sit')
  embed.add_embed_field(name='Field 3', value='amet consetetur')
  embed.add_embed_field(name='Field 4', value='sadipscing elitr')

  webhook.add_embed(embed)
  response = webhook.execute()
  ```

  ![Image](img/extended_embed2.png "Example Embed Result")

  By Default, the Embed fields are placed side by side. We can arrange them in a new line by setting `inline=False` as follows:

  ```python
  from discord_webhook import DiscordWebhook, DiscordEmbed

  webhook = DiscordWebhook(url="your webhook url", username="New Webhook Username")

  embed = DiscordEmbed(
      title="Embed Title", description="Your Embed Description", color='03b2f8'
  )
  embed.set_author(
      name="Author Name",
      url="https://github.com/lovvskillz",
      icon_url="https://avatars0.githubusercontent.com/u/14542790",
  )
  embed.set_footer(text="Embed Footer Text")
  embed.set_timestamp()

  embed.add_embed_field(name="Field 1", value="Lorem ipsum", inline=False)
  embed.add_embed_field(name="Field 2", value="dolor sit", inline=False)
  embed.add_embed_field(name="Field 3", value="amet consetetur")
  embed.add_embed_field(name="Field 4", value="sadipscing elitr")

  webhook.add_embed(embed)
  response = webhook.execute()
  ```

  ![Image](img/extended_embed3.png "Example Non-Inline Embed Result")



  ```python
  from discord_webhook import DiscordWebhook
  from time import sleep

  webhook = DiscordWebhook(url='your webhook url', content='Webhook content before edit')
  webhook.execute()
  webhook.content = 'After Edit'
  sleep(10)
  webhook.edit()
  ```



  ```python
  from discord_webhook import DiscordWebhook
  from time import sleep

  webhook = DiscordWebhook(url='your webhook url', content='Webhook Content')
  webhook.execute()
  sleep(10)
  webhook.delete()
  ```



  ```python
  from discord_webhook import DiscordWebhook

  webhook = DiscordWebhook(url='your webhook url', username="Webhook with files")


  with open("path/to/first/image.jpg", "rb") as f:
      webhook.add_file(file=f.read(), filename='example.jpg')
  with open("path/to/second/image.jpg", "rb") as f:
      webhook.add_file(file=f.read(), filename='example2.jpg')

  response = webhook.execute()
  ```

  ![Image](img/webhook_files.png "Example Files Result")

  You can use uploaded attachments in Embeds:

  ```python
  from discord_webhook import DiscordWebhook, DiscordEmbed

  webhook = DiscordWebhook(url='your webhook url')

  with open("path/to/image.jpg", "rb") as f:
      webhook.add_file(file=f.read(), filename='example.jpg')

  embed = DiscordEmbed(title='Embed Title', description='Your Embed Description', color='03b2f8')
  embed.set_thumbnail(url='attachment://example.jpg')

  webhook.add_embed(embed)
  response = webhook.execute()
  ```



  ```python
  from discord_webhook import DiscordWebhook, DiscordEmbed

  webhook = DiscordWebhook(url='your webhook url')

  with open("path/to/image.jpg", "rb") as f:
      webhook.add_file(file=f.read(), filename='example.jpg')

  embed = DiscordEmbed(title='Embed Title', description='Your Embed Description', color='03b2f8')
  embed.set_thumbnail(url='attachment://example.jpg')

  webhook.add_embed(embed)
  response = webhook.execute(remove_embeds=True)


  ```

  `.remove_file()` removes the given file

  ```python
  from discord_webhook import DiscordWebhook

  webhook = DiscordWebhook(url='your webhook url', username="Webhook with files")


  with open("path/to/first/image.jpg", "rb") as f:
      webhook.add_file(file=f.read(), filename='example.jpg')
  with open("path/to/second/image.jpg", "rb") as f:
      webhook.add_file(file=f.read(), filename='example2.jpg')

  webhook.remove_file('example.jpg')

  response = webhook.execute()
  ```



  Look into the [Discord Docs](https://discord.com/developers/docs/resources/channel#allowed-mentions-object) for examples and for more explanation

  This example would only ping user `123` and `124` but not everyone else.

  ```python
  from discord_webhook import DiscordWebhook

  content = "@everyone say hello to our new friends <@123> and <@124>"
  allowed_mentions = {
      "users": ["123", "124"]
  }

  webhook = DiscordWebhook(url='your webhook url', content=content, allowed_mentions=allowed_mentions)
  response = webhook.execute()
  ```



  ```python
  from discord_webhook import DiscordWebhook

  proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
  }
  webhook = DiscordWebhook(url='your webhook url', content='Webhook Message', proxies=proxies)
  response = webhook.execute()
  ```
  or
  ```python
  from discord_webhook import DiscordWebhook

  proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
  }
  webhook = DiscordWebhook(url='your webhook url', content='Webhook Message')
  webhook.set_proxies(proxies)
  response = webhook.execute()
  ```



  ```
  usage: discord_webhook [-h] -u URL [URL ...] -c CONTENT [--username USERNAME]
                         [--avatar_url AVATAR_URL]

  Trigger discord webhook(s).

  optional arguments:
    -h, --help            show this help message and exit
    -u URL [URL ...], --url URL [URL ...]
                          Webhook(s) url(s)
    -c CONTENT, --content CONTENT
                          Message content
    --username USERNAME   override the default username of the webhook
    --avatar_url AVATAR_URL
                          override the default avatar of the webhook
  ```



  ```python
  from requests.exceptions import Timeout
  from discord_webhook import DiscordWebhook, DiscordEmbed


  webhook = DiscordWebhook(url='your webhook url', timeout=0.1)




  embed = DiscordEmbed(title='Embed Title', description='Your Embed Description', color='03b2f8')

  webhook.add_embed(embed)


  try:
      response = webhook.execute()
  except Timeout as err:
      print(f'Oops! Connection to Discord timed out: {err}')
  ```


  In order to use the async version, you need to install the package using:
  ```
  pip install discord-webhook[async]
  ```
  Example usage:
  ```python
  import asyncio
  from discord_webhook import AsyncDiscordWebhook


  async def send_webhook(message):
      webhook = AsyncDiscordWebhook(url='your webhook url', content=message)
      await webhook.execute()


  async def main():
      await asyncio.gather(
          send_webhook('Async webhook message 1'),
          send_webhook('Async webhook message 2'),
      )  # sends both messages asynchronously


  asyncio.run(main())
  ```




  This project uses [Poetry](https://python-poetry.org/docs/) for dependency management and packaging.

  Install Poetry and add Poetry to [Path](https://python-poetry.org/docs/#installation).

  **Debian / Ubuntu / Mac**

  `curl -sSL https://install.python-poetry.org | python3 -`

  **Windows**

  open powershell and run: `(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -`

  Install dependencies: `poetry install`

  Install the defined pre-commit hooks: `poetry run pre-commit install`

  Activate the virtualenv: `poetry shell`


pkgId: 989ec4bd214cbc92dd635ae30c11402fa012cd521b2716728808cba1fc896029
name: python-discord.js
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: The Python module for discord.js.
url: https://pypi.org/project/discord.js/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-47b8a7bc-ee88-47f4-acba-3f0141f443ba
location_href: 00013926-python-discord-js/python-discord.js-1.0.7-1.src.rpm
checksum_type: sha256
description:
  This module lets you use discord.js in python by offering a similar syntax to the actual discord.js.



  Stable version:

  ```
  pip install discord.js
  ```

  Working version:

  ```
  pip install git+https://github.com/CodeWithSwastik/discord-js
  ```



  ```python
  from discordjs import Client
  from javascript import console

  client = Client()

  client.on("ready", lambda:
      console.log("Bot is ready")
  )

  async def msg(message):
      if message.content.startswith("!ping"):
          await message.channel.send("pong")

  client.on("message", msg)

  client.login('Token')
  ```


pkgId: 6bd0fb6b8097cb99b7d2ff1a8436fea99adedc56f38c5dea9d3f6196e14e1579
name: python-discord.py-self
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: A Python wrapper for the Discord user API
url: https://github.com/dolfies/discord.py-self
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-41f558e8-e9fd-42aa-b374-2dcf9a18a357
location_href: 00011677-python-discord-py-self/python-discord.py-self-2.0.0-1.src.rpm
checksum_type: sha256
description:
  A modern, easy to use, feature-rich, and async ready API wrapper for Discord's user API written in Python.
  | **Note:**
  | Automating user accounts is against the Discord ToS. This library is a proof of concept and I cannot recommend using it. Do so at your own risk.


pkgId: 26f7e999d4a10bd799b0d3eb23c64356c2ae914bd6aca7266f8d505b3f0abaf9
name: python-diskcache
arch: src
version: 5.4.0
epoch: 0
release: 1
summary: Disk Cache -- Disk and file backed persistent cache.
url: http://www.grantjenks.com/docs/diskcache/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c1b6a08a-1b01-4528-8533-c4660903cc02
location_href: 00003441-python-diskcache/python-diskcache-5.4.0-1.src.rpm
checksum_type: sha256
description:
  `DiskCache`_ is an Apache2 licensed disk and file backed cache library, written
  in pure-Python, and compatible with Django.
  The cloud-based computing of 2021 puts a premium on memory. Gigabytes of empty
  space is left on disks as processes vie for memory. Among these processes is
  Memcached (and sometimes Redis) which is used as a cache. Wouldn't it be nice
  to leverage empty disk space for caching?
  Django is Python's most popular web framework and ships with several caching
  backends. Unfortunately the file-based cache in Django is essentially
  broken. The culling method is random and large caches repeatedly scan a cache
  directory which slows linearly with growth. Can you really allow it to take
  sixty milliseconds to store a key in a cache with a thousand items?
  In Python, we can do better. And we can do it in pure-Python!
     In [1]: import pylibmc
     In [2]: client = pylibmc.Client(['127.0.0.1'], binary=True)
     In [3]: client[b'key'] = b'value'
     In [4]: %timeit client[b'key']
     10000 loops, best of 3: 25.4 µs per loop
     In [5]: import diskcache as dc
     In [6]: cache = dc.Cache('tmp')
     In [7]: cache[b'key'] = b'value'
     In [8]: %timeit cache[b'key']
     100000 loops, best of 3: 11.8 µs per loop
  **Note:** Micro-benchmarks have their place but are not a substitute for real
  measurements. DiskCache offers cache benchmarks to defend its performance
  claims. Micro-optimizations are avoided but your mileage may vary.
  DiskCache efficiently makes gigabytes of storage space available for
  caching. By leveraging rock-solid database libraries and memory-mapped files,
  cache performance can match and exceed industry-standard solutions. There's no
  need for a C compiler or running another process. Performance is a feature and
  testing has 100% coverage with unit tests and hours of stress.


pkgId: 8503b8ce6fc2f4661d967f97502f3fa294c19257f5a6da9dbc3627182bff8020
name: python-distconfig
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Library to manage configuration using Zookeeper, Etcd, Consul
url: http://github.com/deliveryhero/distconfig/
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f0693e3-dd7a-4ec8-a5f9-2d55b94a91e5
location_href: 00012173-python-distconfig/python-distconfig-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Library to manage distributed configuration using either `ZooKeeper <https://zookeeper.apache.org/>`_ or
  `Etcd <https://github.com/coreos/etcd>`_ or `Consul <http://www.consul.io/>`_.


pkgId: f5241c8dec9a50b9e90b281f2d641bb4ce62bb34b4c91b1f6d90dfc9d9617c36
name: python-distributed
arch: src
version: 2023.3.2.1
epoch: 0
release: 1
summary: Distributed scheduler for Dask
url: https://distributed.dask.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c5c0c547-75eb-440d-8973-651ab5f0b31e
location_href: 00009104-python-distributed/python-distributed-2023.3.2.1-1.src.rpm
checksum_type: sha256
description:
  |Test Status| |Longitudinal Report (full)| |Longitudinal Report (short)| |Coverage| |Doc Status| |Discourse| |Version Status| |NumFOCUS|
  A library for distributed computation.  See documentation_ for more details.


pkgId: 04aa23776c9ba26a4120e194e67ec6e94888fb5eb1644a23224da195c4988cc2
name: python-distroinfo
arch: src
version: 0.6.2
epoch: 0
release: 1
url: https://github.com/softwarefactory-project/distroinfo
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-44009308-e716-440a-b9ce-9fb717a91a97
location_href: 00003443-python-distroinfo/python-distroinfo-0.6.2-1.src.rpm
checksum_type: sha256
summary:
  python module for parsing, validating and querying distribution/packaging metadata stored in human readable and reviewable text/YAML files

description:
  ``distroinfo`` is a python module for parsing, validating and querying
  distribution/packaging metadata stored in human readable and reviewable
  text/YAML files.
  This is a proper generic (re)implementation of
  `rdoinfo <https://github.com/redhat-openstack/rdoinfo>`__ parser which
  proved well suited for the task of interfacing with distribution
  metadata in a human friendly way. If you consider code reviews human
  friendly, that is.
  ``distroinfo`` is a part of `Software Factory
  project <https://softwarefactory-project.io/docs/>`__


pkgId: 6e86bc8e0bb22e92c501597f2a296967f4aaabe2b7e42353bf413023c7280498
name: python-dj-database-url
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Use Database URLs in your Django Application.
url: https://github.com/jazzband/dj-database-url
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-52d6f3e8-eddf-462c-b42f-0fb3b81cb79d
location_href: 00009705-python-dj-database-url/python-dj-database-url-1.3.0-1.src.rpm
checksum_type: sha256
description:
  Support currently exists for PostgreSQL, PostGIS, MySQL, MySQL (GIS),
  Oracle, Oracle (GIS), Redshift, CockroachDB, Timescale, Timescale (GIS) and SQLite.


pkgId: 765fca60f5a0f9f92f1d8addce82fd239d09cf1c0c77836caa9a231b20078cc9
name: python-dj-rest-auth
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Authentication and Registration in Django Rest Framework
url: http://github.com/iMerica/dj-rest-auth
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f9ecda5-eed6-4317-ae65-9eae10fafc0f
location_href: 00011578-python-dj-rest-auth/python-dj-rest-auth-3.0.0-1.src.rpm
checksum_type: sha256
description:
  [![<iMerica>](https://circleci.com/gh/iMerica/dj-rest-auth.svg?style=svg)](https://app.circleci.com/pipelines/github/iMerica/dj-rest-auth)


  Drop-in API endpoints for handling authentication securely in Django Rest Framework. Works especially well
  with SPAs (e.g React, Vue, Angular), and Mobile applications.


  - Django 2, 3 or 4 (See Unit Test Coverage in CI)
  - Python 3



  Install package

      pip install dj-rest-auth

  Add `dj_rest_auth` app to INSTALLED_APPS in your django settings.py:

  ```python
  INSTALLED_APPS = (
      ...,
      'rest_framework',
      'rest_framework.authtoken',
      ...,
      'dj_rest_auth'
  )
  ```

  Add URL patterns

  ```python
  urlpatterns = [
      path('dj-rest-auth/', include('dj_rest_auth.urls')),
  ]
  ```


  (Optional) Use Http-Only cookies

  ```python
  REST_AUTH = {
      'USE_JWT': True,
      'JWT_AUTH_COOKIE': 'jwt-auth',
  }
  ```



  Install required modules with `pip install -r  dj_rest_auth/tests/requirements.pip`

  To run the tests within a virtualenv, run `python runtests.py` from the repository directory.
  The easiest way to run test coverage is with [`coverage`](https://pypi.org/project/coverage/),
  which runs the tests against all supported Django installs. To run the test coverage
  within a virtualenv, run `coverage run ./runtests.py` from the repository directory then run `coverage report`.



  Testing may also be done using [`tox`](https://pypi.org/project/tox/), which
  will run the tests against all supported combinations of python and django.

  Install tox, either globally or within a virtualenv, and then simply run `tox`
  from the repository directory. As there are many combinations, you may run them
  in [`parallel`](https://tox.readthedocs.io/en/latest/config.html#cmdoption-tox-p)
  using `tox --parallel`.

  The `tox.ini` includes an environment for testing code [`coverage`](https://pypi.org/project/coverage/)
  and you can run it and view this report with `tox -e coverage`.

  Linting may also be performed via [`flake8`](https://pypi.org/project/flake8/)
  by running `tox -e flake8`.



  View the full documentation here: https://dj-rest-auth.readthedocs.io/en/latest/index.html




  This project began as a fork of `django-rest-auth`. Big thanks to everyone who contributed to that repo!



  This project has an optional and very narrow support for Django-AllAuth. As maintainer I have no intererest in making this package support every and all use case in Django All Auth. I would rather focus on improving the quality of the base funtionality or focus on OIDC support instead. Pull requests that extend or add more support for Django AllAuth will most likely be declined. Do you disagreee? Feel free to fork this repo!


pkgId: 25703bad066b52a52b368251b1f568d4b20492b7aca2bbdc8052514c5ef9af2f
name: python-dj-static
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Serve production static files with Django.
url: https://github.com/kennethreitz/dj-static
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e7151c82-7e2e-4338-813e-dfb5de5dedb0
location_href: 00012092-python-dj-static/python-dj-static-0.0.6-1.src.rpm
checksum_type: sha256
description:
  Configure your static assets in ``settings.py``::
     STATIC_ROOT = 'staticfiles'
     STATIC_URL = '/static/'
  Then, update your ``wsgi.py`` file to use dj-static::
      from django.core.wsgi import get_wsgi_application
      from dj_static import Cling
      application = Cling(get_wsgi_application())


pkgId: 777598c126d1c10cdef3e18a9113e297502b0ed5481fc5775170e43d3b11f69a
name: python-django-activity-stream
arch: src
version: 1.4.2
epoch: 0
release: 1
url: http://github.com/justquick/django-activity-stream
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-20a066b3-89bb-4844-9089-579461b7a407
location_href: 00014102-python-django-activity-stream/python-django-activity-stream-1.4.2-1.src.rpm
checksum_type: sha256
summary:
  Generate generic activity streams from the actions on your site. Users can follow any actors' activities for personalized streams.


pkgId: ff933a081f9e95495d84f38190b12c39488804fd9a1f669e8e25388bbe8f071e
name: python-django-add-default-value
arch: src
version: 0.10.0
epoch: 0
release: 1
url: https://github.com/3YOURMIND/django-add-default-value
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5f3f7594-7d62-49bb-ad99-7f0ed1429763
location_href: 00013259-python-django-add-default-value/python-django-add-default-value-0.10.0-1.src.rpm
checksum_type: sha256
summary:
  This django Migration Operation can be used to transfer a fields default value to the database scheme.

description:
  Django Migration Operation that can be used to transfer a field's default value
  to the database scheme.
  [![PyPi](https://img.shields.io/pypi/v/django-add-default-value.svg?branch=master)](https://pypi.python.org/pypi/django-add-default-value/)
  [![License](https://img.shields.io/github/license/3yourmind/django-add-default-value.svg)](./LICENSE)
  [![Contributing](https://img.shields.io/badge/PR-welcome-green.svg)](https://github.com/3YOURMIND/django-add-default-value/pulls)
  [![3yourminD-Careers](https://img.shields.io/badge/3YOURMIND-Hiring-brightgreen.svg)](https://www.3yourmind.com/career)
  [![Stars](https://img.shields.io/github/stars/3YOURMIND/django-add-default-value.svg?style=social&label=Stars)](https://github.com/3YOURMIND/django-add-default-value/stargazers)


pkgId: 258183540beea897610c9910d4ad0f8939cb3eb11f37bb44d3e010440fa75ecc
name: python-django-admin-autocomplete-filter
arch: src
version: 0.7.1
epoch: 0
release: 1
summary: A simple Django app to render list filters in django admin using autocomplete widget
url: https://github.com/farhan0581/django-admin-autocomplete-filter
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76314df3-4676-42de-bdbe-e27dfc998636
checksum_type: sha256
description:
  A simple Django app to render list filters in django admin using an autocomplete widget. This app is heavily inspired by [dal-admin-filters.](https://github.com/shamanu4/dal_admin_filters)

location_href:
  00012736-python-django-admin-autocomplete-filter/python-django-admin-autocomplete-filter-0.7.1-1.src.rpm


pkgId: 01a074bd1699a28147762d1bce2ad734df8056e2d3c0bd0a0c4162c8437a3d08
name: python-django-admin-autocomplete-filter-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for django-admin-autocomplete-filter
url: https://github.com/farhan0581/django-admin-autocomplete-filter
rpm_license: GNU Lesser General Public License v3 (LGPLv3)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-76314df3-4676-42de-bdbe-e27dfc998636
rpm_sourcerpm: python-django-admin-autocomplete-filter-0.7.1-1.src.rpm
checksum_type: sha256
description:
  A simple Django app to render list filters in django admin using an autocomplete widget. This app is heavily inspired by [dal-admin-filters.](https://github.com/shamanu4/dal_admin_filters)

location_href:
  00012736-python-django-admin-autocomplete-filter/python-django-admin-autocomplete-filter-help-0.7.1-1.noarch.rpm


pkgId: 6f3d846ac0953e5fcd20dcc8b03016441180308ee51987a0bbbd9a51267514d8
name: python-django-admin-interface
arch: src
version: 0.24.2
epoch: 0
release: 1
url: https://github.com/fabiocaccamo/django-admin-interface
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-14dd3b7d-f902-406f-bac2-173522d45cd2
location_href: 00013820-python-django-admin-interface/python-django-admin-interface-0.24.2-1.src.rpm
checksum_type: sha256
summary:
  django-admin-interface is a modern responsive flat admin interface customizable by the admin itself.


pkgId: d17ff918a8b04b3dacea80d557fcf17dc8e82b02041328c9a927e82b3be6d116
name: python-django-admin-list-filter-dropdown
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Use dropdowns in Django admin list filter
description: Use dropdowns in Django admin list filter
url: https://github.com/mrts/django-admin-list-filter-dropdown
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-393f9d97-f1c9-422f-86e1-1a6517df323e
checksum_type: sha256
location_href:
  00012242-python-django-admin-list-filter-dropdown/python-django-admin-list-filter-dropdown-1.0.3-1.src.rpm


pkgId: ba19884d1144536966de3352e32b46657b3b0ba30b366db8dde64e1d9c45d868
name: python-django-admin-list-filter-dropdown-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for django-admin-list-filter-dropdown
description: Use dropdowns in Django admin list filter
url: https://github.com/mrts/django-admin-list-filter-dropdown
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-393f9d97-f1c9-422f-86e1-1a6517df323e
rpm_sourcerpm: python-django-admin-list-filter-dropdown-1.0.3-1.src.rpm
checksum_type: sha256
location_href:
  00012242-python-django-admin-list-filter-dropdown/python-django-admin-list-filter-dropdown-help-1.0.3-1.noarch.rpm


pkgId: 5475dd80676c8a2d065e55e1538a467059a0c4fd914b05f86573440cd48f8b0d
name: python-django-admin-sortable
arch: src
version: 2.3
epoch: 0
release: 1
summary: Drag and drop sorting for models and inline models in Django admin.
url: https://github.com/iambrandontaylor/django-admin-sortable
rpm_license: APL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a93d64fa-79c3-455d-908a-8c1f20b8b607
location_href: 00012531-python-django-admin-sortable/python-django-admin-sortable-2.3-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |Python versions| |Build Status|
  This project makes it easy to add drag-and-drop ordering to any model in
  Django admin. Inlines for a sortable model may also be made sortable,
  enabling individual items or groups of items to be sortable.
  If you find Django Admin Sortable to be helpful, consider `buying me a
  coffee <https://www.buymeacoffee.com/NY9TUAEwF>`__!
  Sorting model instances with a sortable parent:
     sortable-models
  Sorting inlines:
     sortable-inlines


pkgId: cdc535c31b24ea49380455309780b99bb95a77c412e720d6cf5402566f809fda
name: python-django-admin-sortable2
arch: src
version: 2.1.5
epoch: 0
release: 1
url: https://github.com/jrief/django-admin-sortable2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-123b07e9-df0a-4a80-bd67-55ad9b25b3d7
location_href: 00011674-python-django-admin-sortable2/python-django-admin-sortable2-2.1.5-1.src.rpm
checksum_type: sha256
summary:
  Generic drag-and-drop sorting for the List, the Stacked- and the Tabular-Inlines Views in the Django Admin

description:
  This Django package adds functionality for generic drag-and-drop ordering of items in the List, the Stacked- and the
  Tabular-Inlines Views of the Django Admin interface.

  [![Build Status](https://github.com/jrief/django-admin-sortable2/actions/workflows/tests.yml/badge.svg)](https://github.com/jrief/django-admin-sortable2/actions/workflows/tests.yml)
  [![PyPI version](https://img.shields.io/pypi/v/django-admin-sortable2.svg)](https://pypi.python.org/pypi/django-admin-sortable2)
  [![Python versions](https://img.shields.io/pypi/pyversions/django-admin-sortable2.svg)](https://pypi.python.org/pypi/django-admin-sortable2)
  [![Django versions](https://img.shields.io/pypi/djversions/django-admin-sortable2)](https://pypi.python.org/pypi/django-admin-sortable2)
  [![Downloads](https://img.shields.io/pypi/dm/django-admin-sortable2.svg)](https://img.shields.io/pypi/dm/django-admin-sortable2.svg)
  [![Software license](https://img.shields.io/pypi/l/django-admin-sortable2.svg)](https://github.com/jrief/django-admin-sortable2/blob/master/LICENSE)

  Check the demo:

  ![Demo](https://raw.githubusercontent.com/jrief/django-admin-sortable2/master/docs/source/_static/django-admin-sortable2.gif)

  This library offers simple mixin classes which enrich the functionality of any existing class inheriting from
  `admin.ModelAdmin`, `admin.StackedInline` or `admin.TabularInline`.

  It thus makes it very easy to integrate with existing models and their model admin interfaces. Existing models can
  inherit from `models.Model` or any other class derived thereof. No special base class is required.




  This is a major rewrite of this **django-admin-sortable2**. It replaces the client side part against
  [Sortable.JS](https://sortablejs.github.io/Sortable/) and thus the need for jQuery.

  Replacing that library allowed me to add a new feature: Multiple items can now be dragged and dropped together.




  https://github.com/jrief/django-admin-sortable2

  Detailled documentation can be found on [ReadTheDocs](https://django-admin-sortable2.readthedocs.org/en/latest/).

  Before reporting bugs or asking questions, please read the
  [contributor's guide](https://django-admin-sortable2.readthedocs.io/en/latest/contributing.html).




  Licensed under the terms of the MIT license.

  Copyright &copy; 2013-2022 Jacob Rief and contributors.

  Please follow me on
  [![Twitter Follow](https://img.shields.io/twitter/follow/jacobrief.svg?style=social&label=Jacob+Rief)](https://twitter.com/jacobrief)
  for updates and other news.


pkgId: fa70d806d94974df0af4b23efa64dc3ade32876b4003fe666abcccbc712462e7
name: python-django-ajax-selects
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Edit ForeignKey, ManyToManyField and CharField in Django Admin using jQuery UI AutoComplete.
url: https://github.com/crucialfelix/django-ajax-selects/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1847e77-912e-4666-8e3e-a98a886db16c
location_href: 00003446-python-django-ajax-selects/python-django-ajax-selects-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Edit ForeignKey, ManyToManyField and CharField in Django Admin using jQuery UI AutoComplete.

  - Customize search query
  - Query other resources besides Django ORM
  - Format results with HTML
  - Customize styling
  - Customize security policy
  - Add additional custom UI alongside widget
  - Integrate with other UI elements elsewhere on the page using the javascript API
  - Works in Admin as well as in normal views

  - Django >=3, <=4
  - Python >=3.6


pkgId: 4fe34b65407ee57a8eed18596ed0383346bafbc0a00d74e993cf00a1e6861d41
name: python-django-allauth
arch: src
version: 0.54.0
epoch: 0
release: 1
url: http://www.intenct.nl/projects/django-allauth/
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-03ffcb3e-8240-4f66-89af-e893e5cdcbce
location_href: 00010031-python-django-allauth/python-django-allauth-0.54.0-1.src.rpm
checksum_type: sha256
summary:
  Integrated set of Django applications addressing authentication, registration, account management as well as 3rd party (social) account authentication.


pkgId: 0791e3c398eccbdd7140be61ac7dc48c2a5eeda1c03c25971157f58a6c227e20
name: python-django-amazon-ses
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: A Django email backend that uses Boto3 to interact with Amazon Simple Email Service (SES).
url: https://github.com/azavea/django-amazon-ses
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d6a08c6-a82b-45f1-8b59-beb47de7deea
location_href: 00013363-python-django-amazon-ses/python-django-amazon-ses-4.0.1-1.src.rpm
checksum_type: sha256
description:
  A Django email backend that uses `Boto 3 <https://boto3.readthedocs.io/en/latest/>`_ to interact with `Amazon Simple Email Service (SES) <https://aws.amazon.com/ses/>`_.


pkgId: a4af8513d2982e0a76b1308a4ef4c15fab8f75644d6e1ce16d292245b240e453
name: python-django-angular
arch: src
version: 2.3
epoch: 0
release: 1
summary: Let Django play well with AngularJS
url: https://github.com/jrief/django-angular
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b552f623-9743-4524-8551-37f466c0732b
location_href: 00003447-python-django-angular/python-django-angular-2.3-1.src.rpm
checksum_type: sha256
description:
  Let Django play well with AngularJS

  [![Build Status](https://travis-ci.org/jrief/django-angular.svg?branch=master)](https://travis-ci.org/jrief/django-angular)
  [![PyPI version](https://img.shields.io/pypi/v/django-angular.svg)](https://pypi.python.org/pypi/django-angular)
  [![Python versions](https://img.shields.io/pypi/pyversions/django-angular.svg)](https://pypi.python.org/pypi/django-angular)
  [![Software license](https://img.shields.io/pypi/l/django-angular.svg)](https://github.com/jrief/django-angular/blob/master/LICENSE-MIT)
  [![Twitter Follow](https://img.shields.io/twitter/follow/jacobrief.svg?style=social&label=Jacob+Rief)](https://twitter.com/jacobrief)



  Add AngularJS directives to Django Forms. This allows to handle client side form validation using
  the constraints provided by the server side Form declaration.

  For more information, please visit the [demo site](https://django-angular.awesto.com/form_validation/).




  ```
  git clone https://github.com/jrief/django-angular.git django-angular.git
  cd django-angular.git
  docker build -t django-angular.git .
  docker run -d -it -p 9002:9002 django-angular.git
  ```

  Open the application at `http://{docker-host's-ip}:9002/`



  To be compliant with other libraries such as **djangorestframework**,  server-side responses on
  rejected forms use error code 422, rather than 200. If you use your own form controllers, adopt
  them accordingly. The JSON format used to communicate errors downstream has changed slightly.



  For a smoother transition path, **django-angular** added two directives in version 2.0:

  ``<form djng-endpoint="/path/to/endpoint">...</form>``, which can be used to upload form
  data to the server. It also populates the error fields, in case the server rejected some data.

  ``<djng-forms-set endpoint="/path/to/endpoint"><form ...>...</form>...</djng-forms-set>``
  Similar to the above directive, but rather than validating one single form, it validates a
  set of forms using one shared endpoint.

  A promise chain has been introduced. Buttons used to submit form data and then proceed with
  something else, now can be written as:

  ``<button ng-click="do(update()).then(redirectTo('/path/to/other/page'))">Label</button>``




  Detailed documentation on [ReadTheDocs](http://django-angular.readthedocs.org/en/latest/).

  [Demo](http://django-angular.awesto.com/form_validation/) on how to combine Django with Angular's form validation.

  Please drop me a line, if and where you use this project.




  * Seamless integration of Django forms with AngularJS controllers.
  * Client side form validation for Django forms using AngularJS.
  * Let an AngularJS controller call methods in a Django view - kind of Javascript RPCs.
  * Manage Django URLs for static controller files.
  * Three way data binding to connect AngularJS models with a server side message queue.
  * Perform basic CRUD operations.



  * Implement Filter On Single Page Application using Django & Angular JS https://shriniket.home.blog/2019/09/22/integrate-angular-js-with-django-filter-application/




  Copyright &copy; 2019

  MIT licensed


pkgId: 457e14f3fee875f801600282a16b4d77f1127b0486dc07093a9b360b5fce51ca
name: python-django-annoying
arch: src
version: 0.10.6
epoch: 0
release: 1
summary: This is a django application that tries to eliminate annoying things in the Django framework.
url: https://github.com/skorokithakis/django-annoying
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ac944593-775c-419c-af10-3e041be59f78
location_href: 00003449-python-django-annoying/python-django-annoying-0.10.6-1.src.rpm
checksum_type: sha256
description:
  **Features:**

      - render_to decorator - Reduce typing in django views.
      - signals decorator - Allow using signals as decorators.
      - ajax_request decorator - Returns JsonResponse with dict as content.
      - autostrip decorator - Strip form text fields before validation.
      - get_object_or_None function - Similar to get_object_or_404, but returns None if the object is not found.
      - get_config function - Get settings from django.conf if exists, return a default value otherwise.
      - AutoOneToOne field - Creates related object on first call if it doesn't exist yet.
      - HttpResponseReload - Reload and stay on same page from where request was made.
      - StaticServer middleware - Instead of configuring urls.py, just add this middleware and it will serve you static files.
      - JSONField - A field that stores a Python object as JSON and retrieves it as a Python object.


  **Installation instructions:**

       - Copy the "annoying" directory to your Django project or put it in your PYTHONPATH.
       - You can also run "python setup.py install", "easy_install django-annoying", or "pip install django-annoying".


  **Download:**

      - git clone git://github.com/skorokithakis/django-annoying.git
      - hg clone http://bitbucket.org/Stavros/django-annoying/


pkgId: da53f51e51f859e0c610a33c0fe7e643a65ce7f150aa022edcb1b0674cf48ac3
name: python-django-anymail
arch: src
version: 9.1
epoch: 0
release: 1
url: https://github.com/anymail/django-anymail
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1ceedfd7-0a7e-4688-9bad-f68281b37912
location_href: 00010471-python-django-anymail/python-django-anymail-9.1-1.src.rpm
checksum_type: sha256
summary:
  Django email backends and webhooks for Amazon SES, MailerSend, Mailgun, Mailjet, Mandrill, Postal, Postmark, SendGrid, SendinBlue, and SparkPost

description:
      * Github: project page, exactly as it appears here
      * Docs: shared-intro section gets included in docs/index.rst
              quickstart section gets included in docs/quickstart.rst
      * PyPI: project page (via setup.py long_description),
              with several edits to freeze it to the specific PyPI release
              (see long_description_from_readme in setup.py)
      You can use docutils 1.0 markup, but *not* any Sphinx additions.
      GitHub rst supports code-block, but *no other* block directives.
  Anymail lets you send and receive email in Django using your choice
  of transactional email service providers (ESPs). It extends the
  standard `django.core.mail` with many common ESP-added features, providing
  a consistent API that avoids locking your code to one specific ESP
  (and making it easier to change ESPs later if needed).
  Anymail currently supports these ESPs:
  * **Amazon SES**
  * **MailerSend**
  * **Mailgun**
  * **Mailjet**
  * **Mandrill** (MailChimp transactional)
  * **Postal** (self-hosted ESP)
  * **Postmark**
  * **SendGrid**
  * **SendinBlue**
  * **SparkPost**
  Anymail includes:
  * Integration of each ESP's sending APIs into
    `Django's built-in email <https://docs.djangoproject.com/en/v9.1/topics/email/>`_
    package, including support for HTML, attachments, extra headers,
    and other standard email features
  * Extensions to expose common ESP-added functionality, like tags, metadata,
    and tracking, with code that's portable between ESPs
  * Simplified inline images for HTML email
  * Normalized sent-message status and tracking notification, by connecting
    your ESP's webhooks to Django signals
  * "Batch transactional" sends using your ESP's merge and template features
  * Inbound message support, to receive email through your ESP's webhooks,
    with simplified, portable access to attachments and other inbound content
  Anymail maintains compatibility with all Django versions that are in mainstream
  or extended support, plus (usually) a few older Django versions, and is extensively
  tested on all Python versions supported by Django. (Even-older Django versions
  may still be covered by an Anymail extended support release; consult the
  `changelog <https://anymail.dev/en/v9.1/changelog/>`_ for details.)
  Anymail releases follow `semantic versioning <https://semver.org/>`_.
  The package is released under the BSD license.
  **Resources**
  * Full documentation: https://anymail.dev/en/v9.1/
  * Help and troubleshooting: https://anymail.dev/en/v9.1/help/
  * Package on PyPI: https://pypi.org/project/django-anymail/
  * Project on Github: https://github.com/anymail/django-anymail
  * Changelog: https://anymail.dev/en/v9.1/changelog/


pkgId: 289396d63863653b6b3a2703b58d3e2e11c1da5d4db02d1049997ab72edcb29d
name: python-django-appconf
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: A helper class for handling configuration defaults of packaged apps gracefully.
url: https://django-appconf.readthedocs.io/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a5fb2568-76c6-4dd0-9439-9e95a0829600
location_href: 00003451-python-django-appconf/python-django-appconf-1.0.5-1.src.rpm
checksum_type: sha256
description:
  A helper class for handling configuration defaults of packaged Django
  apps gracefully.
      This app precedes Django's own AppConfig_ classes that act as
      "objects [to] store metadata for an application" inside Django's
      app loading mechanism. In other words, they solve a related but
      different use case than django-appconf and can't easily be used
      as a replacement. The similarity in name is purely coincidental.


pkgId: dc46cb63f3028659a0f0848e12d10fd59403a6498f620c15e7c09656f0ec89e7
name: python-django-autocomplete-light
arch: src
version: 3.9.4
epoch: 0
release: 1
summary: Fresh autocompletes for Django
url: http://django-autocomplete-light.rtfd.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1bcd7e00-0c79-49f7-b5a1-06e2612f4d35
location_href: 00011043-python-django-autocomplete-light/python-django-autocomplete-light-3.9.4-1.src.rpm
checksum_type: sha256
description:
  - Python 2.7, 3.4, Django 2.0+ support (Django 1.11 (LTS), is supported until django-autocomplete-light-3.2.10),
  - Django (multiple) choice support,
  - Django (multiple) model choice support,
  - Django generic foreign key support (through django-querysetsequence),
  - Django generic many to many relation support (through django-generic-m2m and
    django-gm2m)
  - Multiple widget support: select2.js, easy to add more.
  - Creating choices that don't exist in the autocomplete,
  - Offering choices that depend on other fields in the form, in an elegant and
    innovative way,
  - Dynamic widget creation (ie. inlines), supports YOUR custom scripts too,
  - Provides a test API for your awesome autocompletes, to support YOUR custom
    use cases too,
  - A documented automatically tested example for each use case in test_project.


pkgId: 0497e3a7312b574da4ac785eb69459217738e1075c7fa812fa00cacdfb708c53
name: python-django-autoslug
arch: src
version: 1.9.9
epoch: 0
release: 1
summary: An automated slug field for Django.
url: https://github.com/justinmayer/django-autoslug/
rpm_license: GNU Lesser General Public License (LGPL), Version 3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c6ed7a77-318f-4122-82df-c0c0e3629ea2
location_href: 00011843-python-django-autoslug/python-django-autoslug-1.9.9-1.src.rpm
checksum_type: sha256
description:
  *Python 3.7+ or PyPy*.
  *Django 3.2* or higher.
  It may be possible to successfully use django-autoslug in other environments
  but they are not tested.
    PyPy3 is not officially supported only because there were some problems with
    permissions and ``__pycache__`` on CI unrelated to django-autoslug itself.


pkgId: f4a65a498886d69e67d4c08e7a212a9055c9542ca1e8f73a6a1c2bd9a002f745
name: python-django-axes
arch: src
version: 5.41.0
epoch: 0
release: 1
summary: Keep track of failed login attempts in Django-powered sites.
url: https://github.com/jazzband/django-axes
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eb953003-7ad4-41ba-a56d-17700a62d1c5
location_href: 00010792-python-django-axes/python-django-axes-5.41.0-1.src.rpm
checksum_type: sha256
description:
  Axes is a Django plugin for keeping track of suspicious
  login attempts for your Django based website
  and implementing simple brute-force attack blocking.
  The name is sort of a geeky pun, since it can be interpreted as:
  * ``access``, as in monitoring access attempts, or
  * ``axes``, as in tools you can use to hack (generally on wood).


pkgId: ac6af64889a104fb36b0b5b49f145c72e4c36771ff47f7bb3980a4cebe9a97df
name: python-django-better-admin-arrayfield
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Better ArrayField widget for admin
url: https://github.com/gradam/django-better-admin-arrayfield
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae421fdf-d207-4fbf-8341-99de3daba76a
checksum_type: sha256
description:
  [![image](https://badge.fury.io/py/django-better-admin-arrayfield.svg)](https://badge.fury.io/py/django-better-admin-arrayfield)

  [![Actions Status](https://github.com/gradam/django-better-admin-arrayfield/workflows/tests/badge.svg)](https://github.com/gradam/django-better-admin-arrayfield/actions)

  [![image](https://codecov.io/gh/gradam/django-better-admin-arrayfield/branch/master/graph/badge.svg)](https://codecov.io/gh/gradam/django-better-admin-arrayfield)

  Better ArrayField widget for admin

  Supported Python versions: [![Python 3.5](https://img.shields.io/badge/python-3.5-blue.svg)](https://www.python.org/downloads/release/python-350/) [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://www.python.org/downloads/release/python-380/)





  Supported Django versions: 2.0, 2.1, 2.2, 3.0, 3.1

  might work with different django/python versions as well but I did not test that.

  It changes comma separated widget to list based in admin panel.

  Before:
  ![Alt text](https://raw.githubusercontent.com/gradam/django-better-admin-arrayfield/master/readme_images/before.jpg "Before")

  After:
  ![Alt text](https://raw.githubusercontent.com/gradam/django-better-admin-arrayfield/master/readme_images/after.png "After")



  Install Django better admin ArrayField:

      pip install django-better-admin-arrayfield

  Add it to your \`INSTALLED\_APPS\`:

  ```python
  INSTALLED_APPS = (
      ...
      'django_better_admin_arrayfield',
      ...
  )
  ```




  `django_better_admin_arrayfield.models.fields.ArrayField` is a drop-in replacement for standard Django `ArrayField`.

  Import it like below and use it in your model class definition.
  ```python
  from django_better_admin_arrayfield.models.fields import ArrayField
  ```

  Import DynamicArrayMixin like below
  ```python
  from django_better_admin_arrayfield.admin.mixins import DynamicArrayMixin
  ```

  In your admin class add `DynamicArrayMixin`:
      ...
  ```python
  class MyModelAdmin(admin.ModelAdmin, DynamicArrayMixin):
  ```

  That's it.




  By default the subwidget (the one used for each item in the array) will be TextInput. If you want something else, you can use your own specifying it in the `formfield_overrides` of your Admin model:
  ```python
  class MyWidget(DynamicArrayWidget):
      def __init__(self, *args, **kwargs):
          kwargs['subwidget_form'] = MyForm
          super().__init__(*args, **kwargs)

  class MyModelAdmin(models.ModelAdmin, DynamicArrayMixin):
      ...
      formfield_overrides = {
          DynamicArrayField: {'widget': MyWidget},
      }
  ```

  If you wanted to have Textarea as the subwidget, you can simply use the included drop-in widget replacement:
  ```python
  from django_better_admin_arrayfield.forms.widgets import DynamicArrayTextareaWidget

  class MyModelAdmin(models.ModelAdmin, DynamicArrayMixin):
      ...
      formfield_overrides = {
          DynamicArrayField: {'widget': DynamicArrayTextareaWidget},
      }
  ```



  Does the code actually work?

      source <YOURVIRTUALENV>/bin/activate
      (myenv) $ pip install tox
      (myenv) $ tox



  Install pre-commit black hook

      source <YOURVIRTUALENV>/bin/activate
      (myenv) $ pip install -r requirements_dev.txt
      (myenv) $ pre-commit install



  Inspired by: https://stackoverflow.com/a/49370480/4638248

  Tools used in rendering this
      package:

    - [Cookiecutter](https://github.com/audreyr/cookiecutter)
    - [cookiecutter-djangopackage](https://github.com/pydanny/cookiecutter-djangopackage)






    - Adjust template to better match django style



    - Allow submitting empty array field



    - allow choosing subwidget for DynamicArrayWidget



    - Handle default values in form field



    - Fix tests requirements



    - handle default values in model fields



    - Add spanish translations



    - Add possibility to i18n strings



    - Remove debugging print statements
    - use default_app_config for easier integration
    - Support dynamically-added inline forms



    - Add python 3.8 and Django 3.0 to tests



    - Can add item after removing everything from the list



    - Can add item after removing everything from the list
    - Do not call static at startup time



    - If field is required empty list raises ValidationError on clean.



    - Empty list is no longer recognized as changed.




    - First release on PyPI.

location_href:
  00012436-python-django-better-admin-arrayfield/python-django-better-admin-arrayfield-1.4.2-1.src.rpm


pkgId: 0c3cb856b199bc892de42f5434d058f62d6ac420a06ec350054c9545614e62ba
name: python-django-better-admin-arrayfield-help
arch: noarch
version: 1.4.2
epoch: 0
release: 1
summary: Development documents and examples for django-better-admin-arrayfield
url: https://github.com/gradam/django-better-admin-arrayfield
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ae421fdf-d207-4fbf-8341-99de3daba76a
rpm_sourcerpm: python-django-better-admin-arrayfield-1.4.2-1.src.rpm
checksum_type: sha256
description:
  [![image](https://badge.fury.io/py/django-better-admin-arrayfield.svg)](https://badge.fury.io/py/django-better-admin-arrayfield)

  [![Actions Status](https://github.com/gradam/django-better-admin-arrayfield/workflows/tests/badge.svg)](https://github.com/gradam/django-better-admin-arrayfield/actions)

  [![image](https://codecov.io/gh/gradam/django-better-admin-arrayfield/branch/master/graph/badge.svg)](https://codecov.io/gh/gradam/django-better-admin-arrayfield)

  Better ArrayField widget for admin

  Supported Python versions: [![Python 3.5](https://img.shields.io/badge/python-3.5-blue.svg)](https://www.python.org/downloads/release/python-350/) [![Python 3.6](https://img.shields.io/badge/python-3.6-blue.svg)](https://www.python.org/downloads/release/python-360/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://www.python.org/downloads/release/python-380/)





  Supported Django versions: 2.0, 2.1, 2.2, 3.0, 3.1

  might work with different django/python versions as well but I did not test that.

  It changes comma separated widget to list based in admin panel.

  Before:
  ![Alt text](https://raw.githubusercontent.com/gradam/django-better-admin-arrayfield/master/readme_images/before.jpg "Before")

  After:
  ![Alt text](https://raw.githubusercontent.com/gradam/django-better-admin-arrayfield/master/readme_images/after.png "After")



  Install Django better admin ArrayField:

      pip install django-better-admin-arrayfield

  Add it to your \`INSTALLED\_APPS\`:

  ```python
  INSTALLED_APPS = (
      ...
      'django_better_admin_arrayfield',
      ...
  )
  ```




  `django_better_admin_arrayfield.models.fields.ArrayField` is a drop-in replacement for standard Django `ArrayField`.

  Import it like below and use it in your model class definition.
  ```python
  from django_better_admin_arrayfield.models.fields import ArrayField
  ```

  Import DynamicArrayMixin like below
  ```python
  from django_better_admin_arrayfield.admin.mixins import DynamicArrayMixin
  ```

  In your admin class add `DynamicArrayMixin`:
      ...
  ```python
  class MyModelAdmin(admin.ModelAdmin, DynamicArrayMixin):
  ```

  That's it.




  By default the subwidget (the one used for each item in the array) will be TextInput. If you want something else, you can use your own specifying it in the `formfield_overrides` of your Admin model:
  ```python
  class MyWidget(DynamicArrayWidget):
      def __init__(self, *args, **kwargs):
          kwargs['subwidget_form'] = MyForm
          super().__init__(*args, **kwargs)

  class MyModelAdmin(models.ModelAdmin, DynamicArrayMixin):
      ...
      formfield_overrides = {
          DynamicArrayField: {'widget': MyWidget},
      }
  ```

  If you wanted to have Textarea as the subwidget, you can simply use the included drop-in widget replacement:
  ```python
  from django_better_admin_arrayfield.forms.widgets import DynamicArrayTextareaWidget

  class MyModelAdmin(models.ModelAdmin, DynamicArrayMixin):
      ...
      formfield_overrides = {
          DynamicArrayField: {'widget': DynamicArrayTextareaWidget},
      }
  ```



  Does the code actually work?

      source <YOURVIRTUALENV>/bin/activate
      (myenv) $ pip install tox
      (myenv) $ tox



  Install pre-commit black hook

      source <YOURVIRTUALENV>/bin/activate
      (myenv) $ pip install -r requirements_dev.txt
      (myenv) $ pre-commit install



  Inspired by: https://stackoverflow.com/a/49370480/4638248

  Tools used in rendering this
      package:

    - [Cookiecutter](https://github.com/audreyr/cookiecutter)
    - [cookiecutter-djangopackage](https://github.com/pydanny/cookiecutter-djangopackage)






    - Adjust template to better match django style



    - Allow submitting empty array field



    - allow choosing subwidget for DynamicArrayWidget



    - Handle default values in form field



    - Fix tests requirements



    - handle default values in model fields



    - Add spanish translations



    - Add possibility to i18n strings



    - Remove debugging print statements
    - use default_app_config for easier integration
    - Support dynamically-added inline forms



    - Add python 3.8 and Django 3.0 to tests



    - Can add item after removing everything from the list



    - Can add item after removing everything from the list
    - Do not call static at startup time



    - If field is required empty list raises ValidationError on clean.



    - Empty list is no longer recognized as changed.




    - First release on PyPI.

location_href:
  00012436-python-django-better-admin-arrayfield/python-django-better-admin-arrayfield-help-1.4.2-1.noarch.rpm


pkgId: 743a6ff850a5901a6d3c1066e8490c02b95755b4b395deb59e3ccc17481b3ba8
name: python-django-bootstrap3
arch: src
version: 23.1
epoch: 0
release: 1
summary: Bootstrap 3 support for Django projects
url: https://github.com/zostera/django-bootstrap3
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ef2525cb-2a17-4ca7-8d4a-4a88d08d312a
location_href: 00011669-python-django-bootstrap3/python-django-bootstrap3-23.1-1.src.rpm
checksum_type: sha256
description:
  A demo app is provided in `demo`. You can run it from your virtualenv with `python manage.py runserver`.


pkgId: cb2e88b5221ae3f3204ea6631391dd88594ccfc8def259b6e76fb5ba9623daab
name: python-django-bootstrap4
arch: src
version: 23.1
epoch: 0
release: 1
summary: Bootstrap 4 for Django
url: https://github.com/zostera/django-bootstrap4
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4ae2619-1169-4326-b33c-7ebaf5455346
location_href: 00011246-python-django-bootstrap4/python-django-bootstrap4-23.1-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/zostera/django-bootstrap4/workflows/CI/badge.svg?branch=main)](https://github.com/zostera/django-bootstrap4/actions?workflow=CI)
  [![Coverage Status](https://coveralls.io/repos/github/zostera/django-bootstrap4/badge.svg?branch=main)](https://coveralls.io/github/zostera/django-bootstrap4?branch=main)
  [![Latest PyPI version](https://img.shields.io/pypi/v/django-bootstrap4.svg)](https://pypi.python.org/pypi/django-bootstrap4)
  [![Any color you like](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  Bootstrap 4 integration for Django.



  The goal of this project is to seamlessly blend Django and Bootstrap 4.



  Python 3.7 or newer with Django 3.2 or newer.



  The full documentation is at https://django-bootstrap4.readthedocs.io/



  1. Install using pip:

  ```bash
  pip install django-bootstrap4
  ```

     Alternatively, you can install download or clone this repo and call ``pip install -e .``.

  2. Add to `INSTALLED_APPS` in your `settings.py`:

  ```python
  INSTALLED_APPS = (
    
    "bootstrap4",
    
  )
  ```

  3. In your templates, load the `bootstrap4` library and use the `bootstrap_*` tags. See example below.



  ```jinja
  {% load bootstrap4 %}

  {# Display a form #}

  <form action="/url/to/submit/" method="post" class="form">
      {% csrf_token %}
      {% bootstrap_form form %}
      {% buttons %}
          <button type="submit" class="btn btn-primary">Submit</button>
      {% endbuttons %}
  </form>
  ```



  A demo app is provided in `demo`. You can run it from your virtualenv with `python manage.py runserver`.



  If you have found a bug or if you have a request for additional functionality, please use the issue tracker on GitHub.

  https://github.com/zostera/django-bootstrap4/issues



  You can use this under BSD-3-Clause. See [LICENSE](LICENSE) file for details.



  Developed and maintained by [Zostera](https://zostera.nl).

  Original author: [Dylan Verheul](https://github.com/dyve).

  Thanks to everybody that has contributed pull requests, ideas, issues, comments and kind words.

  Please see [AUTHORS](AUTHORS) for a list of contributors.


pkgId: 1b042a1cfb1991b2b6857cfe9613f6490ecbbd72f5534bbe124ea1732753238b
name: python-django-bulk-update
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Bulk update using one query over Django ORM.
url: https://github.com/aykut/django-bulk-update
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4c296c0c-4ea1-40d8-906f-6f80065bc5b5
location_href: 00011083-python-django-bulk-update/python-django-bulk-update-2.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/aykut/django-bulk-update.svg?branch=master)](https://travis-ci.org/aykut/django-bulk-update)
  [![Coverage Status](https://coveralls.io/repos/aykut/django-bulk-update/badge.svg?branch=master)](https://coveralls.io/r/aykut/django-bulk-update?branch=master)
  Simple bulk update over Django ORM or with helper function.
  This project aims to bulk update given objects using **one query** over
  **Django ORM**.


pkgId: 44ddf781f84c55c60bacd7759bac6d2e884b05836f3bc143950c1122eee23522
name: python-django-cache-url
arch: src
version: 3.4.4
epoch: 0
release: 1
summary: Use Cache URLs in your Django application.
url: https://github.com/epicserve/django-cache-url
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d4056243-cc1f-4ea0-bcd1-de30e4b48065
location_href: 00012893-python-django-cache-url/python-django-cache-url-3.4.4-1.src.rpm
checksum_type: sha256
description:
  Configure your cache in ``settings.py``::
      CACHES={'default': django_cache_url.config()}
  Nice and simple.


pkgId: 369782843d6b55b1f1b121fecb78adbf052423b869e2ab93b5ecb4679772012d
name: python-django-cacheops
arch: src
version: 6.2
epoch: 0
release: 1
summary: A slick ORM cache with automatic granular event-driven invalidation for Django.
url: http://github.com/Suor/django-cacheops
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a8d6ca12-90da-4bd2-9aa6-2457567d3018
location_href: 00003453-python-django-cacheops/python-django-cacheops-6.2-1.src.rpm
checksum_type: sha256
description:
  A slick app that supports automatic or manual queryset caching and `automatic
  granular event-driven invalidation <http://suor.github.io/blog/2014/03/09/on-orm-cache-invalidation/>`_.
  It uses `redis <http://redis.io/>`_ as backend for ORM cache and redis or
  filesystem for simple time-invalidated one.
  And there is more to it:
  - decorators to cache any user function or view as a queryset or by time
  - extensions for django and jinja2 templates
  - transparent transaction support
  - dog-pile prevention mechanism
  - a couple of hacks to make django faster
  Requirements
  ++++++++++++
  Python 3.5+, Django 2.1+ and Redis 4.0+.
  Installation
  ++++++++++++
  Using pip:
      $ pip install django-cacheops
      
      $ pip install git+https://github.com/Suor/django-cacheops.git@master
  Setup
  +++++
  Add ``cacheops`` to your ``INSTALLED_APPS``.
  Setup redis connection and enable caching for desired models:
      CACHEOPS_REDIS = {
          'host': 'localhost', # redis-server is on same machine
          'port': 6379,        # default redis port
          'db': 1,             # SELECT non-default redis database
                               
                               
          'socket_timeout': 3,   # connection timeout in seconds, optional
          'password': '...',     # optional
          'unix_socket_path': '' # replaces host and port
      }
      
      CACHEOPS_REDIS = "redis://localhost:6379/1"
      
      CACHEOPS_REDIS = "unix://path/to/socket?db=1"
      
      CACHEOPS_REDIS = "redis://:password@localhost:6379/1"
      
      CACHEOPS_SENTINEL = {
          'locations': [('localhost', 26379)], # sentinel locations, required
          'service_name': 'mymaster',          # sentinel service name, required
          'socket_timeout': 0.1,               # connection timeout in seconds, optional
          'db': 0                              # redis database, default: 0
      }
      
      
      CACHEOPS_CLIENT_CLASS = 'your.redis.ClientClass'
      CACHEOPS = {
          
          
          
          
          'auth.user': {'ops': 'get', 'timeout': 60*15},
          
          
          'auth.*': {'ops': {'fetch', 'get'}, 'timeout': 60*60},
          
          
          'auth.permission': {'ops': 'all', 'timeout': 60*60},
          
          
          
          
          
          '*.*': {'ops': (), 'timeout': 60*60},
          
          '*.*': {'timeout': 60*60},
          
          
          
          'some_app.*': None,
      }
  You can configure default profile setting with ``CACHEOPS_DEFAULTS``. This way you can rewrite the config above:
      CACHEOPS_DEFAULTS = {
          'timeout': 60*60
      }
      CACHEOPS = {
          'auth.user': {'ops': 'get', 'timeout': 60*15},
          'auth.*': {'ops': ('fetch', 'get')},
          'auth.permission': {'ops': 'all'},
          '*.*': {},
      }
  Using ``'*.*'`` with non-empty ``ops`` is **not recommended**
  since it will easily cache something you don't intent to or even know about like migrations tables.
  The better approach will be restricting by app with ``'app_name.*'``.
  Besides ``ops`` and ``timeout`` options you can also use:
  ``local_get: True``
      To cache simple gets for this model in process local memory.
      This is very fast, but is not invalidated in any way until process is restarted.
      Still could be useful for extremely rarely changed things.
  ``cache_on_save=True | 'field_name'``
      To write an instance to cache upon save.
      Cached instance will be retrieved on ``.get(field_name=...)`` request.
      Setting to ``True`` causes caching by primary key.
  Additionally, you can tell cacheops to degrade gracefully on redis fail with:
      CACHEOPS_DEGRADE_ON_FAILURE = True
  There is also a possibility to make all cacheops methods and decorators no-op, e.g. for testing:
      from django.test import override_settings
      @override_settings(CACHEOPS_ENABLED=False)
      def test_something():
          
          assert cond
  Usage
  +++++
  | **Automatic caching**
  It's automatic you just need to set it up.
  | **Manual caching**
  You can force any queryset to use cache by calling its ``.cache()`` method:
      Article.objects.filter(tag=2).cache()
  Here you can specify which ops should be cached for the queryset, for example, this code:
      qs = Article.objects.filter(tag=2).cache(ops=['count'])
      paginator = Paginator(objects, ipp)
      articles = list(pager.page(page_num)) # hits database
  will cache count call in ``Paginator`` but not later articles fetch.
  There are five possible actions - ``get``, ``fetch``, ``count``, ``aggregate`` and ``exists``.
  You can pass any subset of this ops to ``.cache()`` method even empty - to turn off caching.
  There is, however, a shortcut for the latter:
      qs = Article.objects.filter(visible=True).nocache()
      qs1 = qs.filter(tag=2)       # hits database
      qs2 = qs.filter(category=3)  # hits it once more
  It is useful when you want to disable automatic caching on particular queryset.
  You can also override default timeout for particular queryset with ``.cache(timeout=...)``.
  | **Function caching**
  You can cache and invalidate result of a function the same way as a queryset.
  Cached results of the next function will be invalidated on any ``Article`` change,
  addition or deletion:
      from cacheops import cached_as
      @cached_as(Article, timeout=120)
      def article_stats():
          return {
              'tags': list(Article.objects.values('tag').annotate(Count('id')))
              'categories': list(Article.objects.values('category').annotate(Count('id')))
          }
  Note that we are using list on both querysets here, it's because we don't want
  to cache queryset objects but their results.
  Also note that if you want to filter queryset based on arguments,
  e.g. to make invalidation more granular, you can use a local function:
      def articles_block(category, count=5):
          qs = Article.objects.filter(category=category)
          @cached_as(qs, extra=count)
          def _articles_block():
              articles = list(qs.filter(photo=True)[:count])
              if len(articles) < count:
                  articles += list(qs.filter(photo=False)[:count-len(articles)])
              return articles
          return _articles_block()
  We added ``extra`` here to make different keys for calls with same ``category`` but different
  ``count``. Cache key will also depend on function arguments, so we could just pass ``count`` as
  an argument to inner function. We also omitted ``timeout`` here, so a default for the model
  will be used.
  Another possibility is to make function cache invalidate on changes to any one of several models:
      @cached_as(Article.objects.filter(public=True), Tag)
      def article_stats():
          return {...}
  As you can see, we can mix querysets and models here.
  | **View caching**
  You can also cache and invalidate a view as a queryset. This works mostly the same way as function
  caching, but only path of the request parameter is used to construct cache key:
      from cacheops import cached_view_as
      @cached_view_as(News)
      def news_index(request):
          
          return render(...)
  You can pass ``timeout``, ``extra`` and several samples the same way as to ``@cached_as()``. Note that you can pass a function as ``extra``:
      @cached_view_as(News, extra=lambda req: req.user.is_staff)
      def news_index(request):
          
          return render(...)
  A function passed as ``extra`` receives the same arguments as the cached function.
  Class based views can also be cached:
      class NewsIndex(ListView):
          model = News
      news_index = cached_view_as(News, ...)(NewsIndex.as_view())
  Invalidation
  ++++++++++++
  Cacheops uses both time and event-driven invalidation. The event-driven one
  listens on model signals and invalidates appropriate caches on ``Model.save()``, ``.delete()``
  and m2m changes.
  Invalidation tries to be granular which means it won't invalidate a queryset
  that cannot be influenced by added/updated/deleted object judging by query
  conditions. Most of the time this will do what you want, if it won't you can use
  one of the following:
      from cacheops import invalidate_obj, invalidate_model, invalidate_all
      invalidate_obj(some_article)  # invalidates queries affected by some_article
      invalidate_model(Article)     # invalidates all queries for model
      invalidate_all()              # flush redis cache database
  And last there is ``invalidate`` command::
      ./manage.py invalidate articles.Article.34  # same as invalidate_obj
      ./manage.py invalidate articles.Article     # same as invalidate_model
      ./manage.py invalidate articles   # invalidate all models in articles
  And the one that FLUSHES cacheops redis database::
      ./manage.py invalidate all
  Don't use that if you share redis database for both cache and something else.
  | **Turning off and postponing invalidation**
  There is also a way to turn off invalidation for a while:
      from cacheops import no_invalidation
      with no_invalidation:
          
          obj.save()
  Also works as decorator:
      @no_invalidation
      def some_work(...):
          
          obj.save()
  Combined with ``try ... finally`` it could be used to postpone invalidation:
      try:
          with no_invalidation:
              
      finally:
          invalidate_obj(...)
          
          invalidate_model(...)
  Postponing invalidation can speed up batch jobs.
  | **Mass updates**
  Normally `qs.update(...)` doesn't emit any events and thus doesn't trigger invalidation.
  And there is no transparent and efficient way to do that: trying to act on conditions will
  invalidate too much if update conditions are orthogonal to many queries conditions,
  and to act on specific objects we will need to fetch all of them,
  which `QuerySet.update()` users generally try to avoid.
  In the case you actually want to perform the latter cacheops provides a shortcut:
      qs.invalidated_update(...)
  Note that all the updated objects are fetched twice, prior and post the update.
  Components
  ++++++++++


pkgId: 4a2ef7ae6f35a6a2a9542019f9cbc613363c05b8bbffcc2bb9bd131fc130b70a
name: python-django-cacheops
arch: src
version: 7.0
epoch: 0
release: 1
summary: A slick ORM cache with automatic granular event-driven invalidation for Django.
url: http://github.com/Suor/django-cacheops
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dc5f829a-8b98-4d13-ac57-1cd8d9008dee
location_href: 00006812-python-django-cacheops/python-django-cacheops-7.0-1.src.rpm
checksum_type: sha256
description:
  A slick app that supports automatic or manual queryset caching and `automatic
  granular event-driven invalidation <http://suor.github.io/blog/2014/03/09/on-orm-cache-invalidation/>`_.
  It uses `redis <http://redis.io/>`_ as backend for ORM cache and redis or
  filesystem for simple time-invalidated one.
  And there is more to it:
  - decorators to cache any user function or view as a queryset or by time
  - extensions for django and jinja2 templates
  - transparent transaction support
  - dog-pile prevention mechanism
  - a couple of hacks to make django faster
  Requirements
  ++++++++++++
  Python 3.7+, Django 3.2+ and Redis 4.0+.
  Installation
  ++++++++++++
  Using pip:
      $ pip install django-cacheops
      
      $ pip install git+https://github.com/Suor/django-cacheops.git@master
  Setup
  +++++
  Add ``cacheops`` to your ``INSTALLED_APPS``.
  Setup redis connection and enable caching for desired models:
      CACHEOPS_REDIS = {
          'host': 'localhost', # redis-server is on same machine
          'port': 6379,        # default redis port
          'db': 1,             # SELECT non-default redis database
                               
                               
          'socket_timeout': 3,   # connection timeout in seconds, optional
          'password': '...',     # optional
          'unix_socket_path': '' # replaces host and port
      }
      
      CACHEOPS_REDIS = "redis://localhost:6379/1"
      
      CACHEOPS_REDIS = "unix://path/to/socket?db=1"
      
      CACHEOPS_REDIS = "redis://:password@localhost:6379/1"
      
      CACHEOPS_SENTINEL = {
          'locations': [('localhost', 26379)], # sentinel locations, required
          'service_name': 'mymaster',          # sentinel service name, required
          'socket_timeout': 0.1,               # connection timeout in seconds, optional
          'db': 0                              # redis database, default: 0
      }
      
      CACHEOPS_CLIENT_CLASS = 'your.redis.ClientClass'
      CACHEOPS = {
          
          
          
          
          'auth.user': {'ops': 'get', 'timeout': 60*15},
          
          
          'auth.*': {'ops': {'fetch', 'get'}, 'timeout': 60*60},
          
          
          'auth.permission': {'ops': 'all', 'timeout': 60*60},
          
          
          
          
          
          '*.*': {'ops': (), 'timeout': 60*60},
          
          '*.*': {'timeout': 60*60},
          
          
          
          'some_app.*': None,
      }
  You can configure default profile setting with ``CACHEOPS_DEFAULTS``. This way you can rewrite the config above:
      CACHEOPS_DEFAULTS = {
          'timeout': 60*60
      }
      CACHEOPS = {
          'auth.user': {'ops': 'get', 'timeout': 60*15},
          'auth.*': {'ops': ('fetch', 'get')},
          'auth.permission': {'ops': 'all'},
          '*.*': {},
      }
  Using ``'*.*'`` with non-empty ``ops`` is **not recommended**
  since it will easily cache something you don't intent to or even know about like migrations tables.
  The better approach will be restricting by app with ``'app_name.*'``.
  Besides ``ops`` and ``timeout`` options you can also use:
  ``local_get: True``
      To cache simple gets for this model in process local memory.
      This is very fast, but is not invalidated in any way until process is restarted.
      Still could be useful for extremely rarely changed things.
  ``cache_on_save=True | 'field_name'``
      To write an instance to cache upon save.
      Cached instance will be retrieved on ``.get(field_name=...)`` request.
      Setting to ``True`` causes caching by primary key.
  Additionally, you can tell cacheops to degrade gracefully on redis fail with:
      CACHEOPS_DEGRADE_ON_FAILURE = True
  There is also a possibility to make all cacheops methods and decorators no-op, e.g. for testing:
      from django.test import override_settings
      @override_settings(CACHEOPS_ENABLED=False)
      def test_something():
          
          assert cond
  Usage
  +++++
  | **Automatic caching**
  It's automatic you just need to set it up.
  | **Manual caching**
  You can force any queryset to use cache by calling its ``.cache()`` method:
      Article.objects.filter(tag=2).cache()
  Here you can specify which ops should be cached for the queryset, for example, this code:
      qs = Article.objects.filter(tag=2).cache(ops=['count'])
      paginator = Paginator(objects, ipp)
      articles = list(pager.page(page_num)) # hits database
  will cache count call in ``Paginator`` but not later articles fetch.
  There are five possible actions - ``get``, ``fetch``, ``count``, ``aggregate`` and ``exists``.
  You can pass any subset of this ops to ``.cache()`` method even empty - to turn off caching.
  There is, however, a shortcut for the latter:
      qs = Article.objects.filter(visible=True).nocache()
      qs1 = qs.filter(tag=2)       # hits database
      qs2 = qs.filter(category=3)  # hits it once more
  It is useful when you want to disable automatic caching on particular queryset.
  You can also override default timeout for particular queryset with ``.cache(timeout=...)``.
  | **Function caching**
  You can cache and invalidate result of a function the same way as a queryset.
  Cached results of the next function will be invalidated on any ``Article`` change,
  addition or deletion:
      from cacheops import cached_as
      @cached_as(Article, timeout=120)
      def article_stats():
          return {
              'tags': list(Article.objects.values('tag').annotate(Count('id')))
              'categories': list(Article.objects.values('category').annotate(Count('id')))
          }
  Note that we are using list on both querysets here, it's because we don't want
  to cache queryset objects but their results.
  Also note that if you want to filter queryset based on arguments,
  e.g. to make invalidation more granular, you can use a local function:
      def articles_block(category, count=5):
          qs = Article.objects.filter(category=category)
          @cached_as(qs, extra=count)
          def _articles_block():
              articles = list(qs.filter(photo=True)[:count])
              if len(articles) < count:
                  articles += list(qs.filter(photo=False)[:count-len(articles)])
              return articles
          return _articles_block()
  We added ``extra`` here to make different keys for calls with same ``category`` but different
  ``count``. Cache key will also depend on function arguments, so we could just pass ``count`` as
  an argument to inner function. We also omitted ``timeout`` here, so a default for the model
  will be used.
  Another possibility is to make function cache invalidate on changes to any one of several models:
      @cached_as(Article.objects.filter(public=True), Tag)
      def article_stats():
          return {...}
  As you can see, we can mix querysets and models here.
  | **View caching**
  You can also cache and invalidate a view as a queryset. This works mostly the same way as function
  caching, but only path of the request parameter is used to construct cache key:
      from cacheops import cached_view_as
      @cached_view_as(News)
      def news_index(request):
          
          return render(...)
  You can pass ``timeout``, ``extra`` and several samples the same way as to ``@cached_as()``. Note that you can pass a function as ``extra``:
      @cached_view_as(News, extra=lambda req: req.user.is_staff)
      def news_index(request):
          
          return render(...)
  A function passed as ``extra`` receives the same arguments as the cached function.
  Class based views can also be cached:
      class NewsIndex(ListView):
          model = News
      news_index = cached_view_as(News, ...)(NewsIndex.as_view())
  Invalidation
  ++++++++++++
  Cacheops uses both time and event-driven invalidation. The event-driven one
  listens on model signals and invalidates appropriate caches on ``Model.save()``, ``.delete()``
  and m2m changes.
  Invalidation tries to be granular which means it won't invalidate a queryset
  that cannot be influenced by added/updated/deleted object judging by query
  conditions. Most of the time this will do what you want, if it won't you can use
  one of the following:
      from cacheops import invalidate_obj, invalidate_model, invalidate_all
      invalidate_obj(some_article)  # invalidates queries affected by some_article
      invalidate_model(Article)     # invalidates all queries for model
      invalidate_all()              # flush redis cache database
  And last there is ``invalidate`` command::
      ./manage.py invalidate articles.Article.34  # same as invalidate_obj
      ./manage.py invalidate articles.Article     # same as invalidate_model
      ./manage.py invalidate articles   # invalidate all models in articles
  And the one that FLUSHES cacheops redis database::
      ./manage.py invalidate all
  Don't use that if you share redis database for both cache and something else.
  | **Turning off and postponing invalidation**
  There is also a way to turn off invalidation for a while:
      from cacheops import no_invalidation
      with no_invalidation:
          
          obj.save()
  Also works as decorator:
      @no_invalidation
      def some_work(...):
          
          obj.save()
  Combined with ``try ... finally`` it could be used to postpone invalidation:
      try:
          with no_invalidation:
              
      finally:
          invalidate_obj(...)
          
          invalidate_model(...)
  Postponing invalidation can speed up batch jobs.
  | **Mass updates**
  Normally `qs.update(...)` doesn't emit any events and thus doesn't trigger invalidation.
  And there is no transparent and efficient way to do that: trying to act on conditions will
  invalidate too much if update conditions are orthogonal to many queries conditions,
  and to act on specific objects we will need to fetch all of them,
  which `QuerySet.update()` users generally try to avoid.
  In the case you actually want to perform the latter cacheops provides a shortcut:
      qs.invalidated_update(...)
  Note that all the updated objects are fetched twice, prior and post the update.
  Components
  ++++++++++


pkgId: 96ea23d677a605ebb7b15a2a1c1c449a06a0b7ff586e8fe4ab322e01ddf9b02a
name: python-django-ckeditor
arch: src
version: 6.5.1
epoch: 0
release: 1
summary: Django admin CKEditor integration.
url: https://github.com/django-ckeditor/django-ckeditor
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bc904ad0-7575-4b0d-b015-68c980d4afcd
location_href: 00010727-python-django-ckeditor/python-django-ckeditor-6.5.1-1.src.rpm
checksum_type: sha256
description:
  **Django admin CKEditor integration.**
  Provides a ``RichTextField``, ``RichTextUploadingField``, ``CKEditorWidget`` and ``CKEditorUploadingWidget`` utilizing CKEditor with image uploading and browsing support included.
  This version also includes:


pkgId: c4e94a5dc50f3cf4dace86f90c27552ae7ea43e725ca7d5af9b03793c5f435f0
name: python-django-cleanup
arch: src
version: 7.0.0
epoch: 0
release: 1
summary: Deletes old files.
url: https://github.com/un1t/django-cleanup
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-54e135ef-6da4-420d-be04-d26814d54fc7
location_href: 00012089-python-django-cleanup/python-django-cleanup-7.0.0-1.src.rpm
checksum_type: sha256
description:
  The django-cleanup app automatically deletes files for :code:`FileField`, :code:`ImageField` and
  subclasses. When a :code:`FileField`'s value is changed and the model is saved, the old file is
  deleted. When a model that has a :code:`FileField` is deleted, the file is also deleted. A file that
  is set as the :code:`FileField`'s default value will not be deleted.


pkgId: 60428e4963cfb233e586b1796cf544feb97551f989f294c04195a16e0d8ec744
name: python-django-cms
arch: src
version: 3.11.1
epoch: 0
release: 1
summary: Lean enterprise content management powered by Django.
url: https://www.django-cms.org/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c5025a9-4b17-4cf0-af84-cb7dd7ac19c9
location_href: 00012987-python-django-cms/python-django-cms-3.11.1-1.src.rpm
checksum_type: sha256
description:
  django CMS

  .. image:: https://travis-ci.org/django-cms/django-cms.svg?branch=develop
      :target: https://travis-ci.org/django-cms/django-cms
  .. image:: https://img.shields.io/pypi/v/django-cms.svg
      :target: https://pypi.python.org/pypi/django-cms/
  .. image:: https://img.shields.io/badge/wheel-yes-green.svg
      :target: https://pypi.python.org/pypi/django-cms/
  .. image:: https://img.shields.io/pypi/l/django-cms.svg
      :target: https://pypi.python.org/pypi/django-cms/
  .. image:: https://codeclimate.com/github/divio/django-cms/badges/gpa.svg
     :target: https://codeclimate.com/github/divio/django-cms
     :alt: Code Climate

  Open source enterprise content management system based on the Django framework and backed by the non-profit django CMS Association (`Sponsor us! <https://www.django-cms.org/en/memberships/>`_).

  *******************************************
  Contribute to this project and win rewards
  *******************************************

  Because django CMS is a community-driven project, we welcome everyone to `get involved in the project <https://www.django-cms.org/en/contribute/>`_ and `receive a reward <https://www.django-cms.org/en/bounty-program/>`_ for their contribution. Become part of a fantastic community and help us make django CMS the best open source CMS in the world.


  .. ATTENTION::

      Please use the ``develop`` branch as the target for pull requests for on-going development.

      Security fixes will be backported to older branches by the core team as appropriate.


  ********
  Features
  ********

  * hierarchical pages
  * extensive built-in support for multilingual websites
  * multi-site support
  * draft/publish workflows
  * version control
  * a sophisticated publishing architecture, that's also usable in your own applications
  * frontend content editing
  * a hierarchical content structure for nested plugins
  * an extensible navigation system that your own applications can hook into
  * SEO-friendly URLs
  * designed to integrate thoroughly into other applications

  Developing applications that integrate with and take advantage of django CMS features is easy and well-documented.

  More information on `our website <https://www.django-cms.org>`_.

  ************
  Requirements
  ************

  See the `Python/Django requirements for the current release version
  <http://docs.django-cms.org/en/latest/#software-version-requirements-and-release-notes>`_ in our documentation.

  See the `installation how-to guide for an overview of some other requirements and dependencies of the current release
  <http://docs.django-cms.org/en/latest/how_to/install.html>`_.


  ***************
  Getting started
  ***************

  These `tutorials <http://docs.django-cms.org/en/latest/introduction/index.html>`_ take you step-by-step through some key aspects of django CMS.


  *************
  Documentation
  *************

  Our documentation working group maintains documentation for several versions of the project. Key versions are:

  * `stable <http://docs.django-cms.org>`_ (default), for the **current release** version
  * `latest <http://docs.django-cms.org/en/latest/>`_, representing the latest build of the **release-3.4.x branch**
  * `develop <http://docs.django-cms.org/en/develop/>`_, representing the latest build of the **develop branch**

  For more information about our branch policy, see `Branches
  <http://docs.django-cms.org/en/latest/contributing/development-policies.html>`_.

  Our documentation is hosted courtesy of `Read the Docs <https://readthedocs.org>`_.

  The dependencies for the docs are compiled by `pip-tools <https://github.com/jazzband/pip-tools>`_.


  ***************************
  Test django CMS in our demo
  ***************************

  The demo platform is kindly provided by Divio, platinum member of the django CMS Association.

  .. image:: https://raw.githubusercontent.com/django-cms/django-cms/develop/docs/images/try-with-divio.png
     :target: https://www.django-cms.org/en/django-cms-demo/
     :alt: Try demo with Divio Cloud

  ************
  Getting Help
  ************

  Please head over to our `Slack channel <https://www.django-cms.org/slack>`_ or our `discourse forum <https://discourse.django-cms.org/>`_ for support.

  ********************
  Professional support
  ********************

  Choose from a list of `trusted tech partner <https://www.django-cms.org/en/tech-partners/>`_ of the django CMS Association to get your website project delivered successfully.

  Choose a `trusted web host <https://www.django-cms.org/en/hosting-services/>`_ for your django CMS project and get your website online today.


  **************************
  The django CMS Association
  **************************

  The django CMS Association is a non-profit organization that was founded in 2020 with the goal to drive the success of django CMS, by increasing customer happiness, market share and open-source contributions. We provide infrastructure and guidance for the django CMS project.

  The non-profit django CMS Association is dependent on donations to fulfill its purpose. The best way to donate is to become a member of the association and pay membership fees. The funding will be funneled back into core development and community projects.

  `Join the django CMS Association <https://www.django-cms.org/en/contribute/>`_.


  *******
  Credits
  *******

  * Includes icons from `FamFamFam <http://www.famfamfam.com>`_.
  * Python tree engine powered by
    `django-treebeard <https://tabo.pe/projects/django-treebeard/>`_.
  * JavaScript tree in admin uses `jsTree <https://www.jstree.com>`_.
  * Many thanks to
    `all the contributors <https://github.com/django-cms/django-cms/graphs/contributors>`_
    to django CMS!


pkgId: bedd5282e5d79d67ce7cee4cc3fd73b693210bdea5614c09c9ec6ec3a03283a4
name: python-django-colorfield
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: simple color field for your models with a nice color-picker in the admin-interface.
url: https://github.com/fabiocaccamo/django-colorfield
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-576d9921-c7e8-4cd9-8119-28d84fa2fd71
location_href: 00011329-python-django-colorfield/python-django-colorfield-0.8.0-1.src.rpm
checksum_type: sha256
description:
  -   Run `pip install django-colorfield`
  -   Add `colorfield` to `settings.INSTALLED_APPS`
  -   Run `python manage.py collectstatic`


pkgId: 900464a1b714f99dd2b5fd593468862b8ca02787af53892f131abfddd814c99e
name: python-django-compat
arch: src
version: 1.0.15
epoch: 0
release: 1
summary: For- and backwards compatibility layer for Django 1.4, 1.7, 1.8, 1.9, 1.10, and 1.11
url: https://github.com/arteria/django-compat
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7640bbaa-9678-4376-9533-853a672f54c6
location_href: 00011346-python-django-compat/python-django-compat-1.0.15-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/arteria/django-compat.svg?branch=master)](https://travis-ci.org/arteria/django-compat)
  [![Stories in Ready](https://badge.waffle.io/arteria/django-compat.png?label=ready&title=Ready)](https://waffle.io/arteria/django-compat)
  [![Coverage Status](https://coveralls.io/repos/arteria/django-compat/badge.svg?branch=master&service=github)](https://coveralls.io/github/arteria/django-compat?branch=master)
  [![PyPI](https://img.shields.io/pypi/v/django-compat.svg)](https://pypi.python.org/pypi/django-compat)
  Forward and backwards compatibility layer for Django ~~1.4~~, ~~1.7~~, 1.8, 1.9, 1.10 and 1.11
  ~~Consider [django-compat](https://github.com/arteria/django-compat) as an experiment based on the discussion [on reddit](http://redd.it/2jrr4l). Let's see where it goes.~~
  What started as an experiment based on [this discussion on reddit](http://redd.it/2jrr4l) has proven to be true in real life.
  django-compat is under active development. To learn about other features, bug fixes, and changes, please refer to the [changelog](https://github.com/arteria/django-compat#changelog).

  Two popular examples of open source reusable app that uses django-compat are [django-hijack](https://github.com/arteria/django-hijack/) and [django-background-tasks](https://github.com/arteria/django-background-tasks).
  Want to have yours listed here? Send us a PR.

  * Be able to use the LTS versions of Django and support newer versions in your app
  * Use features from newer Django versions in an old one
  * Manage and master the gap between different framework versions

  Install compat from the [PyPI](https://pypi.python.org/pypi/django-compat) or download and install manually. All relevant  releases are listed [here under releases](https://github.com/arteria/django-compat/releases).
  Using one of the compatible objects is easy. For example
  	from compat import patterns, url
  	urlpatterns = patterns('ABC.views',
      		url(r'^abc/$', 'abc', name='abc-link'),
  See a full example [here](https://github.com/arteria/django-hijack/blob/4966d8865e7e829a562ff2724771628c6590f841/hijack/urls.py#L1).
  | django-compat is free software. If you find it useful and would like to give back, please consider to make a donation using [Bitcoin](https://blockchain.info/payment_request?address=1AJkbQdcNkrHzxi91mB1kkPxh4t4BJ4hu4) or [PayPal](https://www.paypal.me/arteriagmbh). Thank you! |
  | ----- |

  |Compatible object|Specifically tested|1.8|1.9|1.10|1.11|Notes|
  |---|---|---|---|---|---|---|
  |`BytesIO`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`DjangoJSONEncoder`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`EmailValidator`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`GenericForeignKey`|:heavy_multiplication_x:|:heavy_check_mark:|:x:|:x:|:x:||
  |`models.GenericForeignKey`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`HttpResponseBase`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`JsonResponse`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`LocaleRegexProvider`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`LocaleRegexURLResolver`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`NoReverseMatch`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`RegexURLPattern`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`RegexURLResolver`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`Resolver404`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`ResolverMatch`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`SortedDict`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`StringIO`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`URLValidator`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`VariableNode`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`View`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`add_to_builtins`|:heavy_multiplication_x:|:heavy_check_mark:|:x:|:x:|:x:||
  |`admin_utils`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`atomic`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`clean_manytomany_helptext`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`clear_url_caches`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`close_connection`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`commit`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`commit_on_success`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|`:heavy_check_mark:|`commit_on_success` replaced by `atomic` in Django >= 1.8|
  |`force_text`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`format_html`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_callable`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_current_site`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_ident`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_mod_func`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_model`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_model_name`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_ns_resolver`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_resolver`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_script_prefix`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_template_loaders`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_urlconf`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_user_model`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`get_username_field`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`handler404`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`handler500`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`import_module`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`import_string`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`include`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`is_valid_path`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`parse_qs`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`patterns`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:x:|:x:||
  |`python_2_unicode_compatible`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`render_to_string`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|The new function signature (https://docs.djangoproject.com/en/1.9/releases/1.8/#dictionary-and-context-instance-arguments-of-rendering-functions) is backported to pre-1.8.|
  |`resolve`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`resolve_url`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:warning:|:warning:|1.10: Reversing by dotted path has been removed|
  |`reverse`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`reverse_lazy`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`rollback`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|Transaction savepoint (sid) is required for Django < 1.8|
  |`set_script_prefix`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`set_urlconf`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`simplejson`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`slugify`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`smart_text`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`unquote_plus`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`url`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_multiplication_x:|:heavy_multiplication_x:|Function used in `urlpatterns`|
  |`tempat.url`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|Templatetag; import with `{% load url from compat %}`|
  |`uravy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`urlparse`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`urlresolvers`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`urlunparse`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`user_model_label`|:heavy_multiplication_x:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:||
  |`templatetags.compat.verbatim`|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|:heavy_check_mark:|Templatetag; import with `{% load verbatim from compat %}`. 1.4: Does not allow specific closing tags, e.g. `{% endverbatim myblock %}`, and does not preserve whitespace inside tags.|


  * https://github.com/ubernostrum/django-compat-lint
  * https://docs.djangoproject.com/en/dev/misc/api-stability/
  * https://docs.djangoproject.com/en/dev/topics/python3/
  * http://andrewsforge.com/presentation/upgrading-django-to-17/

  Bits and bites of the following projects were re-used to build [django-compat](https://github.com/arteria/django-compat).
  - [x] https://github.com/lukaszb/django-guardian/blob/devel/guardian/compat.py
  - [X] https://github.com/evonove/django-oauth-toolkit/blob/master/oauth2_provider/compat.py
  - [X] https://github.com/toastdriven/django-tastypie/blob/master/tastypie/compat.py
  - [X] https://github.com/tomchristie/django-rest-framework/blob/master/rest_framework/compat.py
  	- [ ] TODO: MinValueValidator, MaxValueValidator et al. (other relevant bits are included) Django 1.8
  - [X] https://gist.github.com/theskumar/ff8de60ff6a33bdacaa8
  - [X] https://github.com/evonove/django-oauth-toolkit/blob/master/oauth2_provider/templatetags/compat.py
  - [ ] https://github.com/kennethreitz/requests/blob/master/requests/compat.py
  - [ ] https://github.com/mitsuhiko/jinja2/blob/master/jinja2/_compat.py
  - [ ] https://github.com/jaraco/setuptools/blob/master/setuptools/compat.py
  - [ ] https://github.com/mariocesar/sorl-thumbnail/blob/master/sorl/thumbnail/compat.py


  * Update existing patches for Django 1.10

  * Update existing patches for Django 1.10

  * Add ``get_current_site`` and ``admin_utils``

  * Fix error when installing package under python 3.4

  * Backport new render_to_string function signature to Django < 1.8
  * Backport verbatim tag to Django 1.4
  * Add get_template_loaders
  * Add close_connection
  * Improve JsonResponse backport to Django 1.4
  * Add tests for import_module, get_model and add_to_builtins
  * Anticipate renaming of django.core.urlresolvers to django.urls in 1.10
  * Avoid warnings in setup.py

  * 1.9 compatibility for existing objects with the following changes:
  	* ``add_to_builtins`` was removed for Django >= 1.9
  	* ``GenericForeignKey` was moved to ``compat.models`` for Django >= 1.9

  * ``add_to_builtins`` was added

  * ``get_query_set``/``get_queryset`` support was dropped again (see [#29](https://github.com/arteria/django-compat/issues/29))


pkgId: 376a206e92da352768e5602fbdbc1353f8c21002e3efafe5197a242909d6b778
name: python-django-compressor
arch: src
version: 4.3.1
epoch: 0
release: 1
summary: ('Compresses linked and inline JavaScript or CSS into single cached files.',)
url: https://django-compressor.readthedocs.io/en/latest/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-82a7fb6c-7e69-49b6-9f85-6fe98fbda331
location_href: 00003454-python-django-compressor/python-django-compressor-4.3.1-1.src.rpm
checksum_type: sha256
description:
  Django Compressor processes, combines and minifies linked and inline
  Javascript or CSS in a Django template into cacheable static files.
  It supports compilers such as coffeescript, LESS and SASS and is
  extensible by custom processing steps.


pkgId: 30a69e95cc91eb8a78389dc66812946239bc055b1024c515e42b936032b430ea
name: python-django-configurations
arch: src
version: 2.4
epoch: 0
release: 1
summary: A helper for organizing Django settings.
url: https://django-configurations.readthedocs.io/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f80f01e6-8a3a-4761-90c1-742e9422b411
location_href: 00003455-python-django-configurations/python-django-configurations-2.4-1.src.rpm
checksum_type: sha256
description:
  |jazzband| |build-status| |codecov| |docs| |python-support| |django-support|
  django-configurations eases Django project configuration by relying
  on the composability of Python classes. It extends the notion of
  Django's module based settings loading with well established
  object oriented programming patterns.
  Check out the `documentation`_ for more complete examples.


pkgId: 9e0dd252a0a95ea90e7ec4fe987018c27fa98d64aacd786ffdfec593b853efaf
name: python-django-constance
arch: src
version: 2.9.1
epoch: 0
release: 1
summary: Django live settings with pluggable backends, including Redis.
url: https://github.com/jazzband/django-constance
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9de6dc08-505c-418d-8772-3506d76f3c49
location_href: 00011134-python-django-constance/python-django-constance-2.9.1-1.src.rpm
checksum_type: sha256
description:
  A Django app for storing dynamic settings in pluggable backends (Redis and
  Django model backend built in) with an integration with the Django admin app.
  For more information see the documentation at:
  https://django-constance.readthedocs.io/
  If you have questions or have trouble using the app please file a bug report
  at:
  https://github.com/jazzband/django-constance/issues


pkgId: 49f35248bbe02c8a8fd4b686f2d9f0b8c36bd1b4b87b928f1caab294de3240ae
name: python-django-contact-form
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A generic contact-form application for Django
url: https://github.com/ubernostrum/django-contact-form/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eeca20ac-c0a5-4682-ac33-8278ed6b8e9e
location_href: 00003456-python-django-contact-form/python-django-contact-form-2.0.1-1.src.rpm
checksum_type: sha256
description:
  .. -*-restructuredtext-*-

  .. image:: https://github.com/ubernostrum/django-contact-form/workflows/CI/badge.svg
     :alt: CI status image
     :target: https://github.com/ubernostrum/django-contact-form/actions?query=workflow%3ACI

  This application provides extensible contact-form functionality for
  `Django <https://www.djangoproject.com/>`_ sites.

  Full documentation for all functionality is included and is also
  `available online <http://django-contact-form.readthedocs.io/>`_.


pkgId: 8fc749795bfe36151ec765cae4f6272fbf5e71450cb78485ac721c4bca31fcb7
name: python-django-cors-headers
arch: src
version: 3.14.0
epoch: 0
release: 1
url: https://github.com/adamchainz/django-cors-headers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e570fcfd-0760-4d53-be87-aeaaf7c121bf
location_href: 00003458-python-django-cors-headers/python-django-cors-headers-3.14.0-1.src.rpm
checksum_type: sha256
summary:
  django-cors-headers is a Django application for handling the server headers required for Cross-Origin Resource Sharing (CORS).


pkgId: 3f3c84ee1778bdb90b19e9cf5bca7ee496a5e4b7e8c160df96d140e79add7587
name: python-django-crum
arch: src
version: 0.7.9
epoch: 0
release: 1
summary: Django middleware to capture current request and user.
url: https://github.com/ninemoreminutes/django-crum/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1aa2e96d-907b-4f81-b56f-68a7a7a502a1
location_href: 00012374-python-django-crum/python-django-crum-0.7.9-1.src.rpm
checksum_type: sha256
description:
  Django-CRUM (Current Request User Middleware) captures the current request and
  user in thread local storage.
  It enables apps to check permissions, capture audit trails or otherwise access
  the current request and user without requiring the request object to be passed
  directly. It also offers a context manager to allow for temporarily
  impersonating another user.
  It provides a signal to extend the built-in function for getting the current
  user, which could be helpful when using custom authentication methods or user
  models.
  Documentation can be found at `RTFD <http://django-crum.readthedocs.io/>`_.
  It is tested against:
   * Django 1.11 (Python 3.5 and 3.6)
   * Django 2.0 (Python 3.5, 3.6 and 3.7)
   * Django 2.1 (Python 3.5, 3.6 and 3.7)
   * Django 2.2 (Python 3.5, 3.6, 3.7, 3.8 and 3.9)
   * Django 3.0 (Python 3.6, 3.7, 3.8 and 3.9)
   * Django 3.1 (Python 3.6, 3.7, 3.8 and 3.9)
   * Django master/3.2 (Python 3.6, 3.7, 3.8 and 3.9)


pkgId: b26ebf6c9548351e0bbe9bcda8a4550c4ee04100b794ff1ebf432c9c29be72c7
name: python-django-cte
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Common Table Expressions (CTE) for Django
url: https://github.com/dimagi/django-cte
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0485032b-34bd-428c-80ab-5c6ab23bc53b
location_href: 00014055-python-django-cte/python-django-cte-1.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.com/dimagi/django-cte.png)](https://travis-ci.com/dimagi/django-cte)
  [![PyPI version](https://badge.fury.io/py/django-cte.svg)](https://badge.fury.io/py/django-cte)


  ```
  pip install django-cte
  ```




  The [django-cte documentation](https://dimagi.github.io/django-cte/) shows how
  to use Common Table Expressions with the Django ORM.




  ```
  cd django-cte
  mkvirtualenv cte  # or however you choose to setup your environment
  pip install django nose flake8

  nosetests
  flake8 --config=setup.cfg
  ```

  All feature and bug contributions are expected to be covered by tests.




  Package and upload the generated files.

  ```
  pip install -r pkg-requires.txt

  python setup.py sdist bdist_wheel
  twine upload dist/*
  ```


pkgId: 3bebfc36cd20b13ae0a86f31d24c201eab901ce8794a72aeba7c17c901db489c
name: python-django-database-url
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Use Database URLs in your Django Application.
url: https://github.com/tend/dj-database-url
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3aad24fd-f561-4139-a692-5edc8b8f1ae3
location_href: 00003460-python-django-database-url/python-django-database-url-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Support currently exists for PostgreSQL, PostGIS, MySQL, MySQL (GIS),
  Oracle, Oracle (GIS), Redshift, and SQLite.


pkgId: 95405c64cdde9a6079b2aa6a6e64592470f9734cd1a353322f1b1a7b2d156c0c
name: python-django-dbbackup
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: Management commands to help backup and restore a project database and media.
url: https://github.com/jazzband/django-dbbackup
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9d069d52-6682-4ecc-9d61-c9c6e52357ba
location_href: 00013633-python-django-dbbackup/python-django-dbbackup-4.0.2-1.src.rpm
checksum_type: sha256
description:
  This Django application provides management commands to help backup and
  restore your project database and media files with various storages such as
  Amazon S3, Dropbox, local file storage or any Django storage.
  It is made to:
  - Allow you to secure your backup with GPG signature and encryption
  - Archive with compression
  - Deal easily with remote archiving
  - Keep your development database up to date
  - Use Crontab or Celery to setup automated backups


pkgId: 6a0be6422d26abe66fd16c6749b6c50ce7d112286eeaf5a8b8dbe84e5abd9749
name: python-django-debreach
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Adds middleware to give some added protection against the BREACH attack in Django.
url: http://github.com/lpomfrey/django-debreach
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fa1ca5f4-34c7-408f-ac1b-5684a9d43e9c
location_href: 00003461-python-django-debreach/python-django-debreach-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Extra mitigation against the `BREACH attack <http://breachattack.com/>`_
  for Django projects.
  django-debreach provides additional protection to Django's built in CSRF
  token masking by randomising the content length of each response. This is
  achieved by adding a random string of between 12 and 25 characters as a
  comment to the end of the HTML content. Note that this will only be applied to
  responses with a content type of ``text/html``.
  When combined with the built-in mitigations in Django and rate limiting
  (either in your web-server, or by using something like
  `django-ratelimit <http://django-ratelimit.readthedocs.org/>`_), the
  techniques here should provide a fairly comprehensive protection against the
  BREACH attack.


pkgId: d69398187704ce6b579df77f2da0bf777346b106ecfb0c1becf4daaf30285e4f
name: python-django-environ
arch: src
version: 0.10.0
epoch: 0
release: 1
url: https://django-environ.readthedocs.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-38fb8773-21ea-4514-aecb-c4bb408e3f70
location_href: 00009688-python-django-environ/python-django-environ-0.10.0-1.src.rpm
checksum_type: sha256
summary:
  A package that allows you to utilize 12factor inspired environment variables to configure your Django application.


pkgId: e8dbc1622cca5be7bc0c51cb1b41512b3f749b68d5a85db6280b329f248c8359
name: python-django-extra-fields
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Additional fields for Django Rest Framework.
url: https://github.com/Hipo/drf-extra-fields
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-579e01e3-88e1-4f35-a78f-bc495df527f1
location_href: 00012146-python-django-extra-fields/python-django-extra-fields-3.0.2-1.src.rpm
checksum_type: sha256
description:
  This package renamed as "drf-extra-fields", earlier it was named as django-extra-fields. New versions can be tracked from [here](https://github.com/Hipo/drf-extra-fields).


pkgId: 587a468011dd4c5de55d3b995704cde28be3e22c21cefba7673f17364d028425
name: python-django-extra-views
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Extra class-based views for Django
url: https://github.com/AndrewIngram/django-extra-views
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e1cd0c9d-9ea8-411e-b3ce-1dfc3b02d828
location_href: 00012629-python-django-extra-views/python-django-extra-views-0.14.0-1.src.rpm
checksum_type: sha256
description:
  Django-extra-views is a Django package which introduces additional class-based views
  in order to simplify common design patterns such as those found in the Django
  admin interface.
  Full documentation is available at `read the docs`_.


pkgId: 0e238d9c9eef3dcd39f4d1f533d3cd2b9ab67990585dd20e205720f720c10965
name: python-django-filter
arch: src
version: 22.1
epoch: 0
release: 1
summary: Django-filter is a reusable Django application for allowing users to filter querysets dynamically.
url: https://github.com/carltongibson/django-filter/tree/main
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c06ae174-a721-4afa-8513-fcd7ae9044a8
location_href: 00003465-python-django-filter/python-django-filter-22.1-1.src.rpm
checksum_type: sha256
description:
  Django-filter is a reusable Django application allowing users to declaratively
  add dynamic ``QuerySet`` filtering from URL parameters.
  Full documentation on `read the docs`_.


pkgId: a3697f8b1f6741dc27374c5084ea53caebda64287aaf31cd0a5c16841f378737
name: python-django-flat-theme
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: A flat theme for Django admin interface. Modern, fresh, simple.
url: https://github.com/elky/django-flat-theme
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f544902e-f178-4b84-9a20-cd6f811ee1ed
location_href: 00013626-python-django-flat-theme/python-django-flat-theme-1.1.4-1.src.rpm
checksum_type: sha256
description:
  **django-flat-theme** is included as `part <https://github.com/django/django/commit/35901e64b043733acd1687734274553cf994511b>`_ of Django from `version 1.9 <https://docs.djangoproject.com/en/1.9/releases/1.9/#new-styling-for-contrib-admin>`_! :tada:
  Please use this app if your project is powered by an older Django version.


pkgId: f3d295fc6e74649a4d1be28e253818ba87b1157a8cd65832d4bb661af99f2674
name: python-django-graphql-jwt
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: JSON Web Token for Django GraphQL.
url: https://github.com/flavors/django-graphql-jwt
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c071272f-abe5-4846-8916-c2d085471f1c
location_href: 00011687-python-django-graphql-jwt/python-django-graphql-jwt-0.3.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://django-graphql-jwt.domake.io/"><img width="420px" src="https://django-graphql-jwt.domake.io/_static/logo.png" alt='Django GraphQL JWT'></a>
  </p>

  <p align="center">
      JSON Web Token authentication for Django GraphQL.
      <br>Fantastic <strong>documentation</strong> is available at <a href="https://django-graphql-jwt.domake.io">https://django-graphql-jwt.domake.io</a>.
  </p>
  <p align="center">
      <a href="https://github.com/flavors/django-graphql-jwt/actions">
          <img src="https://github.com/flavors/django-graphql-jwt/actions/workflows/test-suite.yml/badge.svg" alt="Test">
      </a>
      <a href="https://codecov.io/gh/flavors/django-graphql-jwt">
          <img src="https://img.shields.io/codecov/c/github/flavors/django-graphql-jwt?color=%2334D058" alt="Coverage">
      </a>
      <a href="https://www.codacy.com/gh/flavors/django-graphql-jwt/dashboard">
          <img src="https://app.codacy.com/project/badge/Grade/4f9fd439fbc74be88a215b9ed2abfcf9" alt="Codacy">
      </a>
      <a href="https://pypi.python.org/pypi/django-graphql-jwt">
          <img src="https://img.shields.io/pypi/v/django-graphql-jwt.svg" alt="Package version">
      </a>
  </p>



  Install last stable version from Pypi:

  ```sh
  pip install django-graphql-jwt
  ```

  Add `AuthenticationMiddleware` middleware to your *MIDDLEWARE* settings:


  ```py
  MIDDLEWARE = [
      
      "django.contrib.auth.middleware.AuthenticationMiddleware",
      
  ]
  ```

  Add `JSONWebTokenMiddleware` middleware to your *GRAPHENE* settings:

  ```py
  GRAPHENE = {
      "SCHEMA": "mysite.myschema.schema",
      "MIDDLEWARE": [
          "graphql_jwt.middleware.JSONWebTokenMiddleware",
      ],
  }
  ```

  Add `JSONWebTokenBackend` backend to your *AUTHENTICATION_BACKENDS*:

  ```py
  AUTHENTICATION_BACKENDS = [
      "graphql_jwt.backends.JSONWebTokenBackend",
      "django.contrib.auth.backends.ModelBackend",
  ]
  ```



  Add *django-graphql-jwt* mutations to the root schema:

  ```py
  import graphene
  import graphql_jwt


  class Mutation(graphene.ObjectType):
      token_auth = graphql_jwt.ObtainJSONWebToken.Field()
      verify_token = graphql_jwt.Verify.Field()
      refresh_token = graphql_jwt.Refresh.Field()


  schema = graphene.Schema(mutation=Mutation)
  ```


pkgId: a902e139f8d51dc85ef0b4541a067ea18d04af862ae585d9c45dcdbaacd344ba
name: python-django-grappelli
arch: src
version: 3.0.5
epoch: 0
release: 1
summary: A jazzy skin for the Django Admin-Interface.
url: http://django-grappelli.readthedocs.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-77b521c6-dc7a-4468-8287-cecbc9563a6b
location_href: 00011256-python-django-grappelli/python-django-grappelli-3.0.5-1.src.rpm
checksum_type: sha256
description:
  **A jazzy skin for the Django admin interface**.
  Grappelli is a grid-based alternative/extension to the `Django <http://www.djangoproject.com>`_ administration interface.


pkgId: 8df7e7475d11aa0187102c2c0aee2eb4441a2ff85cffe8efa530c0a2836f2a5c
name: python-django-hashid-field
arch: src
version: 3.3.7
epoch: 0
release: 1
summary: A Hashids obfuscated Django Model Field
url: https://github.com/nshafer/django-hashid-field
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1f0a54f8-dde1-4faf-b2a3-255743f74af9
location_href: 00013476-python-django-hashid-field/python-django-hashid-field-3.3.7-1.src.rpm
checksum_type: sha256
description:
  A custom Model Field that uses the `Hashids <http://hashids.org/>`_ `library <https://pypi.python.org/pypi/hashids/>`_
  to obfuscate an IntegerField or AutoField. It can be used in new models or dropped in place of an existing IntegerField,
  explicit AutoField, or an automatically generated AutoField.


pkgId: 711e93aa015b5269a4fe1f7553b03b40cf605f1973324a71c6bce2c65aa38afd
name: python-django-helpdesk
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Django-powered ticket tracker for your helpdesk
url: https://github.com/django-helpdesk/django-helpdesk
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f4071ee6-2426-4a42-84e8-3d5dc7a38a42
location_href: 00003470-python-django-helpdesk/python-django-helpdesk-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://dev.azure.com/django-helpdesk/django-helpdesk/_apis/build/status/django-helpdesk.django-helpdesk?branchName=master)](https://dev.azure.com/django-helpdesk/django-helpdesk/_build/latest?definitionId=1&branchName=master)
  Copyright 2009-2022 Ross Poulton and django-helpdesk contributors. All Rights Reserved.
  See LICENSE for details.
  django-helpdesk was formerly known as Jutda Helpdesk, named after the
  company which originally created it. As of January 2011 the name has been
  changed to reflect what it really is: a Django-powered ticket tracker with
  contributors reaching far beyond Jutda.
  Complete documentation is available in the docs/ directory,
  or online at http://django-helpdesk.readthedocs.org/.
  You can see a demo installation at https://django-helpdesk-demo.herokuapp.com/,
  or run a demo locally in just a couple steps!


pkgId: 3de4fcad9dcb7a04b8a3b04b45ea8ce95f7fab73338c4b872cdc6b7cd3ca017a
name: python-django-heroku
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: This is a Django library for Heroku apps.
url: https://github.com/heroku/django-heroku
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-42256857-e6fb-4b25-b777-b636969b2778
location_href: 00011268-python-django-heroku/python-django-heroku-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This is a Django library for Heroku applications that ensures a seamless deployment and development experience.
  This library provides:
  -  Settings configuration (Static files / WhiteNoise).
  -  Logging configuration.


pkgId: 8b239a47da4e7dc4800bab5dc4bf43e07fdc5e3e2828c564de6ca79ae5acdc55
name: python-django-hosts
arch: src
version: 5.2
epoch: 0
release: 1
summary: Dynamic and static host resolving for Django. Maps hostnames to URLconfs.
url: https://django-hosts.readthedocs.io/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-50e759a2-d241-474f-bdc0-50d85821cb7e
location_href: 00011487-python-django-hosts/python-django-hosts-5.2-1.src.rpm
checksum_type: sha256
description:
  This Django app routes requests for specific hosts to different URL schemes
  defined in modules called "hostconfs".
  For example, if you own ``example.com`` but want to serve specific content
  at ``api.example.com`` and ``beta.example.com``, add the following to a
  ``hosts.py`` file:
      from django_hosts import patterns, host
      host_patterns = patterns('path.to',
          host(r'api', 'api.urls', name='api'),
          host(r'beta', 'beta.urls', name='beta'),
      )
  This causes requests to ``{api,beta}.example.com`` to be routed to their
  corresponding URLconf. You can use your ``urls.py`` as a template for these
  hostconfs.
  Patterns are evaluated in order. If no pattern matches, the request is
  processed in the usual way, ie. using the standard ``ROOT_URLCONF``.
  The patterns on the left-hand side are regular expressions. For example,
  the following ``ROOT_HOSTCONF`` setting will route ``foo.example.com``
  and ``bar.example.com`` to the same URLconf.
      from django_hosts import patterns, host
      host_patterns = patterns('',
          host(r'(foo|bar)', 'path.to.urls', name='foo-or-bar'),
      )
    Remember:
    * Patterns are matched against the extreme left of the requested host
    * It is implied that all patterns end either with a literal full stop
      (ie. ".") or an end of line metacharacter.
    * As with all regular expressions, various metacharacters need quoting.


pkgId: f0d2bd66b8824e4ce5b169ddb2fd4d0221fd0209417226b0f75073d3a2ddd526
name: python-django-htmlmin
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: HTML minifier for Python frameworks (not only Django, despite the name).
url: https://pypi.org/project/django-htmlmin/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1537a344-a27f-4d32-bcd9-10f10b57240a
location_href: 00013669-python-django-htmlmin/python-django-htmlmin-0.11.0-1.src.rpm
checksum_type: sha256
description:
  One of the important points on client side optimization is to minify HTML. With
  minified HTML code, you reduce the size of the data transferred from the server
  to the client, which results in faster load times.


pkgId: 4a78263f06d01efc7c651877586c12fd8f72e1ad2de6fdb8d6681f2880092ec3
name: python-django-imagekit
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Automated image processing for Django models.
url: http://github.com/matthewwithanm/django-imagekit/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-439fe738-8ea5-4345-877d-d9e24407ccde
location_href: 00011602-python-django-imagekit/python-django-imagekit-4.1.0-1.src.rpm
checksum_type: sha256
description:
  1. Install `Pillow`_. (If you're using an ``ImageField`` in Django,
     you should have already done this.)
  2. ``pip install django-imagekit``
  3. Add ``'imagekit'`` to your ``INSTALLED_APPS`` list in your project's ``settings.py``


pkgId: 6e04e460884ded7365db4e4213e8b12bc61f52861b4aa0a1f1712358f7e2fe3f
name: python-django-impersonate
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: Django app to allow superusers to impersonate other users.
url: https://code.netlandish.com/~petersanchez/django-impersonate
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-00aae797-8595-4282-ae16-2d0b65b8dbc4
location_href: 00012643-python-django-impersonate/python-django-impersonate-1.9.1-1.src.rpm
checksum_type: sha256
description:
  Simple application to allow superusers to "impersonate" other
  non-superuser accounts.
  **Version:** 1.9.1
  **Project Links:**
  `Issues <https://todo.code.netlandish.com/~petersanchez/django-impersonate>`__
  - `Mailing
  List <https://lists.code.netlandish.com/~petersanchez/public-inbox>`__ -
  `Contributing <#contributing>`__
  **Author:** Peter Sanchez (https://petersanchez.com)


pkgId: 386cdb620a3da3761d9bcb64a8b8ae5ede591528e0bbe5f90dd413798c8d3f4b
name: python-django-ipware
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: A Django application to retrieve user's IP address
url: https://github.com/un33k/django-ipware
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff2f36a8-ff7f-4a65-8efa-28167b511d1b
location_href: 00003471-python-django-ipware/python-django-ipware-5.0.0-1.src.rpm
checksum_type: sha256
description:
  **A Django application to retrieve client's IP address**

  [![status-image]][status-link]
  [![version-image]][version-link]
  [![coverage-image]][coverage-link]



  **Best attempt** to get client's IP address while keeping it **DRY**.



  There is no perfect `out-of-the-box` solution against fake IP addresses, aka `IP Address Spoofing`.
  You are encouraged to read the ([Advanced users](README.md#advanced-users)) section of this page and
  use `trusted_proxies_ips` and/or `proxy_count` features to match your needs, especially `if` you are
  planning to include `ipware` in any authentication, security or `anti-fraud` related architecture.

  This is an open source project, with the source code visible to all. Therefore, it may be exploited through unimplemented, or improperly implemented features.

  Please use ipware `ONLY` as a complement to your `firewall` security measures!



      1. easy_install django-ipware
      2. pip install django-ipware
      3. git clone http://github.com/un33k/django-ipware
          a. cd django-ipware
          b. run python setup.py install
      4. wget https://github.com/un33k/django-ipware/zipball/master
          a. unzip the downloaded file
          b. cd into django-ipware-* directory
          c. run python setup.py install



  ```python
   

   from ipware import get_client_ip
   client_ip, is_routable = get_client_ip(request)
   if client_ip is None:
      
   else:
       
       if is_routable:
           
       else:
           

   
  ```



  - ### Precedence Order

    The default meta precedence order is top to bottom. However, you may customize the order
    by providing your own `IPWARE_META_PRECEDENCE_ORDER` by adding it to your project's settings.py

    ```python
     
     IPWARE_META_PRECEDENCE_ORDER = (
         'HTTP_X_FORWARDED_FOR', 'X_FORWARDED_FOR',  # <client>, <proxy1>, <proxy2>
         'HTTP_CLIENT_IP',
         'HTTP_X_REAL_IP',
         'HTTP_X_FORWARDED',
         'HTTP_X_CLUSTER_CLIENT_IP',
         'HTTP_FORWARDED_FOR',
         'HTTP_FORWARDED',
         'HTTP_VIA',
         'REMOTE_ADDR',
     )
    ```

    **Alternatively**, you can provide your custom _request header meta precedence order_ when calling `get_client_ip()`.

  ```python
  get_client_ip(request, request_header_order=['X_FORWARDED_FOR'])
  get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'HTTP_X_FORWARDED_FOR'])
  ```



  You may customize the prefixes to indicate an IP address is private. This is done by adding your
  own `IPWARE_PRIVATE_IP_PREFIX` to your project's settings.py. IP addresses matching the following
  prefixes are considered _private_ & are **not** publicly routable.

  ```python

  IPWARE_PRIVATE_IP_PREFIX = getattr(settings,
     'IPWARE_PRIVATE_IP_PREFIX', (
       '0.',  # messages to software
       '10.',  # class A private block
       '100.64.',  '100.65.',  '100.66.',  '100.67.',  '100.68.',  '100.69.',
       '100.70.',  '100.71.',  '100.72.',  '100.73.',  '100.74.',  '100.75.',
       '100.76.',  '100.77.',  '100.78.',  '100.79.',  '100.80.',  '100.81.',
       '100.82.',  '100.83.',  '100.84.',  '100.85.',  '100.86.',  '100.87.',
       '100.88.',  '100.89.',  '100.90.',  '100.91.',  '100.92.',  '100.93.',
       '100.94.',  '100.95.',  '100.96.',  '100.97.',  '100.98.',  '100.99.',
       '100.100.', '100.101.', '100.102.', '100.103.', '100.104.', '100.105.',
       '100.106.', '100.107.', '100.108.', '100.109.', '100.110.', '100.111.',
       '100.112.', '100.113.', '100.114.', '100.115.', '100.116.', '100.117.',
       '100.118.', '100.119.', '100.120.', '100.121.', '100.122.', '100.123.',
       '100.124.', '100.125.', '100.126.', '100.127.',  # carrier-grade NAT
       '169.254.',  # link-local block
       '172.16.', '172.17.', '172.18.', '172.19.',
       '172.20.', '172.21.', '172.22.', '172.23.',
       '172.24.', '172.25.', '172.26.', '172.27.',
       '172.28.', '172.29.', '172.30.', '172.31.',  # class B private blocks
       '192.0.0.',  # reserved for IANA special purpose address registry
       '192.0.2.',  # reserved for documentation and example code
       '192.168.',  # class C private block
       '198.18.', '198.19.',  # reserved for inter-network communications between two separate subnets
       '198.51.100.',  # reserved for documentation and example code
       '203.0.113.',  # reserved for documentation and example code
       '224.', '225.', '226.', '227.', '228.', '229.', '230.', '231.', '232.',
       '233.', '234.', '235.', '236.', '237.', '238.', '239.',  # multicast
       '240.', '241.', '242.', '243.', '244.', '245.', '246.', '247.', '248.',
       '249.', '250.', '251.', '252.', '253.', '254.', '255.',  # reserved
     ) + (
       '::',  # Unspecified address
       '::ffff:', '2001:10:', '2001:20:'  # messages to software
       '2001::',  # TEREDO
       '2001:2::',  # benchmarking
       '2001:db8:',  # reserved for documentation and example code
       'fc00:',  # IPv6 private block
       'fe80:',  # link-local unicast
       'ff00:',  # IPv6 multicast
     )
  )
  ```



  If your Django server is behind one or more known proxy server(s), you can filter out unwanted requests
  by providing the `trusted` proxy list when calling `get_client_ip(request, proxy_trusted_ips=['177.139.233.133'])`.
  In the following example, your load balancer (LB) can be seen as a `trusted` proxy.

  ```
   `Real` Client  <public> <---> <public> LB (Server) <private> <--------> <private> Django Server
                                                                     ^
                                                                     |
   `Fake` Client  <private> <---> <private> LB (Server) <private> ---^
  ```

  ```python

  client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.233.133'])


  client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.233.133', '177.139.233.134'])


  client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.', '177.140'])
  client_ip, is_routable = get_client_ip(request, proxy_trusted_ips=['177.139.233.', '177.139.240'])
  ```

  `Please note:` By default, the `right-most` proxy in the chain is the `trusted` proxy and that is the one your django
  server talks to. Therefore, `ipware` checks to see if the `right-most` proxy address starts with any ip pattern that was
  passed in via the `proxy_trusted_ips` list.



  If your Django server is behind a `known` number of proxy server(s), you can filter out unwanted requests
  by providing the `number` of proxies when calling `get_client_ip(request, proxy_count=1)`.
  In the following example, your load balancer (LB) can be seen as the `only` proxy.

  ```
   `Real` Client  <public> <---> <public> LB (Server) <private> <--------> <private> Django Server
                                                                     ^
                                                                     |
                                         `Fake` Client  <private> ---^
  ```

  ```python

  client_ip, is_routable = get_client_ip(request, proxy_count=1)



  client_ip, is_routable = get_client_ip(request, proxy_count=1, proxy_trusted_ips=['177.139.233.133'])
  ```



  If your proxy server is configured such that the right-most IP address is that of the originating client, you
  can indicate `right-most` as your `proxy_order` when calling `get_client_ip(request, proxy_order="right-most")`.
  Please note that the [de-facto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For) standard
  for the originating client IP address is the `left-most` as per `<client>, <proxy1>, <proxy2>`.



  To run the tests against the current environment:

      python manage.py test



  Released under a ([MIT](LICENSE)) license.



  X.Y.Z Version

      `MAJOR` version -- when you make incompatible API changes,
      `MINOR` version -- when you add functionality in a backwards-compatible manner, and
      `PATCH` version -- when you make backwards-compatible bug fixes.

  [status-image]: https://travis-ci.org/un33k/django-ipware.svg?branch=master
  [status-link]: https://travis-ci.org/un33k/django-ipware
  [version-image]: https://img.shields.io/pypi/v/django-ipware.svg
  [version-link]: https://pypi.python.org/pypi/django-ipware
  [coverage-image]: https://coveralls.io/repos/un33k/django-ipware/badge.svg
  [coverage-link]: https://coveralls.io/r/un33k/django-ipware
  [download-image]: https://img.shields.io/pypi/dm/django-ipware.svg
  [download-link]: https://pypi.python.org/pypi/django-ipware



  [Neekware Inc.](http://neekware.com)


pkgId: eee80ce965567b13a32f958542e46ec19c7ac5a329685a240396452472fb8a29
name: python-django-jinja
arch: src
version: 2.10.2
epoch: 0
release: 1
summary: Jinja2 templating language integrated in Django.
url: https://github.com/niwinz/django-jinja
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f8d4881-1bfa-49cd-a7e3-7e3e717e5909
location_href: 00012002-python-django-jinja/python-django-jinja-2.10.2-1.src.rpm
checksum_type: sha256
description:
  Simple and nonobstructive jinja2 integration with Django.
  **Documentation:** http://niwinz.github.io/django-jinja/latest/


pkgId: 5e610b434441af3c87742b57cf9283e3b867db614b8e973c0d3d9fc3f9a1cbe5
name: python-django-json-widget
arch: src
version: 1.1.1
epoch: 0
release: 1
url: https://github.com/jmrivas86/django-json-widget
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2a853b18-507b-44ae-878c-2c6aa148650c
location_href: 00011330-python-django-json-widget/python-django-json-widget-1.1.1-1.src.rpm
checksum_type: sha256
summary:
  Django json widget is an alternative widget that makes it easy to edit the jsonfield field of django.


pkgId: 386e6d4128f0a06e1bd049d07193ca03685f72bacb76d7c639bd417596bd2e4e
name: python-django-jsonfield
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: JSONField for django models
url: https://github.com/adamchainz/django-jsonfield
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4e95221-e40d-483a-aca8-c9d261110a8b
location_href: 00011219-python-django-jsonfield/python-django-jsonfield-1.4.1-1.src.rpm
checksum_type: sha256
description:
  **Maintenance mode only:** It is not recommended you use this library on new
  projects. Django 3.1 includes a cross-database ``JSONField`` implementation -
  see its `release notes <https://docs.djangoproject.com/en/3.1/releases/3.1/#jsonfield-for-all-supported-database-backends>`__.
  You can use that field on older versions of Django with the
  `django-jsonfield-backport <https://pypi.org/project/django-jsonfield-backport/>`__
  package. See the (long) **History** section below for more information.
  **Naming clarification:** This project is released on Pypi under the name
  `django-jsonfield <https://pypi.org/project/django-jsonfield/>`_.
  It should not be confused with the Pypi package
  `jsonfield <https://pypi.org/project/jsonfield/>`_,


pkgId: 509b7080934dfabdff6e0c6131e773d500e69cc32baad5ae59c30b5f230d930d
name: python-django-log-request-id
arch: src
version: 2.1.0
epoch: 0
release: 1
url: https://github.com/dabapps/django-log-request-id/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-049e3844-ff08-4c8a-b37d-cc4016080316
location_href: 00010650-python-django-log-request-id/python-django-log-request-id-2.1.0-1.src.rpm
checksum_type: sha256
summary:
  Django middleware and log filter to attach a unique ID to every log message generated as part of a request

description:
  **Django middleware and log filter to attach a unique ID to every log message generated as part of a request.**
  **Author:** Jamie Matthews, [@j4mie](https://twitter.com/j4mie)
  [![Build Status](https://travis-ci.org/dabapps/django-log-request-id.png?branch=master)](https://travis-ci.org/dabapps/django-log-request-id)


pkgId: 6e688e11715de77baa2bfc6652715317aabfb45a35d6f2dd6e640d5d057d9333
name: python-django-macros
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: A Django template tag library for repeating blocks tags and creating in template macros.
url: https://github.com/nalourie/django-macros
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31327bd8-3178-4cbd-8434-e1415cd9f090
location_href: 00003473-python-django-macros/python-django-macros-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Macros accepting positional and keyword arguments, and repeated block
  tags in the django template system. Sometimes include tags just don't
  get the job done. Either you have repeated code that you want to keep
  all in the same single template, or your code needs to dynamically
  generate and sub in certain values, in a way that the include syntax
  inhibits. Whatever the case, if you're finding that the built in include
  tag just isn't working for your use case, then perhaps django-macros is
  for you.
  visit the `github <https://github.com/nalourie/django-macros>`__.


pkgId: abc8596f539da6ec225c796f01af7a9f9d23da5284f85d4c4ff2b75c354ce3d0
name: python-django-mailbox
arch: src
version: 4.8.2
epoch: 0
release: 1
url: http://github.com/coddingtonbear/django-mailbox/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-572ac0b3-dea8-4c03-81ac-a6a7d0ce2b52
location_href: 00013559-python-django-mailbox/python-django-mailbox-4.8.2-1.src.rpm
checksum_type: sha256
summary:
  Import mail from POP3, IMAP, local mailboxes or directly from Postfix or Exim4 into your Django application automatically.


pkgId: 6dd8862aab3889fb13ae7ae8f3aa7592a596ab981eaf587440243e792e9e2542
name: python-django-memoize
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: An implementation of memoization technique for Django.
url: https://github.com/unhaggle/django-memoize
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f547d155-30b7-4683-8bac-8cf1f8422fcf
location_href: 00013566-python-django-memoize/python-django-memoize-2.3.1-1.src.rpm
checksum_type: sha256
description:
  **django-memoize** is an implementation
  of `memoization <http://en.wikipedia.org/wiki/Memoization>`_ technique
  for Django. You can think of it as a cache for function or method results.


pkgId: 07bd76711dcfcb9581e23940503502f53100ddf63d87cf22704d05dd6493943f
name: python-django-migration-linter
arch: src
version: 4.1.0
epoch: 0
release: 1
summary: Detect backward incompatible migrations for your django project
url: https://github.com/3YOURMIND/django-migration-linter
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69821bf4-c77c-4a9b-88c8-e73e460c3177
location_href: 00011506-python-django-migration-linter/python-django-migration-linter-4.1.0-1.src.rpm
checksum_type: sha256
description:
  Detect backward incompatible migrations for your Django project.
  It will save you time by making sure migrations will not break with a older codebase.

  [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2F3YOURMIND%2Fdjango-migration-linter%2Fbadge%3Fref%3Dmain&style=flat)](https://actions-badge.atrox.dev/3YOURMIND/django-migration-linter/goto?ref=main)
  [![codecov](https://codecov.io/gh/3YOURMIND/django-migration-linter/branch/master/graph/badge.svg?token=pgNNXGbCf7)](https://codecov.io/gh/3YOURMIND/django-migration-linter)
  [![PyPI](https://img.shields.io/pypi/v/django-migration-linter.svg)](https://pypi.python.org/pypi/django-migration-linter/)
  [![PR_Welcome](https://img.shields.io/badge/PR-welcome-green.svg)](https://github.com/3YOURMIND/django-migration-linter/pulls)
  [![3YD_Hiring](https://img.shields.io/badge/3YOURMIND-Hiring-brightgreen.svg)](https://www.3yourmind.com/career)
  [![GitHub_Stars](https://img.shields.io/github/stars/3YOURMIND/django-migration-linter.svg?style=social&label=Stars)](https://github.com/3YOURMIND/django-migration-linter/stargazers)



  ```
  pip install django-migration-linter
  ```

  And add the migration linter your ``INSTALLED_APPS``:
  ```
      INSTALLED_APPS = [
          ...,
          "django_migration_linter",
          ...,
      ]
  ```



  ```
  $ python manage.py lintmigrations

  (app_add_not_null_column, 0001_create_table)... OK
  (app_add_not_null_column, 0002_add_new_not_null_field)... ERR
          NOT NULL constraint on columns
  (app_drop_table, 0001_initial)... OK
  (app_drop_table, 0002_delete_a)... ERR
          DROPPING table
  (app_ignore_migration, 0001_initial)... OK
  (app_ignore_migration, 0002_ignore_migration)... IGNORE
  (app_rename_table, 0001_initial)... OK
  (app_rename_table, 0002_auto_20190414_1500)... ERR
          RENAMING tables

  *** Summary ***
  Valid migrations: 4/8
  Erroneous migrations: 3/8
  Migrations with warnings: 0/8
  Ignored migrations: 1/8
  ```

  The linter analysed all migrations from the Django project.
  It found 3 migrations that are doing backward incompatible operations and 1 that is explicitly ignored.
  The list of incompatibilities that the linter analyses [can be found at docs/incompatibilities.md](./docs/incompatibilities.md).

  More advanced usages of the linter and options [can be found at docs/usage.md](./docs/usage.md).



  One can either integrate the linter in the CI using its `lintmigrations` command, or detect incompatibilities during generation of migrations with
  ```
  $ python manage.py makemigrations --lint

  Migrations for 'app_correct':
    tests/test_project/app_correct/migrations/0003_a_column.py
      - Add field column to a
  Linting for 'app_correct':
  (app_correct, 0003_a_column)... ERR
          NOT NULL constraint on columns

  The migration linter detected that this migration is not backward compatible.
  - If you keep the migration, you will want to fix the issue or ignore the migration.
  - By default, the newly created migration file will be deleted.
  Do you want to keep the migration? [y/N] n
  Deleted tests/test_project/app_correct/migrations/0003_a_column.py
  ```

  The linter found that the newly created migration is not backward compatible and deleted the file after confirmation.
  This behaviour can be the default of the `makemigrations` command through the `MIGRATION_LINTER_OVERRIDE_MAKEMIGRATIONS` Django setting.
  Find out more about the [makemigrations command at docs/makemigrations.md](./docs/makemigrations.md).



  Please find more documentation [in the docs/ folder](./docs/).

  Some implementation details [can be found in the ./docs/internals/ folder](./docs/internals/).



  * [Keeping Django database migrations backward compatible](https://medium.com/3yourmind/keeping-django-database-migrations-backward-compatible-727820260dbb)
  * [Django and its default values](https://medium.com/botify-labs/django-and-its-default-values-c21a13cff9f)



  * [Django News](https://django-news.com/issues/6?m=web#uMmosw7)
  * [wemake-django-template](https://wemake-django-template.readthedocs.io/en/latest/pages/template/linters.html#django-migration-linter)
  * [Testing Django migrations on sobolevn's blog](https://sobolevn.me/2019/10/testing-django-migrations#existing-setup)



  * [django-test-migrations](https://github.com/wemake-services/django-test-migrations) - Test django schema and data migrations, including migrations' order and best practices.



  *django-migration-linter* is released under the [Apache 2.0 License](./LICENSE).


pkgId: 0428219943708d8c20aa907f4ff7c5e96a1cae7cdf637fa89d81230c30c5617e
name: python-django-modelcluster
arch: src
version: 6.0
epoch: 0
release: 1
url: https://github.com/wagtail/django-modelcluster
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c55e4143-78b2-46ba-ad4c-a7f9f70863eb
location_href: 00011577-python-django-modelcluster/python-django-modelcluster-6.0-1.src.rpm
checksum_type: sha256
summary:
  Django extension to allow working with 'clusters' of models as a single unit, independently of the database

description:
  If you had a data model like this:
   class Band(models.Model):
       name = models.CharField(max_length=255)
   class BandMember(models.Model):
       band = models.ForeignKey('Band', related_name='members', on_delete=models.CASCADE)
       name = models.CharField(max_length=255)
  wouldn't it be nice if you could construct bundles of objects like this, independently of the database:
   beatles = Band(name='The Beatles')
   beatles.members = [
       BandMember(name='John Lennon'),
       BandMember(name='Paul McCartney'),
   ]
  Unfortunately, you can't. Objects need to exist in the database for foreign key relations to work:
   IntegrityError: null value in column "band_id" violates not-null constraint
  But what if you could? There are all sorts of scenarios where you might want to work with a 'cluster' of related objects, without necessarily holding them in the database: maybe you want to render a preview of the data the user has just submitted, prior to saving. Maybe you need to construct a tree of things, serialize them and hand them off to some external system. Maybe you have a workflow where your models exist in an incomplete 'draft' state for an extended time, or you need to handle multiple revisions, and you don't want to redesign your database around that requirement.
  **django-modelcluster** extends Django's foreign key relations to make this possible. It introduces a new type of relation, *ParentalKey*, where the related models are stored locally to the 'parent' model until the parent is explicitly saved. Up to that point, the related models can still be accessed through a subset of the QuerySet API:
   from modelcluster.models import ClusterableModel
   from modelcluster.fields import ParentalKey
   class Band(ClusterableModel):
       name = models.CharField(max_length=255)
   class BandMember(models.Model):
       band = ParentalKey('Band', related_name='members', on_delete=models.CASCADE)
       name = models.CharField(max_length=255)
   >>> beatles = Band(name='The Beatles')
   >>> beatles.members = [
   >>> [member.name for member in beatles.members.all()]
   ['John Lennon', 'Paul McCartney']
   >>> beatles.members.add(BandMember(name='George Harrison'))
   >>> beatles.members.count()
   3
   >>> beatles.save()  # only now are the records written to the database
  For more examples, see the unit tests.


pkgId: 1506d4c8344a13a078ab878056e74c82911508bd982fd283fe10e75751514119
name: python-django-money
arch: src
version: 3.0.0
epoch: 0
release: 1
url: https://github.com/django-money/django-money
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7edf992f-b5fe-4f21-a103-19eb511f3df6
location_href: 00011491-python-django-money/python-django-money-3.0.0-1.src.rpm
checksum_type: sha256
summary:
  Adds support for using money and currency fields in django models and forms. Uses py-moneyed as the money implementation.

description:
  A little Django app that uses `py-moneyed <https://github.com/py-moneyed/py-moneyed>`__ to add support for Money
  fields in your models and forms.
  * Django versions supported: 2.2, 3.2, 4.0, 4.1
  * Python versions supported: 3.7, 3.8, 3.9, 3.10
  * PyPy versions supported: PyPy3
  If you need support for older versions of Django and Python, please refer to older releases mentioned in `the release notes <https://django-money.readthedocs.io/en/latest/changes.html>`__.
  Through the dependency `py-moneyed <https://github.com/py-moneyed/py-moneyed>`__, ``django-money`` gets:
  * Support for proper Money value handling (using the standard Money
    design pattern)
  * A currency class and definitions for all currencies in circulation
  * Formatting of most currencies with correct currency sign


pkgId: 97c9b9a886ee0f89654ab39cfc2068ca35bfdc85def9554e186a07aed7c2667a
name: python-django-mptt
arch: src
version: 0.14.0
epoch: 0
release: 1
url: https://github.com/django-mptt/django-mptt/
rpm_license: MIT-License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f943b240-8b67-472c-81a6-77ac9f226c81
location_href: 00003475-python-django-mptt/python-django-mptt-0.14.0-1.src.rpm
checksum_type: sha256
summary:
  Utilities for implementing Modified Preorder Tree Traversal with your Django Models and working with trees of Model instances.


pkgId: 3fe8b87a3e9ecf5adc6d730fd7c299aec993aa96f8b92121bf4cdb15525b0088
name: python-django-multiselectfield
arch: src
version: 0.1.12
epoch: 0
release: 1
summary: Django multiple select field
url: https://github.com/goinnn/django-multiselectfield
rpm_license: LGPL 3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7f8fc1dc-975d-4ac9-bfb4-b19444d2fe7b
location_href: 00011244-python-django-multiselectfield/python-django-multiselectfield-0.1.12-1.src.rpm
checksum_type: sha256
description:
  A new model field and form field. With this you can get a multiple select from a choices. Stores to the database as a CharField of comma-separated values.
  This egg is inspired by this `snippet <http://djangosnippets.org/snippets/1200/>`_.
  Supported Python versions: 2.7, 3.4+
  Supported Django versions: 1.4-2.0+


pkgId: cdac3372cf439b979a91860f0274ca73411f96180f7914e1a329dcdcbf2ad541
name: python-django-nested-admin
arch: src
version: 4.0.2
epoch: 0
release: 1
summary: Django admin classes that allow for nested inlines
url: https://github.com/theatlantic/django-nested-admin
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c62170a6-87df-45b9-bbb9-b81cb7341864
location_href: 00011535-python-django-nested-admin/python-django-nested-admin-4.0.2-1.src.rpm
checksum_type: sha256
description:
  The recommended way to install django-nested-admin is from
  `PyPI <https://pypi.python.org/pypi/django-nested-admin>`_::
          pip install django-nested-admin
  Alternatively, one can install a development copy of django-nested-admin
  from source::
          pip install -e git+git://github.com/theatlantic/django-nested-admin.git#egg=django-nested-admin
  If the source is already checked out, use setuptools to install::
          python setup.py develop


pkgId: ecc4f02bc7a8277347087b947ba91f3245a364e27be10a2a6b91ee1c4f7bea1b
name: python-django-oauth-toolkit
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: OAuth2 Provider for Django
url: https://github.com/jazzband/django-oauth-toolkit
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c3d200f-c058-4b20-851b-96ad9a698239
location_href: 00010321-python-django-oauth-toolkit/python-django-oauth-toolkit-2.2.0-1.src.rpm
checksum_type: sha256
description:
  *OAuth2 goodies for the Djangonauts!*
  If you are facing one or more of the following:
   * Your Django app exposes a web API you want to protect with OAuth2 authentication,
   * You need to implement an OAuth2 authorization server to provide tokens management for your infrastructure,
  Django OAuth Toolkit can help you providing out of the box all the endpoints, data and logic needed to add OAuth2
  capabilities to your Django projects. Django OAuth Toolkit makes extensive use of the excellent
  `OAuthLib <https://github.com/idan/oauthlib>`_, so that everything is
  `rfc-compliant <http://tools.ietf.org/html/rfc6749>`_.
  Note: If you have issues installing Django 4.0.0, it is because we only support
  Django 4.0.1+ due to a regression in Django 4.0.0. Besides 4.0.0, Django 2.2+ is supported.
  `Explanation <https://github.com/jazzband/django-oauth-toolkit/pull/1046#issuecomment-998015272>`_.


pkgId: 9a2036f01cd106562b06d45a9978a9cdf4d74a4cef037c99cb98bfc6a0e88057
name: python-django-ordered-model
arch: src
version: 3.7.4
epoch: 0
release: 1
summary: Allows Django models to be ordered and provides a simple admin interface for reordering them.
url: http://github.com/django-ordered-model/django-ordered-model
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d40898cf-47d1-4c59-a087-59eec4aa4e2e
location_href: 00012206-python-django-ordered-model/python-django-ordered-model-3.7.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://secure.travis-ci.org/bfirsh/django-ordered-model.png?branch=master)](https://travis-ci.org/bfirsh/django-ordered-model)
  [![PyPI version](https://badge.fury.io/py/django-ordered-model.svg)](https://badge.fury.io/py/django-ordered-model)
  [![codecov](https://codecov.io/gh/bfirsh/django-ordered-model/branch/master/graph/badge.svg)](https://codecov.io/gh/bfirsh/django-ordered-model)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
  django-ordered-model allows models to be ordered and provides a simple admin
  interface for reordering them.
  Based on https://djangosnippets.org/snippets/998/ and
  https://djangosnippets.org/snippets/259/
  See our [compatability notes](#compatibility-with-django-and-python) for the appropriate version to use with older Django and Python releases.


pkgId: 1fc147f6fdc60893971eb36f6866c1a949e6ad58c248d9dcec930bd10b07174e
name: python-django-otp
arch: src
version: 1.1.6
epoch: 0
release: 1
summary: A pluggable framework for adding two-factor authentication to Django using one-time passwords.
url: https://github.com/django-otp/django-otp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-42884630-539f-43d6-8895-246f4aed4c9a
location_href: 00010459-python-django-otp/python-django-otp-1.1.6-1.src.rpm
checksum_type: sha256
description:
  This project makes it easy to add support for `one-time passwords
  <http://en.wikipedia.org/wiki/One-time_password>`_ (OTPs) to Django. It can be
  integrated at various levels, depending on how much customization is required.
  It integrates with ``django.contrib.auth``, although it is not a Django
  authentication backend. The primary target is developers wishing to incorporate
  OTPs into their Django projects as a form of `two-factor authentication
  <http://en.wikipedia.org/wiki/Two-factor_authentication>`_.
  Several simple OTP plugins are included and more are available separately. This
  package also includes an implementation of OATH `HOTP
  <http://tools.ietf.org/html/rfc4226>`_ and `TOTP
  <http://tools.ietf.org/html/rfc6238>`_ for convenience, as these are standard
  OTP algorithms used by multiple plugins.
  If you're looking for a higher-level or more opinionated solution, you might be
  interested in `django-two-factor-auth
  <https://github.com/Bouke/django-two-factor-auth>`_.


pkgId: 4e0ee8053aff1794238aa1d6080fa1d980a91601db18f11db77b2134eb8cd7d4
name: python-django-polymorphic
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Seamless polymorphic inheritance for Django models
url: https://github.com/django-polymorphic/django-polymorphic
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d53c9668-bb93-41d8-8fdd-7f023c140720
location_href: 00010453-python-django-polymorphic/python-django-polymorphic-3.1.0-1.src.rpm
checksum_type: sha256
description:
  Django-polymorphic simplifies using inherited models in Django projects.
  When a query is made at the base model, the inherited model classes are returned.
  When we store models that inherit from a ``Project`` model...
      >>> Project.objects.create(topic="Department Party")
      >>> ArtProject.objects.create(topic="Painting with Tim", artist="T. Turner")
      >>> ResearchProject.objects.create(topic="Swallow Aerodynamics", supervisor="Dr. Winter")
      >>> Project.objects.all()
      [ <Project:         id 1, topic "Department Party">,
        <ArtProject:      id 2, topic "Painting with Tim", artist "T. Turner">,
        <ResearchProject: id 3, topic "Swallow Aerodynamics", supervisor "Dr. Winter"> ]
  Using vanilla Django, we get the base class objects, which is rarely what we wanted:
      >>> Project.objects.all()
      [ <Project: id 1, topic "Department Party">,
        <Project: id 2, topic "Painting with Tim">,
        <Project: id 3, topic "Swallow Aerodynamics"> ]
  This also works when the polymorphic model is accessed via
  ForeignKeys, ManyToManyFields or OneToOneFields.


pkgId: a630959755c5dfa9bbb9d9e01685741bd2f427f3199df45921c51c41388e7b9c
name: python-django-post-office
arch: src
version: 3.6.3
epoch: 0
release: 1
summary: A Django app to monitor and send mail asynchronously, complete with template support.
url: https://github.com/ui/django-post_office
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9fd9f3b8-4032-47be-9a44-02fa704ddc48
location_href: 00003478-python-django-post_office/python-django-post-office-3.6.3-1.src.rpm
checksum_type: sha256
description:
  if Django's caching mechanism is configured, `post_office` will cache
  `EmailTemplate` instances . If for some reason you want to disable
  caching, set `POST_OFFICE_CACHE` to `False` in `settings.py`:
  ```python


  POST_OFFICE_CACHE = False

  CACHES = {
      'post_office': {
          'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
          'LOCATION': '127.0.0.1:11211',
      }
  }
  ```

  `send_many()` is much more performant (generates less database queries)
  when sending a large number of emails. `send_many()` is almost identical
  to `mail.send()`, with the exception that it accepts a list of keyword
  arguments that you'd usually pass into `mail.send()`:
  ```python
  from post_office import mail
  first_email = {
      'sender': 'from@example.com',
      'recipients': ['alice@example.com'],
      'subject': 'Hi!',
      'message': 'Hi Alice!'
  }
  second_email = {
      'sender': 'from@example.com',
      'recipients': ['bob@example.com'],
      'subject': 'Hi!',
      'message': 'Hi Bob!'
  }
  kwargs_list = [first_email, second_email]
  mail.send_many(kwargs_list)
  ```
  Attachments are not supported with `mail.send_many()`.

  To run the test suite:
  ```python
  `which django-admin.py` test post_office --settings=post_office.test_settings --pythonpath=.
  ```
  You can run the full test suite for all supported versions of Django and Python with:
  ```python
  tox
  ```
  or:
  ```python
  python setup.py test
  ```

  If your Django project runs in a Celery enabled configuration, you can use its worker to send out
  queued emails. Compared to the solution with cron (see above), or the solution with uWSGI timers
  (see below) this setup has the big advantage that queued emails are send *immediately* after they
  have been added to the mail queue. The delivery is still performed in a separate and asynchronous
  task, which prevents sending emails during the request/response-cycle.
  If you [configured Celery](https://docs.celeryproject.org/en/latest/userguide/application.html)
  in your project and started the
  [Celery worker](https://docs.celeryproject.org/en/latest/userguide/workers.html),
  you should see something such as:


pkgId: 77c3fb898cadd380914fd04d0b2fa44cb5a968720ad307db144ebd1badcfd30a
name: python-django-prettyjson
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Enables pretty JSON viewer in Django forms, admin, or templates
url: https://github.com/kevinmickey/django-prettyjson
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81efeb24-b049-4fa2-add8-21c30e46f7f9
location_href: 00011975-python-django-prettyjson/python-django-prettyjson-0.4.1-1.src.rpm
checksum_type: sha256
description:
  0.1.0 (2016-05-28)
  ++++++++++++++++++
  * First release.
  0.2.0 (2016-05-29)
  ++++++++++++++++++
  * Switched to using standardjson for encoding objects
  * Added setup option for those with jquery already loaded
  0.2.1 (2016-07-01)
  ++++++++++++++++++
  * Fixed manifest
  0.2.2 (2016-12-07)
  ++++++++++++++++++
  * Added dependencies to setup.py
  0.3.0 (2017-05-23)
  ++++++++++++++++++
  * Added "initial" option to show raw or parsed initial
  * Requires six
  0.3.1 (2018-04-01)
  ++++++++++++++++++
  * Allows CSS control of parsed widget
  0.3.2 (2018-04-09)
  ++++++++++++++++++
  * Fixes widget media order
  0.3.3 (2018-04-13)
  ++++++++++++++++++
  * Fixes string passed as parameter
  0.4.0 (2018-04-30)
  ++++++++++++++++++
  * Allows attrs in template tag
  * Fix JS for initial parsed with multiple widgets
  * Change parsed CSS height to max-height
  0.4.1 (2018-08-07)
  ++++++++++++++++++
  * Fix widget for Django 2.1


pkgId: 14325f8dd5ad158532db59527eaa81640d72f3aa321b34fd03e82005c7e46d85
name: python-django-prometheus
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Django middlewares to monitor your application with Prometheus.io.
url: http://github.com/korfuri/django-prometheus
rpm_license: Apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fb4905e3-dd5e-4245-b4c8-5c93cab821f3
location_href: 00003479-python-django-prometheus/python-django-prometheus-2.2.0-1.src.rpm
checksum_type: sha256
description:
  Export Django monitoring metrics for Prometheus.io

  [![Join the chat at https://gitter.im/django-prometheus/community](https://badges.gitter.im/django-prometheus/community.svg)](https://gitter.im/django-prometheus/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  [![PyPI version](https://badge.fury.io/py/django-prometheus.svg)](http://badge.fury.io/py/django-prometheus)
  [![Build Status](https://github.com/korfuri/django-prometheus/actions/workflows/ci.yml/badge.svg)](https://github.com/korfuri/django-prometheus/actions/workflows/ci.yml)
  [![Coverage Status](https://coveralls.io/repos/github/korfuri/django-prometheus/badge.svg?branch=master)](https://coveralls.io/github/korfuri/django-prometheus?branch=master)
  [![PyPi page link -- Python versions](https://img.shields.io/pypi/pyversions/django-prometheus.svg)](https://pypi.python.org/pypi/django-prometheus)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  This library provides Prometheus metrics for Django related operations:

  * Requests & Responses
  * Database access done via [Django ORM](https://docs.djangoproject.com/en/3.0/topics/db/)
  * Cache access done via [Django Cache framework](https://docs.djangoproject.com/en/3.0/topics/cache/)





  * Django >= 2.2



  Install with:

  ```shell
  pip install django-prometheus
  ```

  Or, if you're using a development version cloned from this repository:

  ```shell
  python path-to-where-you-cloned-django-prometheus/setup.py install
  ```

  This will install [prometheus_client](https://github.com/prometheus/client_python) as a dependency.



  In your settings.py:

  ```python
  INSTALLED_APPS = [
     ...
     'django_prometheus',
     ...
  ]

  MIDDLEWARE = [
      'django_prometheus.middleware.PrometheusBeforeMiddleware',
      
      
      
      'django_prometheus.middleware.PrometheusAfterMiddleware',
  ]
  ```

  In your urls.py:

  ```python
  urlpatterns = [
      ...
      path('', include('django_prometheus.urls')),
  ]
  ```



  Prometheus uses Histogram based grouping for monitoring latencies. The default
  buckets are here: https://github.com/prometheus/client_python/blob/master/prometheus_client/core.py

  You can define custom buckets for latency, adding more buckets decreases performance but
  increases accuracy: https://prometheus.io/docs/practices/histograms/

  ```python
  PROMETHEUS_LATENCY_BUCKETS = (.1, .2, .5, .6, .8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.5, 9.0, 12.0, 15.0, 20.0, 30.0, float("inf"))
  ```



  SQLite, MySQL, and PostgreSQL databases can be monitored. Just
  replace the `ENGINE` property of your database, replacing
  `django.db.backends` with `django_prometheus.db.backends`.

  ```python
  DATABASES = {
      'default': {
          'ENGINE': 'django_prometheus.db.backends.sqlite3',
          'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
      },
  }
  ```



  Filebased, memcached, redis caches can be monitored. Just replace
  the cache backend to use the one provided by django_prometheus
  `django.core.cache.backends` with `django_prometheus.cache.backends`.

  ```python
  CACHES = {
      'default': {
          'BACKEND': 'django_prometheus.cache.backends.filebased.FileBasedCache',
          'LOCATION': '/var/tmp/django_cache',
      }
  }
  ```



  You may want to monitor the creation/deletion/update rate for your
  model. This can be done by adding a mixin to them. This is safe to do
  on existing models (it does not require a migration).

  If your model is:

  ```python
  class Dog(models.Model):
      name = models.CharField(max_length=100, unique=True)
      breed = models.CharField(max_length=100, blank=True, null=True)
      age = models.PositiveIntegerField(blank=True, null=True)
  ```

  Just add the `ExportModelOperationsMixin` as such:

  ```python
  from django_prometheus.models import ExportModelOperationsMixin

  class Dog(ExportModelOperationsMixin('dog'), models.Model):
      name = models.CharField(max_length=100, unique=True)
      breed = models.CharField(max_length=100, blank=True, null=True)
      age = models.PositiveIntegerField(blank=True, null=True)
  ```

  This will export 3 metrics, `django_model_inserts_total{model="dog"}`,
  `django_model_updates_total{model="dog"}` and
  `django_model_deletes_total{model="dog"}`.

  Note that the exported metrics are counters of creations,
  modifications and deletions done in the current process. They are not
  gauges of the number of objects in the model.

  Starting with Django 1.7, migrations are also monitored. Two gauges
  are exported, `django_migrations_applied_by_connection` and
  `django_migrations_unapplied_by_connection`. You may want to alert if
  there are unapplied migrations.

  If you want to disable the Django migration metrics, set the
  `PROMETHEUS_EXPORT_MIGRATIONS` setting to False.



  Prometheus is quite easy to set up. An example prometheus.conf to
  scrape `127.0.0.1:8001` can be found in `examples/prometheus`.

  Here's an example of a PromDash displaying some of the metrics
  collected by django-prometheus:

  ![Example dashboard](https://raw.githubusercontent.com/korfuri/django-prometheus/master/examples/django-promdash.png)



  You can add application-level metrics in your code by using
  [prometheus_client](https://github.com/prometheus/client_python)
  directly. The exporter is global and will pick up your metrics.

  To add metrics to the Django internals, the easiest way is to extend
  django-prometheus' classes. Please consider contributing your metrics,
  pull requests are welcome. Make sure to read the Prometheus best
  practices on
  [instrumentation](http://prometheus.io/docs/practices/instrumentation/)
  and [naming](http://prometheus.io/docs/practices/naming/).



  If you wish to use Django Prometheus but are not able to change
  the code base, it's possible to have all the default metrics by
  modifying only the settings.

  First step is to inject prometheus' middlewares and to add
  django_prometheus in INSTALLED_APPS

  ```python
  MIDDLEWARE = \
      ['django_prometheus.middleware.PrometheusBeforeMiddleware'] + \
      MIDDLEWARE + \
      ['django_prometheus.middleware.PrometheusAfterMiddleware']

  INSTALLED_APPS += ['django_prometheus']
  ```

  Second step is to create the /metrics end point, for that we need
  another file (called urls_prometheus_wrapper.py in this example) that
  will wraps the apps URLs and add one on top:

  ```python
  from django.urls import include, path


  urlpatterns = []

  urlpatterns.append(path('prometheus/', include('django_prometheus.urls')))
  urlpatterns.append(path('', include('myapp.urls')))
  ```

  This file will add a "/prometheus/metrics" end point to the URLs of django
  that will export the metrics (replace myapp by your project name).

  Then we inject the wrapper in settings:

  ```python
  ROOT_URLCONF = "graphite.urls_prometheus_wrapper"
  ```



  You can add application specific labels to metrics reported by the django-prometheus middleware.
  This involves extending the classes defined in middleware.py.

  * Extend the Metrics class and override the `register_metric` method to add the application specific labels.
  * Extend middleware classes, set the metrics_cls class attribute to the the extended metric class and override the label_metric method to attach custom metrics.

  See implementation example in [the test app](django_prometheus/tests/end2end/testapp/test_middleware_custom_labels.py#L19-L46)


pkgId: 8b4f74611b789bc398a8818ffa1e9efd02018c804fb328ac536912930b3e9b1e
name: python-django-push-notifications
arch: src
version: 3.0.0
epoch: 0
release: 1
url: https://github.com/jazzband/django-push-notifications
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-695beb9c-410f-42a9-8d49-e7840168aefc
location_href: 00013429-python-django-push-notifications/python-django-push-notifications-3.0.0-1.src.rpm
checksum_type: sha256
summary:
  Send push notifications to mobile devices through GCM, APNS or WNS and to WebPush (Chrome, Firefox and Opera) in Django


pkgId: 69d1056aea67f7ca632dc3a7ab5f75b9b2bb43d3c8fa11ffc356f89e42a3d33e
name: python-django-pyscss
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Makes it easier to use PySCSS in Django.
url: https://github.com/fusionbox/django-pyscss
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b694dd5e-1ed1-468c-b3f3-ec10aa145f82
location_href: 00003480-python-django-pyscss/python-django-pyscss-2.0.2-1.src.rpm
checksum_type: sha256
description:
  A collection of tools for making it easier to use pyScss within Django.
      This version only supports pyScss 1.3.4 and greater. For pyScss 1.2 support,
      you can use the 1.x series of django-pyscss.


pkgId: 251f59e124f293a253421d5596a017a6bbeda76d52d5d1333c8012e45c83e703
name: python-django-pytest
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: django test runner to use py.test tests
url: http://github.com/buchuki/django-pytest
rpm_license: LICENSE.txt
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-82003ea4-e6b8-4338-a77e-574897377ecb
location_href: 00003481-python-django-pytest/python-django-pytest-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This project allows you to use py.test as a django test runner, instead of the
  default test runner.
  To use it, add it to your python path and add `django_pytest` to your installed
  apps. Also set the `TEST_RUNNER = 'django_pytest.test_runner.run_tests'` setting.
  If you're using Django 1.3 or newer set
  `TEST_RUNNER = 'django_pytest.test_runner.TestRunner'` or Django will print
  deprecation warnings each time you run your tests.
  Also create a `conftest.py` in your project directory and include:
  	from django_pytest.conftest import pytest_funcarg__client, pytest_funcarg__django_client
  You can also use:
  	from django_pytest.auth_funcargs import pytest_funcarg__user, pytest_funcarg__groups
  to import a user or some groups with users in them
  Now anywhere in your project, you can create files called
  `test_<something>.py`.  These are standard py.test test files. Use the funcarg
  `client` in every test to both instantiate a test database that is cleared
  after each test and to provide you with a django test client object identical
  to the one used in django's test system. For example:
  	def test_filter(client):
      	response = client.get('/browse/', {'filter': '1'})
      	assert response.status_code == 200
  Use `./manage.py test` to run the py.test test runs (ie: it replaces the
  standard django test runner). You can pass py.test options to the command
  and they will be forwarded to py.test. (Technically, I haven't got it passing
  all options, just the most common ones I use)
  The management command has been set up so that syncdb will use the django core
  syncdb if `SOUTH_TESTS_MIGRATE` is set to False, if south is installed. This
  prevents migrations from running when running unit tests. This speeds up test
  setup significantly, but it means your test db may not be identical to
  production, if you have faulty migrations.
  py.test automatically picks up any subclasses of `unittest.TestCase`, provided
  they are in a module named `test_<something>.py`. Thus, all your existing django
  unittests should work seemlessly with py.test, although you may have to rename
  your test files if they do not conform to this convention. You can also write
  custom py.test test collection hooks to pick up test modules that are named in
  a different directory structure.
  This project differs from <http://github.com/bfirsh/pytest_django> in that it
  provides a django test runner that calls py.test, rather than creating a
  py.test plugin to test django projects. I believe there is overlapping
  functionality from the two projects, and also that they can be integrated into
  a single project, but I have not looked at the feasibility of this yet.


pkgId: 14d6b447d5c8bd46c65bf14df837fc205eff31f06b213ecf124cd881d2b5d7de
name: python-django-python3-ldap
arch: src
version: 0.15.4
epoch: 0
release: 1
summary: Django LDAP user authentication backend for Python 3.
url: https://github.com/etianen/django-python3-ldap
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f0236abd-005b-4b74-b2c3-feab0e924d48
location_href: 00013689-python-django-python3-ldap/python-django-python3-ldap-0.15.4-1.src.rpm
checksum_type: sha256
description:
  **django-python3-ldap** provides a Django LDAP user authentication backend. Python 3.6+ is required.


pkgId: b1a2cdbc467bf0023c2da0277575591301c9b935938e2eae01b3782359d81c07
name: python-django-q
arch: src
version: 1.3.9
epoch: 0
release: 1
summary: A multiprocessing distributed task queue for Django
url: https://django-q.readthedocs.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e8b6f062-0f63-40e2-ba4b-68f5b4db4ba5
location_href: 00012475-python-django-q/python-django-q-1.3.9-1.src.rpm
checksum_type: sha256
description:
  |image0| |image1| |docs| |image2|
  Features
  ~~~~~~~~
  -  Multiprocessing worker pool
  -  Asynchronous tasks
  -  Scheduled, cron and repeated tasks
  -  Signed and compressed packages
  -  Failure and success database or cache
  -  Result hooks, groups and chains
  -  Django Admin integration
  -  PaaS compatible with multiple instances
  -  Multi cluster monitor
  -  Redis, Disque, IronMQ, SQS, MongoDB or ORM
  -  Rollbar and Sentry support
  Requirements
  ~~~~~~~~~~~~
  -  `Django <https://www.djangoproject.com>`__ > = 2.2
  -  `Django-picklefield <https://github.com/gintas/django-picklefield>`__
  -  `Arrow <https://github.com/crsmithdev/arrow>`__
  -  `Blessed <https://github.com/jquast/blessed>`__
  Tested with: Python 3.7, 3.8, 3.9 Django 2.2.X and 3.2.X
  Brokers
  ~~~~~~~
  - `Redis <https://django-q.readthedocs.org/en/latest/brokers.html#redis>`__
  - `Disque <https://django-q.readthedocs.org/en/latest/brokers.html#disque>`__
  - `IronMQ <https://django-q.readthedocs.org/en/latest/brokers.html#ironmq>`__
  - `Amazon SQS <https://django-q.readthedocs.org/en/latest/brokers.html#amazon-sqs>`__
  - `MongoDB <https://django-q.readthedocs.org/en/latest/brokers.html#mongodb>`__
  - `Django ORM <https://django-q.readthedocs.org/en/latest/brokers.html#django-orm>`__
  Installation
  ~~~~~~~~~~~~
  -  Install the latest version with pip::
      $ pip install django-q
  -  Add `django_q` to your `INSTALLED_APPS` in your projects `settings.py`::
         INSTALLED_APPS = (
             
             'django_q',
         )
  -  Run Django migrations to create the database tables::
      $ python manage.py migrate
  -  Choose a message `broker <https://django-q.readthedocs.org/en/latest/brokers.html>`__ , configure and install the appropriate client library.
  Read the full documentation at `https://django-q.readthedocs.org <https://django-q.readthedocs.org>`__
  Configuration
  ~~~~~~~~~~~~~
  All configuration settings are optional. e.g:
      
      Q_CLUSTER = {
          'name': 'myproject',
          'workers': 8,
          'recycle': 500,
          'timeout': 60,
          'compress': True,
          'cpu_affinity': 1,
          'save_limit': 250,
          'queue_limit': 500,
          'label': 'Django Q',
          'redis': {
              'host': '127.0.0.1',
              'port': 6379,
              'db': 0, }
      }
  For full configuration options, see the `configuration documentation <https://django-q.readthedocs.org/en/latest/configure.html>`__.
  Management Commands
  ~~~~~~~~~~~~~~~~~~~
  Start a cluster with::
      $ python manage.py qcluster
  Monitor your clusters with::
      $ python manage.py qmonitor
  Monitor your clusters' memory usage with::
      $ python manage.py qmemory
  Check overall statistics with::
      $ python manage.py qinfo
  Creating Tasks
  ~~~~~~~~~~~~~~
  Use `async_task` from your code to quickly offload tasks:
      from django_q.tasks import async_task, result
      
      async_task('math.copysign', 2, -2)
      
      import math.copysign
      task_id = async_task(copysign, 2, -2)
      
      task_result = result(task_id)
      
      
      task_result = result(task_id, 200)
      
      async_task('math.modf', 2.5, hook='hooks.print_result')
      
      def print_result(task):
          print(task.result)
  For more info see `Tasks <https://django-q.readthedocs.org/en/latest/tasks.html>`__
  Schedule
  ~~~~~~~~
  Schedules are regular Django models. You can manage them through the
  Admin page or directly from your code:
      
      from django_q.tasks import schedule
      schedule('math.copysign',
               2, -2,
               hook='hooks.print_result',
               schedule_type=Schedule.DAILY)
      
      from django_q.models import Schedule
      Schedule.objects.create(func='math.copysign',
                              hook='hooks.print_result',
                              args='2,-2',
                              schedule_type=Schedule.DAILY
                              )
      
      
      import arrow
      schedule('math.hypot',
               3, 4,
               schedule_type=Schedule.MINUTES,
               minutes=5,
               repeats=24,
               next_run=arrow.utcnow().replace(hour=18, minute=0))
      
      schedule('math.hypot',
               3, 4,
               schedule_type=Schedule.CRON,
               cron = '0 22 * * 1-5')
  For more info check the `Schedules <https://django-q.readthedocs.org/en/latest/schedules.html>`__ documentation.
  Testing
  ~~~~~~~
  To run the tests you will need the following in addition to install requirements:
  * `py.test <http://pytest.org/latest/>`__
  * `pytest-django <https://github.com/pytest-dev/pytest-django>`__
  * Disque from https://github.com/antirez/disque.git
  * Redis
  * MongoDB
  Or you can use the included Docker Compose file.
  The following commands can be used to run the tests:
      
      python -m venv venv
      
      venv/bin/pip install -r requirements.txt
      
      venv/bin/pip install pytest pytest-django
      
      venv/bin/python setup.py develop
      
      docker-compose -f test-services-docker-compose.yaml up -d
      
      venv/bin/pytest
      
      docker-compose -f test-services-docker-compose.yaml down
  Locale
  ~~~~~~
  Currently available in English, German and French.
  Translation pull requests are always welcome.
  Todo
  ~~~~
  -  Better tests and coverage
  -  Less dependencies?
  Acknowledgements
  ~~~~~~~~~~~~~~~~
  -  Django Q was inspired by working with
     `Django-RQ <https://github.com/ui/django-rq>`__ and
     `RQ <https://github.com/ui/django-rq>`__
  -  Human readable hashes by
     `HumanHash <https://github.com/zacharyvoase/humanhash>`__
  -  Redditors feedback at `r/django <https://www.reddit.com/r/django/>`__
  -  JetBrains for their `Open Source Support Program <https://www.jetbrains.com/community/opensource>`__


pkgId: 34f523bc96a5697dbfb7f322047e3c6eb4a80d2df8c67aa08465fbbb839edd67
name: python-django-qr-code
arch: src
version: 3.1.1
epoch: 0
release: 1
summary: An application that provides tools for displaying QR codes on your Django site.
url: https://github.com/dprog-philippe-docourt/django-qr-code
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1af9cd43-9637-4259-bc27-d45db4aa9cf4
location_href: 00013614-python-django-qr-code/python-django-qr-code-3.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Latest PyPI version](https://badge.fury.io/py/django-qr-code.svg)](https://badge.fury.io/py/django-qr-code)
  [![Downloads](https://img.shields.io/pypi/dm/django-qr-code.svg)](https://pypi.python.org/pypi/django-qr-code)
  [![Documentation Status](https://readthedocs.org/projects/django-qr-code/badge/?version=latest)](http://django-qr-code.readthedocs.io/en/latest/)
  [![Build Status](https://travis-ci.com/dprog-philippe-docourt/django-qr-code.svg?branch=master)](https://app.travis-ci.com/github/dprog-philippe-docourt/django-qr-code)
  [![Maintainability](https://api.codeclimate.com/v1/badges/c47e79bf51f6a2bb8264/maintainability)](https://codeclimate.com/github/dprog-philippe-docourt/django-qr-code/maintainability)
  [![Coverage Status](https://coveralls.io/repos/github/dprog-philippe-docourt/django-qr-code/badge.svg?branch=master)](https://coveralls.io/github/dprog-philippe-docourt/django-qr-code?branch=master)

  This is an application that provides tools for displaying QR codes on your [Django](https://www.djangoproject.com/) site.

  This application depends on the [Segno QR Code generator](https://pypi.org/project/segno/) library.

  This app makes no usage of the Django models and therefore do not use any database.

  Only Python >= 3.7 is supported.




  In order to use this app in a Django project, the simplest way is to install it from [PyPi](https://pypi.python.org/pypi/django-qr-code):
  ```bash
  pip install django-qr-code
  ```


  In order to modify or test this app you may want to install it from the source code.

  Clone the [GitHub repository](https://github.com/dprog-philippe-docourt/django-qr-code) and then run:
  ```bash
  pip install -r requirements.txt -r requirements-dev.txt
  python manage.py collectstatic --no-input
  ```


  Start by adding `qr_code` to your `INSTALLED_APPS` setting like this:
  ```python
  INSTALLED_APPS = (
      
      'qr_code',
  )
  ```

  You need to load the tags provided by this app in your template with:
  ```djangotemplate
  {% load qr_code %}
  ```

  The source code on [GitHub](https://github.com/dprog-philippe-docourt/django-qr-code) contains a simple demo app. Please check out the [templates folder](https://github.com/dprog-philippe-docourt/django-qr-code/tree/master/qr_code_demo/templates/qr_code_demo) for an example of template, and the [setting](https://github.com/dprog-philippe-docourt/django-qr-code/tree/master/demo_site/settings.py) and [urls](https://github.com/dprog-philippe-docourt/django-qr-code/tree/master/demo_site/urls.py) files for an example of configuration and integration.


  The tag **`qr_from_text`** generates an embedded `svg` or `img` tag within the HTML code produced by your template.

  The following renders a tiny "hello world" QR code with a `svg` tag:
  ```djangotemplate
  {% qr_from_text "Hello World!" size="T" %}
  ```
  Here is a medium "hello world" QR code with an `img` tag:
  ```djangotemplate
  {% qr_from_text "Hello World!" size="m" image_format="png" error_correction="L" %}
  ```



  The `size` parameter gives the size of each module of the QR code matrix. It can be either a positive integer or one of the following letters:

  * t or T: tiny (value: 6)
  * s or S: small (value: 12)
  * m or M: medium (value: 18)
  * l or L: large (value: 30)
  * h or H: huge (value: 48)

  For PNG image format the size unit is in pixels, while the unit is 1 mm for SVG format.

  Here is a "hello world" QR code using the version 12:
  ```djangotemplate
  {% qr_from_text "Hello World!" size=8 version=12 %}
  ```
  The `version` parameter is an integer from 1 to 40 that controls the size of the QR code matrix. Set to None to determine this automatically. The smallest, version 1, is a 21 x 21 matrix. The biggest, version 40, is 177 x 177 matrix. The size grows by 4 modules/side.

  Here is a "hello world" QR code using a border of 6 modules:
  ```djangotemplate
  {% qr_from_text "Hello World!" size=10 border=6 %}
  ```
  The `border` parameter controls how many modules thick the border should be (the default is 4, which is the minimum according to the specs).

  There are 4 error correction levels used for QR codes, with each one adding different amounts of "backup" data
  depending on how much damage the QR code is expected to suffer in its intended environment, and hence how much
  error correction may be required. The correction level can be configured with the `error_correction` parameter as follows:
  * l or L: error correction level L – up to 7% damage
  * m or M: error correction level M – up to 15% damage
  * q or Q: error correction level Q – up to 25% damage
  * h or H: error correction level H – up to 30% damage

  You may enforce the creation of a Micro QR Code with `micro=True`. The `micro` option defaults to `False`.

  The `encoding` option controls the text encoding used in mode "byte" (used for any general text content). By default `encoding` is ``UTF-8``. When set to ``None``, the implementation (based on Segno) tries to use the standard conform ISO/IEC 8859-1 encoding and if it does not fit, it will use UTF-8. Note that no ECI mode indicator is inserted by default (see `eci` option). The `encoding` parameter is case-insensitive.

  The `boost_error` indicates whether the QR code encoding engine (Segno) tries to increase the error correction level if it does not affect the version. Error correction level is not increased when it impacts the version of the code.

  The `eci` option indicates if binary data which does not use the default encoding (ISO/IEC 8859-1) should enforce the ECI mode. Since a lot of QR code readers do not support the ECI mode, this feature is disabled by default and the data is encoded in the provided encoding using the usual “byte” mode. Set eci to `True` if an ECI header should be inserted into the QR Code. Note that the implementation may not know the ECI designator for the provided encoding and may raise an exception if the ECI designator cannot be found. The ECI mode is not supported by Micro QR Codes.

  Alternatively, you may use the `options` keyword argument with an instance of `QRCodeOptions` as value instead of listing every requested options. Here is an example of view:
  ```python
  from django.shortcuts import render
  from qr_code.qrcode.utils import QRCodeOptions

  def my_view(request):
      
      context = dict(
          my_options=QRCodeOptions(size='t', border=6, error_correction='L'),
      )

      
      return render(request, 'my_app/my_view.html', context=context)
  ```

  and an example of template for the view above:
  ```djangotemplate
  {% qr_from_text "Hello World!" options=my_options %}
  ```


  The **`qr_url_from_text`** tag generates an url to an image representing the QR code. It comes with the same options as `qr_from_text` to customize the image format (SVG or PNG), the size, the border, and the matrix size. It also has an additional option **`cache_enabled`** to disable caching of served image.

  Here is a medium "hello world" QR code that uses an URL to serve the image in SVG format:

  ```djangotemplate
  <img src="{% qr_url_from_text "Hello World!" %}" alt="Hello World!">
  ```

  Here is a "hello world" QR code in version 10 that uses an URL to serve the image in PNG format:

  ```djangotemplate
  <img src="{% qr_url_from_text "Hello World!" size=8 version=10 image_format='png' %}" alt="Hello World!">
  ```

  The image targeted by the generated URL is served by a view provided in `qr_code.urls`. Therefore, you need to include the URLs provided by `qr_code.urls` in your app in order to make this tag work. This can be achieved with something like this:

  ```python
  from django.conf.urls import include
  from django.urls import path

  urlpatterns = [
      path('qr_code/', include('qr_code.urls', namespace="qr_code")),
  ]
  ```

  The QR code images are served via a URL named **`qr_code:serve_qr_code_image`**. You can customize the path under which the images are served (i.e. the path bound to the URL named `qr_code:serve_qr_code_image`) with the optional setting **`SERVE_QR_CODE_IMAGE_PATH`** which defaults to `images/serve-qr-code-image/`. Note that the trailing slash is mandatory and that defining this setting to an empty string leads to using the default value. The example below will serve any QR code image from `<base URL or your application>/qr-code-image/`:

  ```python

  from django.conf.urls import include
  from django.urls import path

  urlpatterns = [
      path('', include('qr_code.urls', namespace='qr_code')),
  ]


  SERVE_QR_CODE_IMAGE_PATH = 'qr-code-image/'
  ```



  If you do not want to use Django tags for rendering QR code in a template, you can simply use the API in your code. For instance, `qr_code.qrcode.maker.make_qr_code_image` will return bytes representing an image according to the image_format passed in the `qr_code_options` parameter.


  The tags **`qr_from_data`** and  **`qr_url_from_data`** produce results similar to those of `qr_from_text` and `qr_url_from_text`, but they avoid converting everything to text (UTF-8 encoded by default, or any supported charset depending on `encoding` option).

  The ISO/IEC 18004 standard defines four modes in order to encode the data as efficiently as possible.


  The numeric mode is the most efficient way to encode digits. This mode does not cover negative numbers because it does not support the minus sign (or plus sign).

  The numeric mode is supported by QR Codes and Micro QR Codes. The encoding engine detects (Segno) the numeric mode if the data is provided as string (e.g. '54') or integer (e.g. 54) to `qr_from_data` or `qr_url_from_data`.


  The alphanumeric mode extends the numeric mode by various characters. Namely, about the upper case letters ABCDEFGHIJKLMNOPQRSTUVWXYZ, a space character " " and other letters $%*+-./:.


  Kanji can be encoded compactly and efficiently and requires significantly less space than encoding the characters in UTF-8.


  The byte mode covers all data which cannot be represented by the other modes. When the `encoding` option is set to `None`, the encoding engine (Segno) detects, according to ISO/IEC 18004, to encode the data with ISO 8859-1. In case the data cannot be represented by ISO 8859-1, UTF-8 is used as fallback.

  NOTE: When using `qr_from_text` or `qr_url_from_text`, the byte mode with UTF-8 encoding is forced by default . You may use the `encoding` option to change this behavior. It appears to be one of the most portable way of encoding text for proper decoding among the readers.


  The following renders a tiny numeric QR code containing the value `2021` with a `svg` tag:
  ```djangotemplate
  {% qr_from_data 2021 size="T" %}
  ```

  Here is a micro QR code with an `img` tag containing the value `2021`:
  ```djangotemplate
  {% qr_from_data 2021 micro=True image_format="png" %}
  ```



  A large QR code (version 40) requires 0.2 second to be generated on a powerful machine (in 2018), and probably more than half a second on a really cheap hosting.

  The image served by the *qr_code* app can be cached to improve performances and reduce CPU usage required to generate the QR codes. In order to activate caching, you simply need to declare a cache alias with the setting **`QR_CODE_CACHE_ALIAS`** to indicate in which cache to store the generated QR codes.

  For instance, you may declare an additional cache for your QR codes like this in your Django settings:
  ```python
  CACHES = {
      'default': {
          'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
      },
      'qr-code': {
          'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
          'LOCATION': 'qr-code-cache',
          'TIMEOUT': 3600
      }
  }

  QR_CODE_CACHE_ALIAS = 'qr-code'
  ```

  The `QR_CODE_CACHE_ALIAS = 'qr-code'` tells the *qr_code* app to use that cache for storing the generated QR codes. All QR codes will be cached with the specified *TIMEOUT* when a non-empty value is set to `QR_CODE_CACHE_ALIAS`.

  If you want to activate the cache for QR codes, but skip the caching for some specific codes, you can use the keyword argument `cache_enabled=False` when using `qr_url_from_text`.

  Here is a "hello world" QR code in version 20 with an error correction level Q (25% of redundant data) that uses a URL to serve the image in SVG format, and disable caching for served image:
  ```djangotemplate
  <img src="{% qr_url_from_text "Hello World!" size=8 version=20 error_correction="Q" cache_enabled=False %}" alt="Hello World!">
  ```



  The default settings protect the URLs that serve QR code images against external requests, and thus against possibly easy (D)DoS attacks.

  Here are the available settings to manage the protection for served images:
  ```python
  from qr_code.qrcode import constants

  QR_CODE_URL_PROTECTION = {
      constants.TOKEN_LENGTH: 30,                         # Optional random token length for URL protection. Defaults to 20.
      constants.SIGNING_KEY: 'my-secret-signing-key',     # Optional signing key for URL token. Uses SECRET_KEY if not defined.
      constants.SIGNING_SALT: 'my-signing-salt',          # Optional signing salt for URL token.
      constants.ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER: True  # Tells whether a registered user can request the QR code URLs from outside a site that uses this app. It can be a boolean value used for any user or a callable that takes a user as parameter. Defaults to False (nobody can access the URL without the signature token).
  }
  ```



  By default, the application only serves QR code images for authenticated URLs (requests generated from your application and addressed to your application). The authentication uses a HMAC to sign the request query arguments. The authentication code is passed as a query argument named **`token`** which is automatically generated by `qr_url_from_text`  or `qr_url_from_data`. Whenever the signature is invalid, the application returns a *HTTP 403 Permission denied* response when processing the request for serving a QR code image.

  This mechanism ensures that, by default, nobody can send external requests to your application to obtain custom QR codes for free. This is especially useful if you display QR code URLs on public pages (no user authentication).

  The `token` query argument is not mandatory and, when a request reaches the `qr_code:serve_qr_code_image` URL without that token, the protection mechanism falls back to the user authentication mechanism (see chapter below).

  It is possible to explicitly remove the  signature token that protects a specific URL with the parameter **`url_signature_enabled=False`**. Here is a "hello world" QR code that uses a URL to serve the image in SVG format without the `token` query argument :

  ```djangotemplate
  <img src="{% qr_url_from_text "Hello World!" url_signature_enabled=False %}" alt="Hello World!">
  ```

  The `token` parameter will not be part of the query string of the generated URL, making possible to build a simpler, predictable URL. However, this will trigger the user authentication mechanism (see chapter below).



  If you are interested in providing the QR code images as a service, there is a setting named **`ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER`** to grant access to some controlled users. This setting tells who can bypass the url signature token (see chapter above). It can be a boolean value used for any authenticated user, or a callable that takes a user as only parameter.

  Setting the `ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER` option to `True` tells the application to serve QR code images to authenticated users only. Hence, to grant access to any authenticated user to generated images, you can use this in your settings:

  ```python
  from qr_code.qrcode import constants

  QR_CODE_URL_PROTECTION = {
      constants.ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER: True
  }
  ```

  Setting the option `ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER` to a callable that always returns `True` (even for anonymous users) will allow anyone to access QR code image generation from outside your Django app. The following settings will grant access to anonymous users to generated images:

  ```python
  from qr_code.qrcode import constants

  QR_CODE_URL_PROTECTION = {
      constants.ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER: lambda u: True
  }
  ```

  Please note that, if your service is available on the Internet, allowing anyone to generate any kind of QR code via your Django application - as shown above - might generate a very heavy load on your server.



  Aside from generating a QR code from a given text, you can also generate codes for specific application purposes, that a reader can interpret as an action to take: open a mail client to send an e-mail to a given address, add a contact to your phone book, connect to a Wi-Fi, start a SMS, etc.  See [this documentation](https://github.com/zxing/zxing/wiki/Barcode-Contents) about what a QR code can encode.

  Django QR Code proposes several utility tags to ease the generation of such codes, without having to build the appropriate text representation for each action you need. This remove the hassle of reading the specifications and handling all the required escaping for reserved chars.

  Please note that some commands are common patterns, rather than formal specifications. Therefore, there is no guarantee that all QR code readers will handle them properly.

  The following tags targeting apps are available:
  * `qr_for_email` and `qr_url_for_email`
  * `qr_for_tel` and `qr_url_for_tel`
  * `qr_for_sms` and `qr_url_for_sms`
  * `qr_for_geolocation` and `qr_url_for_geolocation`
  * `qr_for_google_maps` and `qr_url_for_google_maps`
  * `qr_for_youtube` and `qr_url_for_youtube`
  * `qr_for_google_play` and `qr_url_for_google_play`
  * `qr_for_mecard` and `qr_url_for_mecard`
  * `qr_for_vcard` and `qr_url_for_vcard`
  * `qr_for_wifi` and `qr_url_for_wifi`
  * `qr_for_epc` and `qr_url_for_epc`
  * `qr_for_event` and `qr_url_for_event`
  * `qr_for_contact` and `qr_url_for_contact` (legacy, do not use in new projects)

  You could write a view like this:

  ```python
  import datetime
  from datetime import date
  from django.shortcuts import render
  from qr_code.qrcode.utils import MeCard, VCard, EpcData, VEvent, EventClass, EventTransparency, EventStatus, WifiConfig, Coordinates, QRCodeOptions


  def application_qr_code_demo(request):
      
      mecard_contact = MeCard(
          name='Doe, John',
          phone='+41769998877',
          email='j.doe@company.com',
          url='http://www.company.com',
          birthday=date(year=1985, month=10, day=2),
          memo='Development Manager',
          org='Company Ltd'
      )

      
      vcard_contact = VCard(
          name='Doe; John',
          phone='+41769998877',
          email='j.doe@company.com',
          url='http://www.company.com',
          birthday=date(year=1985, month=10, day=2),
          street='Cras des Fourches 987',
          city='Delémont',
          zipcode=2800,
          region='Jura',
          country='Switzerland',
          memo='Development Manager',
          org='Company Ltd'
      )

      
      wifi_config = WifiConfig(
          ssid='my-wifi',
          authentication=WifiConfig.AUTHENTICATION.WPA,
          password='wifi-password'
      )

      
      epc_data = EpcData(
          name='Wikimedia Foerdergesellschaft',
          iban='DE33100205000001194700',
          amount=50.0,
          text='To Wikipedia'
      )

      
      google_maps_coordinates = Coordinates(latitude=586000.32, longitude=250954.19)
      geolocation_coordinates = Coordinates(latitude=586000.32, longitude=250954.19, altitude=500)

      
      
      
      
      event = VEvent(
          uid="some-event-id",
          summary="Vacations",
          start=datetime.datetime(2022, 8, 6, hour=8, minute=30),
          end=datetime.datetime(2022, 8, 17, hour=12),
          location="New-York, Statue de la Liberté",
          geo=(40.69216097988203, -74.04460073403436),
          categories=["PERSO", "holidays"],
          status=EventStatus.CONFIRMED,
          event_class=EventClass.PRIVATE,
          transparency=EventTransparency.OPAQUE,
          organizer="foo@bar.com",
          url="https://bar.com",
          description="""Fake description. Meeting to provide technical review for "Phoenix" design. Happy Face Conference Room.

  Phoenix design team MUST attend this meeting.

  RSVP to team leader."""
      )

      
      context = dict(
          mecard_contact=mecard_contact,
          vcard_contact=vcard_contact,
          wifi_config=wifi_config,
          epc_data=epc_data,
          event=event,
          video_id='J9go2nj6b3M',
          google_maps_coordinates=google_maps_coordinates,
          geolocation_coordinates=geolocation_coordinates,
          options_example=QRCodeOptions(size='t', border=6, error_correction='L'),
      )

      
      return render(request, 'my_app/application_qr_code_demo.html', context=context)
  ```

  Then, in your template, you can render the appropriate QR codes for the given context:
  ```djangotemplate
  <h3>Add contact '{{ mecard_contact.name }}' to phone book</h3>
  {% qr_for_mecard mecard=mecard_contact size='S' %}
  <p>or:</p>
  {% qr_for_contact mecard_contact size='S' %}
  <p>or:</p>
  {% qr_for_contact mecard_contact options=options_example %}

  <h3>Add contact '{{ vcard_contact.name }}' to phone book</h3>
  {% qr_for_vcard vcard=vcard_contact size='S' %}
  <p>or:</p>
  {% qr_for_contact vcard_contact size='S' %}
  <p>or:</p>
  {% qr_for_contact vcard_contact options=options_example %}

  <h3>Configure Wi-Fi connexion to '{{ wifi_config.ssid }}'</h3>
  <img src="{% qr_url_for_wifi wifi_config=wifi_config size='T' error_correction='Q' %}">
  <p>or:</p>
  <img src="{% qr_url_for_wifi wifi_config size='T' error_correction='Q' %}">
  <p>or:</p>
  <img src="{% qr_url_for_wifi wifi_config options=options_example %}">

  <h3>EPC QR Code'</h3>
  <img src="{% qr_url_for_epc epc_data=epc_data %}">
  <p>or:</p>
  <img src="{% qr_url_for_epc epc_data size='H' %}">

  <h3>Event QR Code'</h3>
  <img src="{% qr_url_for_event event=event %}">
  <p>or:</p>
  {% qr_for_event event=event %}

  <h3>Watch YouTube video '{{ video_id }}'</h3>
  {% qr_for_youtube video_id image_format='png' size='T' %}
  <p>or:</p>
  {% qr_for_youtube video_id options=options_example %}

  <h3>Open map at location: ({{ geolocation_coordinates }})</h3>
  <img src="{% qr_url_for_geolocation coordinates=geolocation_coordinates %}">
  <p>or:</p>
  <img src="{% qr_url_for_geolocation latitude=geolocation_coordinates.latitude longitude=geolocation_coordinates.longitude altitude=geolocation_coordinates.altitude %}">
  <p>or:</p>
  <img src="{% qr_url_for_geolocation latitude=geolocation_coordinates.latitude longitude=geolocation_coordinates.longitude altitude=geolocation_coordinates.altitude options=options_example %}">

  <h3>Open Google Maps App at location: ({{ google_maps_coordinates }})</h3>
  {% qr_for_google_maps coordinates=google_maps_coordinates %}
  <p>or:</p>
  {% qr_for_google_maps latitude=google_maps_coordinates.latitude longitude=google_maps_coordinates.longitude %}
  <p>or:</p>
  {% qr_for_google_maps latitude=google_maps_coordinates.latitude longitude=google_maps_coordinates.longitude options=options_example %}
  ```

  Please check out the [demo application](#demo-application) to see more examples.




  The SVG is the default image format. It is a vector image format so it can be scaled up and down without quality loss. However, it has two drawbacks. The size is not given in pixel, which can be problematic if the design of your website relies on a fixed width (in pixels). The format is less compact than PNG and results in a larger HTML content. Note that a base64 PNG is less compressible than a SVG tag, so it might not matter that much of you use HTML compression on your web server.

  SVG has [broad support](http://caniuse.com/#feat=svg) now, and it will work properly on any modern web browser.


  The tag `qr_url_from_text` has several advantages over `qr_from_text`, despite the fact that it requires a bit more of writing:
  * the generated HTML code does not contain heavy inline image data (lighter and cleaner content)
  * the generated images can be cached (served with a separate HTML request)
  * the HTML tag used to render the QR code is always an `<img>` tag, which may simplify CSS handling
  * the HTML tag embedding the image is not generated for you, which allows for customization of attributes (*height*, *width*, *alt*)
  * the page can be loaded asynchronously, which improves responsiveness
  * you can provide links to QR codes instead of displaying them, which is not possible with `qr_from_text`

  One disadvantage of `qr_url_from_text` is that it increases the number of requests to the server: one request to serve the page containing the URL and another to request the image.

  Be aware that serving image files (which are generated on the fly) from a URL can be abused and lead to (D)DoS attack pretty easily, for instance by requesting very large QR codes from outside your application. This is the reason why the associated setting `ALLOWS_EXTERNAL_REQUESTS_FOR_REGISTERED_USER` in `QR_CODE_URL_PROTECTION` defaults to completely forbid external access to the API. Be careful when opening external access.


  Caching QR codes reduces CPU usage, but the usage of `qr_url_from_text` (which caching depends on) increases the number of requests to the server (one request to serve the page containing the URL and another to request the image).

  Moreover, be aware that the largest QR codes, in version 40 with a border of 4 modules and rendered in SVG format, have a size of ~800 KB.
  Be sure that your cache options are reasonable and can be supported by your server(s), especially for in-memory caching.

  Note that even without caching the generated QR codes, the app will return a *HTTP 304 Not Modified* status code whenever the same QR code is requested again. The URL named **`qr_code:serve_qr_code_image`** adds the `ETag` and `Last-Modified` headers to the response if the headers aren't already set, enabling  *HTTP 304 Not Modified* response upon following requests.


  If you want to try this app, you may want to use the demo application shipped alongside the source code.

  Get the source code from [GitHub](https://github.com/dprog-philippe-docourt/django-qr-code), follow the [installation instructions](#from-the-source-code) above, and run the `runserver` command of Django:
  ```bash
  python manage.py runserver
  ```
  The demo application should be running at <http://127.0.0.1:8000/qr-code-demo/>.

  If you have [Docker Compose](https://docs.docker.com/compose/) installed, you can simply run the following from a terminal (this will save you the burden of setting up a proper python environment):
  ```bash
  cd scripts
  ./run-demo-app.sh
  ```
  The demo application should be running at <http://127.0.0.1:8910/qr-code-demo/>.


  Get the source code from [GitHub](https://github.com/dprog-philippe-docourt/django-qr-code), follow the [installation instructions](#from-the-source-code) above, and run the `test` command of Django:
  ```bash
  python manage.py test
  ```
  This will run the test suite with the locally installed version of Python and Django.

  If you have [Docker Compose](https://docs.docker.com/compose/) installed, you can simply run the following from a terminal (this will save you the burden of setting up a proper python environment):
  ```bash
  cd scripts
  ./run-tests.sh
  ```
  This will run the test suite with all supported versions of Python and Django. The test results are stored within `tests_result` folder.



  This app is used in the following projects:
  * [MyGym Web](https://mygym-web.ch/): a web platform for managing sports clubs. The QR codes are used for importing members' contact information in a phone book.
  * [Gymna-Score](https://gymna-score.acjg.ch/): a web platform for entering scores during gymnastics competitions organized by the Association Cantonale Jurassienne de Gymnastique (ACJG). The QR codes are used to provide an easy way for the public to follow an ongoing competition. They are also used to authenticate judges that need to enter scores.
  * [AC-Ju](https://www.ac-ju.ch/): a website that generates digital vouchers that can be redeemed at affiliate merchants.


pkgId: 628456244f65bf4dcd54586e3fd9a84efc1f8fe20af8affc21a82f62071897d0
name: python-django-recaptcha
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Django recaptcha form field/widget app.
url: https://github.com/torchbox/django-recaptcha
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-129f3a47-a798-4a32-b200-b032a0e662c0
location_href: 00011864-python-django-recaptcha/python-django-recaptcha-3.0.0-1.src.rpm
checksum_type: sha256
description:
  **Django reCAPTCHA form field/widget integration app.**
     django-recaptcha supports Google reCAPTCHA V2 - Checkbox (Default), Google reCAPTCHA V2 - Invisible and Google reCAPTCHA V3 please look at the widgets section for more information.
     Django reCAPTCHA uses a modified version of the `Python reCAPTCHA client <http://pypi.python.org/pypi/recaptcha-client>`_ which is included in the package as ``client.py``.


pkgId: 49a696baea7c05fe57202f5061c3f9c863d70ceec11ea30265602ff74e6dbd55
name: python-django-redis-sessions
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Redis Session Backend For Django
url: http://github.com/martinrusev/django-redis-sessions
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b4a055aa-8979-4567-aea5-3581c784dcf5
location_href: 00012149-python-django-redis-sessions/python-django-redis-sessions-0.6.2-1.src.rpm
checksum_type: sha256
description:
  Redis database backend for your sessions
  |Build Status|
  -  `Installation`_
  -  `Available Settings`_
  -  `Changelog`_


pkgId: 331195260cde1d05f711280a320e7f860e28a7713c3da4e6ac1a9411ddbcfacf
name: python-django-registration
arch: src
version: 3.3
epoch: 0
release: 1
summary: An extensible user-registration application for Django
url: https://github.com/ubernostrum/django-registration/
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-87438904-7aa1-4f24-9e98-571e7707ad6a
location_href: 00003483-python-django-registration/python-django-registration-3.3-1.src.rpm
checksum_type: sha256
description:
  .. -*-restructuredtext-*-

  .. image:: https://github.com/ubernostrum/django-registration/workflows/CI/badge.svg
     :alt: CI status image
     :target: https://github.com/ubernostrum/django-registration/actions?query=workflow%3ACI

  This is a user-registration application for `Django
  <https://www.djangoproject.com/>`_. There are two registration
  workflows (one-step, and two-step with activation) built in, and it's
  designed to be extensible and support building additional workflows.

  To get started, check out `the documentation
  <https://django-registration.readthedocs.io/>`_.


pkgId: 2cce6ab056f0d0cf030f987e3a750838def34a23eeb27ce7f0be3644ecc2693e
name: python-django-request-logging
arch: src
version: 0.7.5
epoch: 0
release: 1
summary: Django middleware that logs http request body.
url: https://github.com/Rhumbix/django-request-logging.git
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-376f77f3-f704-4212-8860-3b8473abfbff
location_href: 00012570-python-django-request-logging/python-django-request-logging-0.7.5-1.src.rpm
checksum_type: sha256
description:
  Plug django-request-logging into your Django project and you will have intuitive and color coded request/response payload logging, for both web requests and API requests. Supports Django 1.8+.

  ```bash
  $ pip install django-request-logging
  ```
  Then add ```request_logging.middleware.LoggingMiddleware``` to your ```MIDDLEWARE```.
  For example:
  ```python
  MIDDLEWARE = (
      'request_logging.middleware.LoggingMiddleware',
  )
  ```
  And configure logging in your app:
  ```python
  LOGGING = {
      'version': 1,
      'disable_existing_loggers': False,
      'handlers': {
          'console': {
              'class': 'logging.StreamHandler',
          },
      },
      'loggers': {
          'django.request': {
              'handlers': ['console'],
              'level': 'DEBUG',  # change debug level as appropiate
              'propagate': False,
          },
      },
  }
  ```

  Most of the times you don't have to care about these details. But in case you need to dig deep:
  * All logs are configured using logger name "django.request".
  * If HTTP status code is between 400 - 599, URIs are logged at ERROR level, otherwise they are logged at INFO level.
  * If HTTP status code is between 400 - 599, data are logged at ERROR level, otherwise they are logged at DEBUG level.
  See `REQUEST_LOGGING_HTTP_4XX_LOG_LEVEL` setting to override this.
  A `no_logging` decorator is included for views with sensitive data. This decorator allows control over logging behaviour of single views via the following parameters:
  ```
  * value
      * False: the view does NOT log any activity at all (overrules settings of log_headers, log_body, log_response and automatically sets them to False).
      * True: the view logs incoming requests (potentially log headers, body and response, depending on their specific settings)
      * None: NO_LOGGING_DEFAULT_VALUE is used (can be defined in settings file as DJANGO_REQUEST_LOGGING_NO_LOGGING_DEFAULT_VALUE)
  * msg
      * Reason for deactivation of logging gets logged instead of request itself (only if silent=True and value=False)
      * NO_LOGGING_MSG is used by default
  * log_headers
      * False: request headers will not get logged
      * True: request headers will get logged (if value is True)
      * None: LOG_HEADERS_DEFAULT_VALUE is used (can be defined in settings file as DJANGO_REQUEST_LOGGING_LOG_HEADERS_DEFAULT_VALUE)
  * no_header_logging_msg
      * Reason for deactivation of header logging gets logged instead of headers (only if silent=True and log_headers=False)
      * NO_HEADER_LOGGING_MSG is used by default
  * log_body
      * False: request body will not get logged
      * True: request headers will get logged (if value is True)
      * None: LOG_BODY_DEFAULT_VALUE is used (can be defined in settings file as DJANGO_REQUEST_LOGGING_LOG_BODY_DEFAULT_VALUE)
  * no_body_logging_msg
      * Reason for deactivation of body logging gets logged instead of body (only if silent=True and log_body=False)
      * NO_BODY_LOGGING_MSG is used by default
  * log_response
      * False: response will not get logged
      * True: response will get logged (if value is True)
      * None: LOG_RESPONSE_DEFAULT_VALUE is used (can be defined in settings file as DJANGO_REQUEST_LOGGING_LOG_RESPONSE_DEFAULT_VALUE)
  * no_response_logging_msg
      * Reason for deactivation of body logging gets logged instead of body (only if silent=True and log_body=False)
      * NO_RESPONSE_LOGGING_MSG is used by default
  * silent
      * True: deactivate logging of alternative messages case parts of the logging are deactivated (request/header/body/response)
      * False: alternative messages for deactivated parts of logging (request/header/body/response) are logged instead
  ```
  By default, value of Http headers `HTTP_AUTHORIZATION` and `HTTP_PROXY_AUTHORIZATION` are replaced wih `*****`. You can use `REQUEST_LOGGING_SENSITIVE_HEADERS` setting to override this default behaviour with your list of sensitive headers.

  You can customized some behaves of django-request-logging by following settings in Django `settings.py`.

  By default, data will log in DEBUG level, you can change to other valid level (Ex. logging.INFO) if need.

  It's enabled by default. If you want to log into log file instead of console, you may want to remove ANSI color. You can set `REQUEST_LOGGING_ENABLE_COLORIZE=False` to disable colorize.

  This legacy setting will still available, but you should't use this setting anymore. You should use `REQUEST_LOGGING_ENABLE_COLORIZE` instead.
  We keep this settings for backward compatibility.

  By default, max length of a request body and a response content is cut to 50000 characters.

  By default, HTTP status codes between 400 - 499 are logged at ERROR level.  You can set `REQUEST_LOGGING_HTTP_4XX_LOG_LEVEL=logging.WARNING` (etc) to override this.
  If you set `REQUEST_LOGGING_HTTP_4XX_LOG_LEVEL=logging.INFO` they will be logged the same as normal requests.

  The value of the headers defined in this settings will be replaced with `'*****'` to hide the sensitive information while logging. By default it is set as `REQUEST_LOGGING_SENSITIVE_HEADERS = ["HTTP_AUTHORIZATION", "HTTP_PROXY_AUTHORIZATION"]`

  Name of the logger that is used to log django.request occurrances with the new LoggingMiddleware. Defaults to "django.request".

  Global default to activate/deactivate logging of all views. Can be overruled for each individual view by using the @no_logging decator's "value" parameter.

  Global default to activate/deactivate logging of request headers for all views. Can be overruled for each individual view by using the @no_logging decator's "log_headers" parameter.

  Global default to activate/deactivate logging of request bodys for all views. Can be overruled for each individual view by using the @no_logging decator's "log_body" parameter.

  Global default to activate/deactivate logging of responses for all views. Can be overruled for each individual view by using the @no_logging decator's "log_response" parameter.


  Use `pyenv` to maintain a set of virtualenvs for 2.7 and a couple versions of Python 3.
  Make sure the `requirements-dev.txt` installs for all of them, at least until we give up on 2.7.
  At that point, update this README to let users know the last version they can use with 2.7.

  - `pip install twine pypandoc pbr wheel`
  - If `pypandoc` complains that `pandoc` isn't installed, you can add that via `brew` if you have Homebrew installed
  - You will need a `.pypirc` file in your user root folder that looks like this:
  ```
      index-servers=
          testpypi
          pypi
      [testpypi]
      username = rhumbix
      password = password for dev@rhumbix.com at Pypi
      [pypi]
      username = rhumbix
      password = password for dev@rhumbix.com at Pypi
  ```

  - Bump the version value in `request_logging/__init__.py`
  - Run `python setup.py publish`
  - Manually tag per the instructions in the output of that command
  - TODO: add automagic `git tag` logic to the publish process
  - TODO: setup 2FA at Pypi


pkgId: 9e714540913570222922bfb275ee58a4160ddc37554e73664405c91640da3e40
name: python-django-rest-knox
arch: src
version: 4.2.0
epoch: 0
release: 1
summary: Authentication for django rest framework
url: https://github.com/James1345/django-rest-knox
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-07bc300a-2add-48bf-82d1-7bcb35958a05
location_href: 00012264-python-django-rest-knox/python-django-rest-knox-4.2.0-1.src.rpm
checksum_type: sha256
description:
  [![image](https://github.com/James1345/django-rest-knox/workflows/Test/badge.svg?branch=develop)](https://github.com/James1345/django-rest-knox/actions)
  Authentication Module for django rest auth
  Knox provides easy to use authentication for [Django REST
  Framework](https://www.django-rest-framework.org/) The aim is to allow
  for common patterns in applications that are REST based, with little
  extra effort; and to ensure that connections remain secure.
  Knox authentication is token based, similar to the `TokenAuthentication`
  built in to DRF. However, it overcomes some problems present in the
  default implementation:
  -   DRF tokens are limited to one per user. This does not facilitate
      securely signing in from multiple devices, as the token is shared.
      It also requires *all* devices to be logged out if a server-side
      logout is required (i.e. the token is deleted).
      Knox provides one token per call to the login view - allowing each
      client to have its own token which is deleted on the server side
      when the client logs out.
      Knox also provides an option for a logged in client to remove *all*
      tokens that the server has - forcing all clients to re-authenticate.
  -   DRF tokens are stored unencrypted in the database. This would allow
      an attacker unrestricted access to an account with a token if the
      database were compromised.
      Knox tokens are only stored in a secure hash form (like a password). Even if the
      database were somehow stolen, an attacker would not be able to log
      in with the stolen credentials.
  -   DRF tokens track their creation time, but have no inbuilt mechanism
      for tokens expiring. Knox tokens can have an expiry configured in
      the app settings (default is 10 hours.)
  More information can be found in the
  [Documentation](https://james1345.github.io/django-rest-knox/)

  If you need to debug a test locally and if you have [docker](https://www.docker.com/) installed:
  simply run the ``./docker-run-tests.sh`` script and it will run the test suite in every Python /
  Django versions.
  You could also simply run regular ``tox`` in the root folder as well, but that would make testing the matrix of
  Python / Django versions a bit more tricky.

  Our documentation is generated by [Mkdocs](https://www.mkdocs.org).
  You can refer to their documentation on how to install it locally.
  Another option is to use `mkdocs.sh` in this repository.
  It will run mkdocs in a [docker](https://www.docker.com/) container.
  Running the script without any params triggers the `serve` command.
  The server is exposed on localhost on port 8000.
  To configure the port the `serve` command will be exposing the server to, you
  can use the following env var:
  ```
  MKDOCS_DEV_PORT="8080"
  ```
  You can also pass any `mkdocs` command like this:
  ```
  ./mkdocs build
  ./mkdocs --help
  ```
  Check the [Mkdocs documentation](https://www.mkdocs.org/) for more.


