# packages

pkgId: 6d073407721bc3e2bd01707f696775a93ed20a3c35e129e4e385431146c708e8
name: python-fastnumbers
arch: src
version: 5.0.1
epoch: 0
release: 1
summary: Super-fast and clean conversions to numbers.
url: https://github.com/SethMMorton/fastnumbers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-eef1e9fb-6de3-433d-8ffb-043533ee2350
location_href: 00013011-python-fastnumbers/python-fastnumbers-5.0.1-1.src.rpm
checksum_type: sha256
description:
  Super-fast and clean conversions to numbers.
      - Source Code: https://github.com/SethMMorton/fastnumbers
      - Downloads: https://pypi.org/project/fastnumbers/
      - Documentation: https://fastnumbers.readthedocs.io/
      - `Quick Start`_
      - `Timing`_
      - `High-level Algorithm`_
      - `How To Run Tests`_
      - `History`_
  ``fastnumbers`` is a module with the following three objectives (in order
  of decreasing importance as to why the module was created):
      
         ``int`` and ``float`` and provides easy, concise, powerful, fast
         and flexible error handling.
      
         an input *could* be converted to *int* or *float*.
      
         ``float`` that are on par or faster with the Python equivalents
         (see the `Timing`_ section for details). These functions
         should behave *identically* to the Python built-ins except for a few
         specific corner-cases as mentioned in the
         `API documentation for those functions <https://fastnumbers.readthedocs.io/en/stable/api.html#the-built-in-replacement-functions>`_.
         - **PLEASE** read the quick start for these functions to fully
           understand the caveats before using them.
  **What kind of speedups can you expect?** Here are some highlights, but please
  see the `Timing`_ section for the raw data if you want details.
      - Up to 2x faster conversion of strings to integers than the built-in
        ``int()`` function
      - Up to 5x faster conversion of strings to floats than the built-in
        ``float()`` function (possibly greater for very long strings)
      - Up to 10x faster handling of errors during conversion than using
        user-side error handling
      - On top of the above, operations to convert a list of strings
        (with the ``map`` option or ``try_array`` function) is 2x faster
        than the equivalent list comprehension.
  **NOTICE**: As of ``fastnumbers`` version 4.0.0, only Python >= 3.7 is
  supported.
  **NOTICE**: As of ``fastnumbers`` version 4.0.0, the functions ``fast_real``,
  ``fast_float``, ``fast_int``, ``fast_forceint``, ``isreal``, ``isfloat``,
  ``isint``, and ``isintlike`` have been deprecated and are replaced with
  ``try_real``, ``try_float``, ``try_int``, ``try_forceint``, ``check_real``,
  ``check_float``, ``check_int``, and ``check_intlike``, respectively. These
  new functions have more flexible APIs and have names that better reflect
  the intent of the functions. The old functions can still be used (they will
  *never* be removed from ``fastnumbers``), but the new ones should be
  preferred for new development.
  **NOTICE**: As of ``fastnumbers`` version 4.0.0, ``query_type`` now sets
  ``allow_underscores`` to ``False`` by default instead of ``True``.


pkgId: af9a4a350bdc04af3e6dc5b2599c9416544ad01d966f81824c54e8650ece4724
name: python-fastnumbers-debuginfo
arch: aarch64
version: 5.0.1
epoch: 0
release: 1
summary: Debug information for package python-fastnumbers
url: https://github.com/SethMMorton/fastnumbers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-eef1e9fb-6de3-433d-8ffb-043533ee2350
rpm_sourcerpm: python-fastnumbers-5.0.1-1.src.rpm
location_href: 00013011-python-fastnumbers/python-fastnumbers-debuginfo-5.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fastnumbers.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 5487be3040a8e5db35c307e12e6beec50a4af756150933c32aad45e10531725d
name: python-fastnumbers-debugsource
arch: aarch64
version: 5.0.1
epoch: 0
release: 1
summary: Debug sources for package python-fastnumbers
url: https://github.com/SethMMorton/fastnumbers
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-eef1e9fb-6de3-433d-8ffb-043533ee2350
rpm_sourcerpm: python-fastnumbers-5.0.1-1.src.rpm
location_href: 00013011-python-fastnumbers/python-fastnumbers-debugsource-5.0.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fastnumbers.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 6082b764f6c6ed8308b12ed41c0c27609121255fafac03bda8552677c529ed64
name: python-fastprogress
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A nested progress with plotting options for fastai
url: https://github.com/fastai/fastprogress
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c70a1b03-7214-413d-9cd0-8c409b5ec4a7
location_href: 00003608-python-fastprogress/python-fastprogress-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Copyright 2017 onwards, fast.ai. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. A copy of the License is provided in the LICENSE file in this repository.


pkgId: 05f2b2f8786bf4069d8367062a2b3e32f7de90dcc06c8794222edfc5b9adadd6
name: python-fastrlock
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Fast, re-entrant optimistic lock implemented in Cython
url: https://github.com/scoder/fastrlock
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a9f56b05-bb6f-4528-a959-0d58b9a3f5b2
location_href: 00012463-python-fastrlock/python-fastrlock-0.8.1-1.src.rpm
checksum_type: sha256
description:
  This is a C-level implementation of a fast, re-entrant, optimistic lock for CPython.
  It is a drop-in replacement for
  `threading.RLock <https://docs.python.org/3/library/threading.html#threading.RLock>`_.
  FastRLock is implemented in `Cython <http://cython.org>`_ and also provides a C-API
  for direct use from Cython code via ``from fastrlock cimport rlock``.
  Under normal conditions, it is about 10x faster than threading.RLock in Python 2.7
  because it avoids all locking unless two or more threads try to acquire it at the
  same time.  Under congestion, it is still about 10% faster than RLock due to being
  implemented in Cython.
  This is mostly equivalent to the revised RLock implementation in Python 3.2,
  but still faster due to being implemented in Cython.  However, in Python 3.4 and
  later, the ``threading.RLock`` implementation in the stdlib tends to be as fast
  or even faster than the lock provided by this package, when called through the
  Python API.  ``FastRLock`` is still faster also on these systems when called
  through its Cython API from other Cython modules.
  It was initially published as a code recipe here:
  https://code.activestate.com/recipes/577336-fast-re-entrant-optimistic-lock-implemented-in-cyt/
  FastRLock has been used and tested in `Lupa <https://github.com/scoder/lupa>`_ for several years.


pkgId: d255c08453fbea1c9496d6acf23dca10efe3a3101d516557620fa56afacb697c
name: python-fastrlock-debuginfo
arch: aarch64
version: 0.8.1
epoch: 0
release: 1
summary: Debug information for package python-fastrlock
url: https://github.com/scoder/fastrlock
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a9f56b05-bb6f-4528-a959-0d58b9a3f5b2
rpm_sourcerpm: python-fastrlock-0.8.1-1.src.rpm
location_href: 00012463-python-fastrlock/python-fastrlock-debuginfo-0.8.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fastrlock.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 1feebb689e8f65f0fa0d8088a4eca8164d5daf73ba8e4cd46b11deb989a558ea
name: python-fastrlock-debugsource
arch: aarch64
version: 0.8.1
epoch: 0
release: 1
summary: Debug sources for package python-fastrlock
url: https://github.com/scoder/fastrlock
rpm_license: MIT style
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-a9f56b05-bb6f-4528-a959-0d58b9a3f5b2
rpm_sourcerpm: python-fastrlock-0.8.1-1.src.rpm
location_href: 00012463-python-fastrlock/python-fastrlock-debugsource-0.8.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fastrlock.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 2668619ef9dbcf2196a21e615b943e0535b6d00c87653df3f215429c72a595a6
name: python-feather-format
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Simple wrapper library to the Apache Arrow-based Feather File Format
url: http://github.com/wesm/feather
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ebf77e1f-5f96-4be6-8e6e-0dc501720759
location_href: 00012084-python-feather-format/python-feather-format-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Feather efficiently stores pandas DataFrame objects on disk. It depends on the
  Apache Arrow for Python



  ```shell
  pip install feather-format
  ```

  pip users note: ``feather-format`` depends on ``pyarrow`` and may not be
  available on your platform via pip. If that does not work try conda-forge.

  From [conda-forge][1]:

  ```shell
  conda install feather-format -c conda-forge
  ```



  Some features of pandas are not supported in Feather:

  * Non-string column names
  * Row indexes
  * Object-type columns with non-homogeneous data

  [1]: https://conda-forge.github.io


pkgId: 2b1217b17c18ed4f963b680c4c59f18f3961598a3e4a610b85f9da7344afaad2
name: python-featurewiz
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Select Best Features from your data set - any size - now with XGBoost!
url: https://github.com/AutoViML/featurewiz
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-69074651-c171-49a4-b221-c10279785434
location_href: 00012024-python-featurewiz/python-featurewiz-0.2.6-1.src.rpm
checksum_type: sha256
description:
  ![banner](featurewiz_logos.png)
  <p>


  <ol>
  <li><b>featurewiz 2.0 is here. You have two small performance improvements:</li> </b>
  1. SULOV method now has a higher correlation limit of 0.90 as default. This means fewer variables are removed and hence more vars are selected. You can always set it back to the old limit by setting `corr_limit`=0.70 if you want.<br>
  2. Recursive XGBoost algorithm is tighter in that it selects fewer features in each iteration. To see how many it selects, set `verbose` flag to 1. <br>
  The net effect is that the same number of features are selected but they are better at producing more accurate models. Try it out and let us know. </ol>


  <ol>
  <li>featurewiz now has a new input: `skip_sulov` flag is here. You can set it to `True` to skip the SULOV method if needed.</li>
  </ol>


  <ol>
  <li><b>featurewiz now has a "silent" mode which you can set using the "verbose=0" option.</b> It will run silently with no charts or graphs and very minimal verbose output. Hope this helps!<br></li>
  </ol>

  <ol>
  <li><b>featurewiz as of version 0.1.50 or higher has multiple high performance models</b> that you can use to build highly performant models once you have completed feature selection. These models are based on LightGBM and XGBoost and have even Stacking and Blending ensembles. You can find them as functions starting with "simple_" and "complex_" under featurewiz. All the best!<br></li>
  </ol>

  <ol>
  <li><b>featurewiz as of version 0.1.04 or higher can read `feather-format` files at blazing speeds.</b> See example below on how to convert your CSV files to feather. Then you can feed those '.ftr' files to featurewiz and it will read it 10-100X faster!<br></li>
  </ol>

  ![feather_example](feather_example.jpg)
  <ol>
  <li><b>featurewiz now runs at blazing speeds thanks to using GPU's by default.</b> So if you are running a large data set on Colab and/or Kaggle, make sure you turn on the GPU kernels. featurewiz will automatically detect that GPU is turned on and will utilize XGBoost using GPU-hist. That will ensure it will crunch your datasets even faster. I have tested it with a very large data set and it reduced the running time from 52 mins to 1 minute! That's a 98% reduction in running time using GPU compared to CPU!<br></li>
  </ol>

  <ol>
  <li><b>FeatureWiz as of version 0.0.90 or higher is a scikit-learn compatible feature selection transformer.</b> You can perform fit and predict as follows. You will get a Transformer that can select the top variables from your dataset. You can also use it in sklearn pipelines as a Transformer.</li>

  ```
  from featurewiz import FeatureWiz
  features = FeatureWiz(corr_limit=0.70, feature_engg='', category_encoders='',
  dask_xgboost_flag=False, nrows=None, verbose=2)
  X_train_selected = features.fit_transform(X_train, y_train)
  X_test_selected = features.transform(X_test)
  features.features  ### provides the list of selected features ###
  ```

  <li><b>Featurewiz is now upgraded with XGBOOST 1.5.1 for DASK for blazing fast performance</b> even for very large data sets! Set `dask_xgboost_flag = True` to run dask + xgboost.</li>
  <li><b>Featurewiz now runs with a default setting of `nrows=None`.</b> This means it will run using all rows. But if you want it to run faster, then you can change `nrows` to 1000 or whatever, so it will sample that many rows and run.</li>
  <li><b>Featurewiz has lots of new fast model builder functions:</b> that you can use to build highly performant models with the features selected by featurewiz. They are:<br>
  1. <b>simple_LightGBM_model()</b> - simple regression and classification with one target label<br>
  2. <b>simple_XGBoost_model()</b> - simple regression and classification with one target label<br>
  3. <b>complex_LightGBM_model()</b> - more complex multi-label and multi-class models<br>
  4. <b>complex_XGBoost_model()</b> - more complex multi-label and multi-class models<br>
  5. <b>Stacking_Classifier()</b>: Stacking model that can handle multi-label, multi-class problems<br>
  6. <b>Stacking_Regressor()</b>: Stacking model that can handle multi-label, regression problems<br>
  7. <b>Blending_Regressor()</b>: Blending model that can handle multi-label, regression problems<br></li>
  </ol>


  As of June 2022, thanks to [arturdaraujo](https://github.com/arturdaraujo), featurewiz is now available on conda-forge. You can try:<br>

  ```
   conda install -c conda-forge featurewiz
  ```




  ```
   !pip install featurewiz --ignore-installed --no-deps
   !pip install xlrd --ignore-installed --no-deps
  ```



  ```
   !pip install Pillow==9.0.0
  ```


  `featurewiz` a new python library for creating and selecting the best features in your data set fast!
  `featurewiz` can be used in one or two ways. Both are explained below.


  <p>The first step is not absolutely necessary but it can be used to create new features that may or may not be helpful (be careful with automated feature engineering tools!).<p>
  1. <b>Performing Feature Engineering</b>: One of the gaps in open source AutoML tools and especially Auto_ViML has been the lack of feature engineering capabilities that high powered competitions such as Kaggle required. The ability to create "interaction" variables or adding "group-by" features or "target-encoding" categorical variables was difficult and sifting through those hundreds of new features to find best features was difficult and left only to "experts" or "professionals". featurewiz was created to help you in this endeavor.<br>
  <p>featurewiz now enables you to add hundreds of such features with a single line of code. Set the "feature_engg" flag to "interactions", "groupby" or "target" and featurewiz will select the best encoders for each of those options and create hundreds (perhaps thousands) of features in one go. Not only that, using the next step, featurewiz will sift through numerous such variables and find only the least correlated and most relevant features to your model. All in one step!.<br>

  You must use this syntax for feature engg. Otherwise, featurewiz will give an error:

  ```
  import featurewiz as FW
  outputs = FW.featurewiz(dataname=train, target=target, corr_limit=0.70, verbose=2, sep=',',
  		header=0, test_data='',feature_engg='', category_encoders='',
  		dask_xgboost_flag=False, nrows=None)
  ```

  ![feature_engg](feature_engg.jpg)


  <p>The second step is Feature Selection. `featurewiz` uses the MRMR (Minimum Redundancy Maximum Relevance) algorithm as the basis for its feature selection. <br>
  <b> Why do Feature Selection</b>? Once you have created 100's of new features, you still have three questions left to answer:
  1. How do we interpret those newly created features?
  2. Which of these features is important and which are useless? How many of them are highly correlated to each other causing redundancy?
  3. Does the model overfit now on these new features and perform better or worse than before?
  <br>
  All are very important questions and featurewiz answers them by using the SULOV method and Recursive XGBoost to reduce features in your dataset to the best "minimum optimal" features for the model.<br>
  <p><b>SULOV</b>: SULOV stands for `Searching for Uncorrelated List of Variables`. The SULOV algorithm is based on the Minimum-Redundancy-Maximum-Relevance (MRMR) <a href="https://towardsdatascience.com/mrmr-explained-exactly-how-you-wished-someone-explained-to-you-9cf4ed27458b">algorithm explained in this article</a> as one of the best feature selection methods. To understand how MRMR works and how it is different from `Boruta` and other feature selection methods, see the chart below. Here "Minimal Optimal" refers to the MRMR and featurewiz kind of algorithms while "all-relevant" refers to Boruta kind of algorithms.<br>

  ![MRMR_chart](MRMR.png)
  <br>
  The working of the SULOV algorithm is as follows:
  <ol>
  <li>Find all the pairs of highly correlated variables exceeding a correlation threshold (say absolute(0.7)).
  <li>Then find their MIS score (Mutual Information Score) to the target variable. MIS is a non-parametric scoring method. So its suitable for all kinds of variables and target.
  <li>Now take each pair of correlated variables, then knock off the one with the lower MIS score.
  <li>What’s left is the ones with the highest Information scores and least correlation with each other.
  </ol>

  ![sulov](SULOV.jpg)

  <b>Recursive XGBoost</b>: Once SULOV has selected variables that have high mutual information scores with least less correlation amongst them, we use XGBoost to repeatedly find best features among the remaining variables after SULOV. The Recursive XGBoost method is explained in this chart below.
  Here is how it works:
  <ol>
  <li>Select all variables in data set and the full data split into train and valid sets.
  <li>Find top X features (could be 10) on train using valid for early stopping (to prevent over-fitting)
  <li>Then take next set of vars and find top X
  <li>Do this 5 times. Combine all selected features and de-duplicate them.
  </ol>

  ![xgboost](xgboost.jpg)

  <b>Building the simplest and most "interpretable" model</b>: featurewiz represents the "next best" step you must perform after doing feature engineering  since you might have added some highly correlated or even useless features when you use automated feature engineering. featurewiz ensures you have the least number of features needed to build a high performing or equivalent model.

  <b>A WORD OF CAUTION:</b> Just because you can engineer new features, doesn't mean you should always create tons of new features. You must make sure you understand what the new features stand for before you attempt to build a model with these (sometimes useless) features. featurewiz displays the SULOV chart which can show you how the 100's of newly created variables added to your dataset are highly correlated to each other and were removed. This will help you understand how feature selection works in featurewiz.


  <ul>
  <li><a href="#background">Background</a></li>
  <li><a href="#install">Install</a></li>
  <li><a href="#usage">Usage</a></li>
  <li><a href="#api">API</a></li>
  <li><a href="#maintainers">Maintainers</a></li>
  <li><a href="#contributing">Contributing</a></li>
  <li><a href="#license">License</a></li>
  </ul>



  ![background](featurewiz_background.jpg)

  To learn more about how featurewiz works under the hood, watch this [video](https://www.youtube.com/embed/ZiNutwPcAU0)<br>

  <p>featurewiz was designed for selecting High Performance variables with the fewest steps.

  In most cases, featurewiz builds models with 20% fewer features than your original data set with nearly the same or slightly lower performance (this is based on my trials. Your experience may vary).<br>
  <p>
  featurewiz is every Data Scientist's feature wizard that will:<ol>
  <li><b>Automatically pre-process data</b>: you can send in your entire dataframe "as is" and featurewiz will classify and change/label encode categorical variables changes to help XGBoost processing. It classifies variables as numeric or categorical or NLP or date-time variables automatically so it can use them correctly to model.<br>
  <li><b>Perform feature engineering automatically</b>: The ability to create "interaction" variables or adding "group-by" features or "target-encoding" categorical variables is difficult and sifting through those hundreds of new features is painstaking and left only to "experts". Now, with featurewiz you can create hundreds or even thousands of new features with the click of a mouse. This is very helpful when you have a small number of features to start with. However, be careful with this option. You can very easily create a monster with this option.
  <li><b>Perform feature reduction automatically</b>. When you have small data sets and you know your domain well, it is easy to perhaps do EDA and identify which variables are important. But when you have a very large data set with hundreds if not thousands of variables, selecting the best features from your model can mean the difference between a bloated and highly complex model or a simple model with the fewest and most information-rich features. featurewiz uses XGBoost repeatedly to perform feature selection. You must try it on your large data sets and compare!<br>
  <li><b>Explain SULOV method graphically </b> using networkx library so you can see which variables are highly correlated to which ones and which of those have high or low mutual information scores automatically. Just set verbose = 2 to see the graph. <br>
  <li><b>Build a fast LightGBM model </b> using the features selected by featurewiz. There is a function called "simple_lightgbm_model" which you can use to build a fast model. It is a new module, so check it out.<br>
  </ol>

  <b>***  Notes of Gratitude ***</b>:<br>
  <ol>
  <li><b>Alex Lekov</b> (https://github.com/Alex-Lekov/AutoML_Alex/tree/master/automl_alex) for his DataBunch and encoders modules which are used by the tool (although with some modifications).</li>
  <li><b>Category Encoders</b> library in Python : This is an amazing library. Make sure you read all about the encoders that featurewiz uses here: https://contrib.scikit-learn.org/category_encoders/index.html </li>
  </ol>



  **Prerequsites:**
  <ol>
  <li><b>featurewiz is built using xgboost, dask, numpy, pandas and matplotlib</b>. It should run on most Python 3 Anaconda installations. You won't have to import any special libraries other than "dask", "XGBoost" and "networkx" library. Optionally, it uses LightGBM for fast modeling, which it installs automatically. </li>
  <li><b>We use "networkx" library for charts and interpretability</b>. <br>But if you don't have these libraries, featurewiz will install those for you automatically.</li>
  </ol>
  - [Anaconda](https://docs.anaconda.com/anaconda/install/)

  To clone featurewiz, it is better to create a new environment, and install the required dependencies:

  To install from PyPi:

  ```
  conda create -n <your_env_name> python=3.7 anaconda
  conda activate <your_env_name> # ON WINDOWS: `source activate <your_env_name>`
  pip install featurewiz --ignore-installed --no-deps
  pip install lazytransform
  or
  pip install git+https://github.com/AutoViML/featurewiz.git
  ```

  To install from source:

  ```
  cd <featurewiz_Destination>
  git clone git@github.com:AutoViML/featurewiz.git

  conda create -n <your_env_name> python=3.7 anaconda
  conda activate <your_env_name> # ON WINDOWS: `source activate <your_env_name>`
  cd featurewiz
  pip install -r requirements.txt
  ```



  As of Jan 2022, you now invoke featurewiz in two ways for two different goals. For feature selection, you must use the scikit-learn compatible fit and predict transformer syntax such as below.

  ```
  from featurewiz import FeatureWiz
  features = FeatureWiz(corr_limit=0.70, feature_engg='', category_encoders='', dask_xgboost_flag=False, nrows=None, verbose=2)
  X_train_selected = features.fit_transform(X_train, y_train)
  X_test_selected = features.transform(X_test)
  features.features  ### provides the list of selected features ###
  ```

  Alternatively, you can use featurewiz for feature engineering using this older syntax. Otherwise, it will give an error. If you want to combine feature engg and then feature selection, you must use this older syntax:

  ```
  import featurewiz as FW
  outputs = FW.featurewiz(dataname=train, target=target, corr_limit=0.70, verbose=2, sep=',',
  		header=0, test_data='',feature_engg='', category_encoders='',
  		dask_xgboost_flag=False, nrows=None)
  ```

  `outputs`: There will always be multiple objects in output. The objects in that tuple can vary:
  1. "features" and "train": It be a list (of selected features) and one dataframe (if you sent in train only)
  2. "trainm" and "testm": It can be two dataframes when you send in both test and train but with selected features.
  <ol>
  <li>Both the selected features and dataframes are ready for you to now to do further modeling.
  <li>Featurewiz works on any multi-class, multi-label data Set. So you can have as many target labels as you want.
  <li>You don't have to tell Featurewiz whether it is a Regression or Classification problem. It will decide that automatically.
  </ol>



  **Arguments**

  - `dataname`: could be a datapath+filename or a dataframe. It will detect whether your input is a filename or a dataframe and load it automatically.
  - `target`: name of the target variable in the data set.
  - `corr_limit`: if you want to set your own threshold for removing variables as highly correlated, then give it here. The default is 0.7 which means variables less than -0.7 and greater than 0.7 in pearson's correlation will be candidates for removal.
  - `verbose`: This has 3 possible states:
    - `0` limited output. Great for running this silently and getting fast results.
    - `1` more verbiage. Great for knowing how results were and making changes to flags in input.
    - `2` SULOV charts and output. Great for finding out what happens under the hood for SULOV method.
  - `test_data`: If you want to transform test data in the same way you are transforming dataname, you can.
      test_data could be the name of a datapath+filename or a dataframe. featurewiz will detect whether
          your input is a filename or a dataframe and load it automatically. Default is empty string.
  - `feature_engg`: You can let featurewiz select its best encoders for your data set by setting this flag
      for adding feature engineering. There are three choices. You can choose one, two or all three.
      - `interactions`: This will add interaction features to your data such as x1*x2, x2*x3, x1**2, x2**2, etc.
      - `groupby`: This will generate Group By features to your numeric vars by grouping all categorical vars.
      - `target`:  This will encode and transform all your categorical features using certain target encoders.<br>
      Default is empty string (which means no additional features)
  - `category_encoders`: Instead of above method, you can choose your own kind of category encoders from the list below.
      Recommend you do not use more than two of these. Featurewiz will automatically select only two from your list. Default is empty string (which means no encoding of your categorical features)<br> These descriptions are derived from the excellent <a href="https://contrib.scikit-learn.org/category_encoders/"> category_encoders</a> python library. Please check it out!
      - `HashingEncoder`: HashingEncoder is a multivariate hashing implementation with configurable dimensionality/precision. The advantage of this encoder is that it does not maintain a dictionary of observed categories. Consequently, the encoder does not grow in size and accepts new values during data scoring by design.
      - `SumEncoder`: SumEncoder is a Sum contrast coding for the encoding of categorical features.
      - `PolynomialEncoder`: PolynomialEncoder is a Polynomial contrast coding for the encoding of categorical features.
      - `BackwardDifferenceEncoder`: BackwardDifferenceEncoder is a Backward difference contrast coding for encoding categorical variables.
      - `OneHotEncoder`: OneHotEncoder is the traditional Onehot (or dummy) coding for categorical features. It produces one feature per category, each being a binary.
      - `HelmertEncoder`: HelmertEncoder uses the Helmert contrast coding for encoding categorical features.
      - `OrdinalEncoder`: OrdinalEncoder uses Ordinal encoding to designate a single column of integers to represent the categories in your data. Integers however start in the same order in which the categories are found in your dataset. If you want to change the order, just sort the column and send it in for encoding.
      - `FrequencyEncoder`: FrequencyEncoder is a count encoding technique for categorical features. For a given categorical feature, it replaces the names of the categories with the group counts of each category.
      - `BaseNEncoder`: BaseNEncoder encodes the categories into arrays of their base-N representation. A base of 1 is equivalent to one-hot encoding (not really base-1, but useful), a base of 2 is equivalent to binary encoding. N=number of actual categories is equivalent to vanilla ordinal encoding.
      - `TargetEncoder`: TargetEncoder performs Target encoding for categorical features. It supports following kinds of targets: binary and continuous. For multi-class targets it uses a PolynomialWrapper.
      - `CatBoostEncoder`: CatBoostEncoder performs CatBoost coding for categorical features. It supports the following kinds of targets: binary and continuous. For polynomial target support, it uses a PolynomialWrapper. This is very similar to leave-one-out encoding, but calculates the values “on-the-fly”. Consequently, the values naturally vary during the training phase and it is not necessary to add random noise.
      - `WOEEncoder`: WOEEncoder uses the Weight of Evidence technique for categorical features. It supports only one kind of target: binary. For polynomial target support, it uses a PolynomialWrapper. It cannot be used for Regression.
      - `JamesSteinEncoder`: JamesSteinEncoder uses the James-Stein estimator. It supports 2 kinds of targets: binary and continuous. For polynomial target support, it uses PolynomialWrapper.
      For feature value i, James-Stein estimator returns a weighted average of:
      The mean target value for the observed feature value i.
      The mean target value (regardless of the feature value).
      - `dask_xgboost_flag`: Default is False. Set to True to use dask_xgboost estimator. You can turn it off if it gives an error. Then it will use pandas and regular xgboost to do the job.
      - `nrows`: default `None`. You can set the number of rows to read from your datafile if it is too large to fit into either dask or pandas. But you won't have to if you use dask.
  **Return values**
  -   `outputs`: Output is always a tuple. We can call our outputs in that tuple: out1 and out2.
      -   `out1` and `out2`: If you sent in just one dataframe or filename as input, you will get:
          - 1. `features`: It will be a list (of selected features) and
          - 2. `trainm`: It will be a dataframe (if you sent in a file or dataname as input)
      -   `out1` and `out2`: If you sent in two files or dataframes (train and test), you will get:
          - 1. `trainm`: a modified train dataframe with engineered and selected features from dataname and
          - 2. `testm`: a modified test dataframe with engineered and selected features from test_data.



  * [@AutoViML](https://github.com/AutoViML)



  See [the contributing file](CONTRIBUTING.md)!

  PRs accepted.



  Apache License 2.0 © 2020 Ram Seshadri


  This project is not an official Google project. It is not supported by Google and Google specifically disclaims all warranties as to its quality, merchantability, or fitness for a particular purpose.


pkgId: 7ae8c7a98119e1d7eef2011d973daae03212855acfc9445d6cf81e7b35d4bde2
name: python-fedfind
arch: src
version: 5.0.1
epoch: 0
release: 1
summary: Fedora Finder finds Fedora - images, more to come?
url: https://pagure.io/fedora-qa/fedfind
rpm_license: GPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-643b572d-2d41-4846-9081-4cb760ab9263
location_href: 00003617-python-fedfind/python-fedfind-5.0.1-1.src.rpm
checksum_type: sha256
description:
  Fedora Finder finds Fedoras. It provides a CLI and Python module that find and providing identifying information about Fedora images and release trees. Try it out:

      fedfind images --release 35
      fedfind images --release 36 --milestone Beta
      fedfind images --release 36 --milestone Beta --compose 1 --respin 1
      fedfind images --dist Fedora-Container --release 33 --compose 20211123 --respin 0
      fedfind images --compose 20211210
      fedfind images --composeid Fedora-Rawhide-20211210.n.0
      fedfind images --release 34 --label Beta-1.1
      fedfind images --release 5 --arch x86_64,ppc
      fedfind images --release 15 --search desk

  Fedora has stable releases, archive releases, really old archive releases, 'milestone' releases (Alpha / Beta), release validation 'candidate' composes, unstable nightly composes, and post-release nightly composes, all in different places, with several different layouts. There is no canonical database of the locations and contents of all the various composes/releases. We in Fedora QA found we had several tools that needed to know where to find various images from various different types of releases, and little bits of knowledge about the locations and layouts of various releases/composes had been added to different tools. fedfind was written to consolidate all this esoteric knowledge in a single codebase with a consistent interface.

  fedfind lets you specify a release/compose using five values: 'dist', 'release', 'milestone', 'compose', and 'respin'. It can then find the location for that compose, tell you whether it exists, and give you the locations of all the images that are part of the release and what each image actually contains. As an alternative to this versioning concept, you can also find releases by their Pungi 4 / productmd 'compose ID' or 'compose label' (see examples above).

  fedfind runs on Python versions 2.7 and later (including 3.x).



  fedfind is packaged in the official Fedora and EPEL repositories: to install on Fedora run `dnf install fedfind`, on RHEL / CentOS with EPEL enabled, run `yum install fedfind`. You may need to enable the *updates-testing* repository to get the latest version.

  You can visit [the fedfind project page on Pagure][1], and clone with `git clone https://pagure.io/fedora-qa/fedfind.git`. Tarballs are released through [PyPI][2].

  You can use the fedfind CLI from the tarball without installing it, as `./fedfindlocal.py` from the root of the tarball (you will need `productmd` and `six`, and `cached_property` for Python < 3.8). You can of course copy the Python module anywhere you like and use it in place. To install both CLI and module systemwide, run `python setup.py install`.



  You can file issues and pull requests on [Pagure][1]. Pull requests must be signed off (use the `-s` git argument). By signing off your pull request you are agreeing to the [Developer's Certificate of Origin][3]:

      Developer's Certificate of Origin 1.1

      By making a contribution to this project, I certify that:

      (a) The contribution was created in whole or in part by me and I
          have the right to submit it under the open source license
          indicated in the file; or

      (b) The contribution is based upon previous work that, to the best
          of my knowledge, is covered under an appropriate open source
          license and I have the right under that license to submit that
          work with modifications, whether created in whole or in part
          by me, under the same open source license (unless I am
          permitted to submit under a different license), as indicated
          in the file; or

      (c) The contribution was provided directly to me by some other
          person who certified (a), (b) or (c) and I have not modified
          it.

      (d) I understand and agree that this project and the contribution
          are public and that a record of the contribution (including all
          personal information I submit with it, including my sign-off) is
          maintained indefinitely and may be redistributed consistent with
          this project or the open source license(s) involved.



  Some usage of fedfind relies on understanding the 'dist', 'release', 'milestone', 'compose', 'respin' versioning concept, so here is a quick primer. Note that if you intend to use fedfind solely with compose IDs or URLs for modern Pungi 4-generated composes, this section will be of less interest to you and you can probably skip it.

  In this section we will write release, milestone, compose, dist quints as (release, milestone, compose, respin, dist) with '' indicating an omitted value, e.g. (22, Beta, TC3, '', 'Fedora') or (22, '', '', '', 'Fedora'). Note 'dist' is usually 'Fedora', and this is its default value, used when it is not explicitly specified. Conceptually, 'dist' should come at the front, but in fact fedfind functions which accept these values tend to place it after the others, for historical reasons (it did not exist when fedfind's versioning scheme was created).

  * **Dist** is the term fedfind uses for what pungi and productmd refer to as the *shortname*; when fedfind was created this didn't really exist, but now the Fedora project produces many more composes than it used to, some with different *dists* / *shortnames*. In the compose with compose ID 'Fedora-Rawhide-20160301.n.0', the *dist* / *shortname* is *Fedora*; in a compose with compose ID 'Fedora-Container-33-20211123.0', the dist / shortname is *Fedora-Container*. *Fedora* is the **dist** for all mainline composes, and this is the default value. *Fedora-Container* is the **dist** for the nightly container image composes, produced once a day for each of the current stable releases, which at present are found only in their initial location as output by release engineering, and not in their mirrored locations. Similarly, *Fedora-Cloud* and *Fedora-IoT* are the **dists** for the nightly Cloud and IoT composes for the current stable releases. So e.g. (35, '', 20211210, 0, 'Fedora-Cloud') will find the (first) 2021-12-10 nightly Cloud compose for Fedora 35. *FedoraRespin* is the **dist** for the current post-release live respin compose in the `live-respins` directory; there is only ever one of these at a time (and note that these are only semi-official builds, provided by volunteers as a courtesy, they do not have the status of official composes). Any **release** or **compose** passed with the **dist** *FedoraRespin* is used as a *check*: if the existing contents of the `live-respins` directory don't match the expected release (number) or compose (date), fedfind will raise an exception instead of returning the `RespinRelease` instance.

  * **Release** is usually a Fedora release number, e.g. 27, 15 or 1. The only non-integer value that is accepted is 'Rawhide', for Rawhide nightly composes. These do not, properly speaking, have a definite release number associated with them: Rawhide is a perpetually rolling tree. The canonical versioning for Rawhide nightly composes is (Rawhide, '', YYYYMMDD, N) (where N is the respin number). Note that [python-wikitcms][4] uses almost the same versioning concept as fedfind, but Wikitcms 'validation events' for Rawhide nightly composes **do** have a release number: this is a property of the *validation event*, not of the *compose*. Thus there may be a Wikitcms *validation event* (24, Rawhide, 20151012, 1, 'Fedora') for the fedfind *compose* (Rawhide, '', 20151012, 1). fedfind and python-wikitcms both recognize this case and will attempt to convert each other's values for convenience.

  * **Milestone** indicates the milestone or the type of nightly compose. Valid milestones for current releases are *Beta*, *RC* (or *Final*, which means the same), *Branched*, and *Production*. The *Alpha* milestone existed until Fedora 25, but Fedora 26 and later releases have no Alpha; no Alpha releases can be found any more, as the Fedora 25 and earlier Alphas are now removed. fedfind will accept *Rawhide* as a milestone and convert it to the release - so ('', Rawhide, YYYYMMDD, N, 'Fedora') is not exactly *valid* but will be handled by the CLI and the `get_release` function and converted to (Rawhide, '', YYYYMMDD, N, 'Fedora'). Stable releases do not have a milestone; (23, RC, '', '', 'Fedora') will be accepted by `get_release` and the CLI but is treated internally as (23, '', '', '', 'Fedora'). The *Production* milestone indicates a so-called 'production' compose, which will usually also be an Alpha, Beta or Final 'candidate' compose - you may be able to find the same compose in two different places, for instance, with the *Production* milestone and a date-based **compose** and **respin**, or with the *Alpha*, *Beta* or *Final* milestone and a numeric **compose** and **respin**. It is approximately the same as the difference between searching for a production compose by compose ID and searching for it by compose label. See more on this in the *fedfind / Wikitcms vs. Pungi / productmd versioning* section below. Currently, the milestone value has no meaning for **dists** other than *Fedora*.

  The values *Cloud* and *Respin* are accepted for backwards compatibility purposes; they will be translated into a **dist** value of *Fedora-Cloud* or *FedoraRespin* respectively, and a blank **milestone** value. Versions of fedfind before 4.0 overloaded the **milestone** concept to handle these **dist** values, rather than properly handling them as **dists**. This functionality may be removed in a future major release.

  * **Compose** is the precise compose identifier (in cases where one is needed). For candidate composes it is always 1. For nightly composes it is a date in YYYYMMDD format. Stable releases and milestone releases do not have a compose.

  * **Respin** is an integer that's bumped any time a compose which would otherwise have the same version is repeated. The concept is taken from Pungi. If we attempt to build two Rawhide nightly composes on 2016-03-01, for instance, in fedfind's versioning they are (Rawhide, '', 20160301, 0) and (Rawhide, '', 20160301, 1). The corresponding Pungi / productmd 'compose ID'-style versioning is Fedora-Rawhide-20160301.n.0 and Fedora-Rawhide-20160301.n.1.

  Note that, as a convenience, fedfind will attempt to detect when a 'compose' value is in fact a combined compose and respin, and split it up - so you can specify the compose as `1.7` (for compose `1`, respin `7`) or `20160330.0` or `20160330.n.0` (both of which will be treated as compose `20160330`, respin `0`).

  Some examples:

  * Stable release: (23, '', '', '', 'Fedora')
  * Beta release: (24, Beta, '', '', 'Fedora')
  * Candidate: (24, Beta, 1, 7, 'Fedora')
  * Branched nightly: (24, Branched, 20160330, 0, 'Fedora')
  * Rawhide nightly: (Rawhide, '', 20160330, 1, 'Fedora')

  The test suite contains a bunch of tests for `get_release()` which incidentally may function as further examples of accepted usage. The fedfind CLI and `get_release()` are designed to guess omitted values in many cases, primarily to aid unattended usage, so e.g. a script can simply specify ('', Branched, '', '', 'Fedora') to run on the date's latest branched compose, without having to know what the current Branched release number is. More detailed information on various cases can be found in the `get_release()` function's docstring.



  The fedfind / Wikitcms versioning system was developed prior to the use of Pungi 4 for Fedora composes. The 'respin' concept from Pungi / productmd was then stuffed into the fedfind / Wikitcms versioning concept quite hastily to keep stuff working, and the productmd 'short' concept was also added to fedfind (usually under the name 'dist', which more closely describes its function in Fedora's context).

  For now, fedfind attempts to remain compatible with its legacy versioning approach as well as possible, while also supporting release identification using productmd versioning concepts. For instance, non-Pungi 4 composes have a sloppily-faked up *cid* attribute that at least will produce the correct release number when parsed like a 'compose ID', and `get_release()` can parse *most* (we aim for 'all', but we're also realists!) compose IDs, compose URLs and compose labels and return appropriate Release instances.

  Pungi has several version-ish concepts. The two most important to fedfind are the 'compose ID' and 'label'. All Pungi composes have a 'compose ID'. Not all have a label - only 'production' composes do (not 'nightly' or 'test' composes).

  A compose ID looks like `Fedora-24-20160301.n.0` (nightly), or `Fedora-Rawhide-20160302.t.1` (test), or `Fedora-24-20160303.0` (production). The release number, date and type of compose are always indicated somehow. For Fedora purposes the respin value should always be present. There is no kind of 'milestone' indicator.

  A label looks like `Alpha-1.2`, or `Beta-13.16`. There's a list of supported milestones (including Fedora's Alpha and Beta, but not Final - productmd uses RC instead). The first number is a public release number (RHEL has numbered milestone releases, unlike Fedora); the second is the respin value, which is considered more of a private/internal property. The system around which the scheme was designed appears to be that multiple "Alpha 1" respins are produced and tested and the final one is released as the public "Alpha 1" - thus the 'respin' concept covers approximately the same ground as Fedora's "TC" and "RC" composes used to.

  Mainline Fedora nightly composes are built just as you'd expect: the short name is 'Fedora', the release number is 'Rawhide' or the actual release number, the type is nightly, and the respin value is incremented if multiple composes are run on the same date (usually only if the first fails and we want to fix it before the next day). So Fedora nightly compose IDs look like `Fedora-Rawhide-20180119.n.0`, for instance.

  For milestone releases, Fedora builds 'production' composes with the label `release` number always set as 1, and the `respin` number incremented each time a compose is run. Thus for Fedora 24 Alpha validation testing we built `Alpha-1.1`, `Alpha-1.2`, `Alpha-1.3` and so on, until `Alpha-1.7` was ultimately released as the public Alpha release. Each of these composes also had a compose ID in `Fedora-24-20160323.0` format.

  The post-release nightly composes for Cloud, Container and IoT images are built almost as you'd expect, but with their type as 'production', not 'nightly'. So their compose IDs look like `Fedora-Cloud-27-20180119.0` or `Fedora-IoT-26-20171215.1`. Their labels are always `RC-(date).(respin)`, e.g. `RC-20180119.0`.

  Current fedfind should be capable in almost all cases of finding any findable Fedora compose by its compose ID or its label. The Fedora 'production' composes initially land in one location (on *kojipkgs*, alongside the nightly Branched and Rawhide composes, in directory names based on the compose ID) and are then mirrored to another location (on *alt*, in directory names based on the compose label). When you search for a given production / candidate compose whether you find its *kojipkgs* location or its *alt* location depends to some extent on how you search for it. Searching by compose label, or with something like *milestone* Alpha, *compose* 1, *respin* 7, will usually find its *alt* location (as a `Compose` class instance). Searching by compose ID, or with something like *milestone* Production, *compose* 20160323, *respin* 0, will usually find its *kojipkgs* location (as a `Production` class instance). However, you can set the `get_fedora_release` argument `promote` to `True` when searching by compose ID-ish values, and fedfind will attempt to find the `Compose` class (*alt* location) if it can. All fedfind release instances for Pungi 4 composes that actually exist should have the compose's compose ID as their `cid` attribute. If the compose has a label, it should be available as the `label` attribute.



  The `fedfind` CLI command gives you URLs for a release's images. For instance, `fedfind images -r 25` will print the URLs to all Fedora 25 images. You can filter the results in various ways. For more information, use `fedfind -h` and `fedfind images -h`.



  The Python module provides access to all fedfind's capabilities.



      import fedfind.release

      comp = fedfind.release.get_release(release=27)
      print comp.location
      for img in comp.all_images:
          print(img['url'])



  The main part of fedfind is the `Release` class, in `fedfind.release`. The primary entry point is `fedfind.release.get_release()` - in almost all cases you would start by getting a release using that function, which takes the `release`, `milestone`, `compose`, `respin`, and `dist` values that identify a release as its arguments and returns an instance of a `Release` subclass. You may also pass `url` (which is expected to be the `/compose` directory of a Pungi 4 compose, or as a special case, `https://dl.fedoraproject.org/pub/alt/live-respins/` for the semi-official post-release live respins which live there), `cid` (a Pungi 4 compose ID), or `label` (a Pungi 4 compose label) as an alternative to release/milestone/compose/respin. If you pass a `url` or `cid`, fedfind will run a cross-check to ensure the URL or CID of the discovered compose actually matches what you requested, and raise an exception if it does not.

  Anyone who used fedfind 1.x may remember the `Image` class for describing images and the `Query` class for doing searches. Both of those were removed from fedfind 2.x in favour of productmd-style metadata. All `Release` instances have a `metadata` dict which, if the release exists, will contain an `images` item which is itself a dict containing image metadata in the format of the productmd `images.json` file. For Pungi 4 releases this is read straight in from `images.json`; for pre-Pungi 4 releases fedfind synthesizes metadata in approximately the same format.

  You can also use the `all_images` convenience property; this is basically a flattened form of the images metadata. It's a list of image dicts, with each image dict in the same basic form as a productmd image dict, but with a `variant` entry added to indicate its variant (in the original productmd layout, the image dicts are grouped by variant and then by arch, which is kind of a pain to parse for many use cases). Note that since fedfind 3.1.0, from Fedora 9 onwards, `boot.iso` files are not included in `all_images`(or the lower-level `all_paths`).

  Since fedfind 3.3.0, image dicts also have `url` and `direct_url` entries added which provide full HTTPS URLs for the image files (so fedfind consumers no longer have to worry about constructing URLs by combining the release `location` or `alt_location` and the image `path`). `url` may go through the https://download.fedoraproject.org mirror redirector, which tries to spread load between mirrors. `direct_url` will always be a direct link. If the image is in the public mirror system, it will use the https://dl.fedoraproject.org mirror. Please use `url` unless you have a strong reason to use `direct_url`, to avoid excessive load on the server.

  You're expected to roll your own queries as appropriate for your use case. The reason fedfind 1.x had a dedicated query interface was primarily to try and speed things up for nightly composes by avoiding Koji queries where possible and tailoring them where not; since fedfind no longer ever has to perform slow Koji queries to find images, the need for the `Query` class is no longer there, you can always just operate on the data in `metadata['images']` or `all_images`. Note the image `subvariant` property is extremely useful for identifying images; you may also want to use the `identify_image` function from `productmd` for this purpose.

  All methods and functions in fedfind are documented directly: please do refer to the docstrings for information on their purposes. Attributes are documented with comments wherever their purpose is not immediately obvious.

  All methods, functions, attributes and properties not prefixed with a `_` are considered 'public'. Public method and function signatures and all public data types will only change in major releases. fedfind has no control over the form or content of the productmd metadata, so when and how that changes is out of our hands; I will make a best effort to keep the synthesized metadata for old composes broadly in line with whatever current Pungi produces, though it is not perfect now and likely never will be (it's kinda tailored to the information I actually need from it).



  fedfind can do some useful stuff that isn't just querying images for releases:

  * `Release.check_expected()` sees if all 'expected' images for the release are present.
  * `Release.previous_release()` takes a cut at figuring out what the 'previous' release was, though this is difficult and may not always work or return what you expect.
  * `helpers.get_current_release()` tells you what the current Fedora release is.



  fedfind has a bunch of knowledge about where Fedora keeps various composes wired in. For Pungi 4 compose types, finding the compose is about all fedfind has to do; it reads all the information about what images are in the compose out from the metadata and exposes it.

  For non-Pungi 4 composes (old stable releases) and Pungi 4 composes that are modified and have their metadata stripped (current stable and milestone releases), fedfind uses the `imagelist` files present on dl.fedoraproject.org, which contain lists of every image file in the entire tree. It finds the images for the specific compose being queried, then produces a path relative to the top of the mirror tree from the result. It can then combine that with a known prefix to produce an HTTPS URL.

  For metadata, fedfind first tries to see if the compose was originally produced with Pungi 4 and its metadata is available from PDC. It tries to guess the compose label from the image file names, and then a compose ID from the compose label, and then query PDC for metadata for that compose. If it is successful, it tries to match each image discovered from the `imagelist` file with an image dict from the original metadata, and combine the two so that the path information is correct but all other information for the image is taken from the original metadata, rather than synthesized by fedfind.

  For any discovered image no matching original image dict is found for, and for composes where no original metadata is available at all, fedfind synthesizes productmd-style metadata by analyzing the file path, guessing the properties that can be guessed and omitting others.

  In all cases, the result is that metadata and derived properties like `all_images` are as similar as possible for the different types of compose, so fedfind consumers can interact with non-Pungi 4 composes in the same way as Pungi 4 ones (to the extent of the metadata discovery and synthesis implementations, some stuff just isn't covered by the synthesis).





  With the use of small metadata files (for metadata composes) and still-quite-small image list files that are cached locally (for non-metadata composes), fedfind is much faster than it used to be. It can still take a few seconds to do all its parsing and analysis, though.

  When used as a module it caches properties and image lists for the lifetime of the release instance. The image list files are cached (in `~/.cache/fedfind`) based on the 'last modified time' provided by the server they come from: for each new release instance, fedfind will hit the server to retrieve the last modified time header, but if the cached copy matches that time, it will not re-download the file. These files are also quite small so will not take long to download in any case. If the download fails for some reason, but we do have a cached copy of the necessary lists, fedfind will work but log a warning that it's using cached data which may be outdated.

  Certain PDC queries, whose results are never expected to change, are also cached (again in `~/.cache/fedfind`), to speed up repeated searches and reduce load on PDC.

  If `~/.cache/fedfind` is not writeable for the user running fedfind, we fall back to using a temporary cache location that is only valid for the life of the process (and deleted on exit). This at least ensures fedfind will work in this case, but results in it being slower and doing more round trips.

  It shouldn't use too much bandwidth (though I haven't really measured), but obviously the server admins won't be happy with me if the servers get inundated with fedfind requests, so don't go *completely* crazy with it - if you want to do something script-y, please at least use the module and re-use release instances so the queries get cached.



  All releases other than stable releases disappear. fedfind can find stable releases all the way back to Fedora Core 1, but it is not going to find Fedora 14 Alpha, Fedora 19 Beta TC3, or nightlies from more than 2-3 weeks ago. This isn't a bug in fedfind - those images literally are not publicly available any more. Nightlies only stick around for a few weeks, candidate composes for a given milestone usually disappear once we've moved on another couple of milestones, and pre-releases (Alphas and Betas) usually disappear some time after the release in question goes stable. fedfind will only find what's actually there.

  Also note that fedfind is not designed to find even *notional* locations for old non-stable releases. Due to their ephemeral nature, the patterns it uses for nightly builds and candidate composes only reflect current practice, and will simply be updated any time that practice changes. It doesn't have a big store of knowledge of what exact naming conventions we used for old composes. If you do `comp = fedfind.release.Compose(12, 'Final', 'TC4')` and read out `comp.location` or something what you get is almost certainly *not* the location where Fedora 12 Final TC4 actually lived when it was around.



  fedfind does not, for the present, handle secondary arches at all. It *will* find PPC images for releases where PPC was a primary arch and i686 images for releases where i686 was a primary arch, though.



  This is pretty much all my fault. Note that aside from its external deps, older versions of fedfind (up to 1.1.2) included a copy of the `cached_property` implementation maintained [here][5] by Daniel Greenfield. The bundled copy was dropped with version 1.1.3.



  Fedora Finder is available under the GPL, version 3 or any later version. A copy is included as COPYING.

  [1]: https://pagure.io/fedora-qa/fedfind
  [2]: https://pypi.python.org/pypi/fedfind
  [3]: https://developercertificate.org/
  [4]: https://pagure.io/fedora-qa/python-wikitcms
  [5]: https://github.com/pydanny


pkgId: 738f8a391d90d578e06a37b1fa782dcafd1b3b54c8b8a8ca784d912bb59cd613
name: python-fedmsg
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Fedora Messaging Client API
url: https://github.com/fedora-infra/fedmsg/
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86fd1777-10b7-42de-baca-65c21a1e6a0d
location_href: 00003618-python-fedmsg/python-fedmsg-1.1.3-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/fedmsg.svg
      :target: https://pypi.python.org/pypi/fedmsg

  .. image:: https://img.shields.io/pypi/pyversions/fedmsg.svg
      :target: https://pypi.python.org/pypi/fedmsg

  .. image:: https://img.shields.io/pypi/l/fedmsg.svg
      :target: https://pypi.python.org/pypi/fedmsg

  .. image:: https://readthedocs.org/projects/docs/badge/?version=latest
      :alt: Documentation Status
      :target: https://fedmsg.readthedocs.io/en/latest/?badge=latest

  .. image:: https://secure.travis-ci.org/fedora-infra/fedmsg.png?branch=develop
     :alt: Build Status - develop branch
     :target: https://travis-ci.org/#!/fedora-infra/fedmsg

  .. image:: https://codecov.io/github/fedora-infra/fedmsg/coverage.svg?branch=develop
      :target: https://codecov.io/github/fedora-infra/fedmsg
      :alt: codecov.io


  fedmsg (Federated Message Bus) is a library built on ZeroMQ using the PyZMQ Python bindings.
  fedmsg aims to make it easy to connect services together using ZeroMQ publishers and
  subscribers.

  Note that this library is deprecated in favor of https://github.com/fedora-infra/fedora-messaging

  Check out the `documentation <https://fedmsg.readthedocs.io/en/stable/>`_ for installation and
  configuration instructions.


pkgId: d708781c28ffe623ab655914415580ba8a89ac14dac04a08f8f88238948fb83d
name: python-fedmsg-meta-fedora-infrastructure
arch: src
version: 0.31.0
epoch: 0
release: 1
summary: fedmsg metadata providers for Fedora Infrastructure's deployment
url: https://github.com/fedora-infra/fedmsg_meta_fedora_infrastructure/
rpm_license: LGPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0f267138-182d-474f-8a50-4bde4e3036b5
checksum_type: sha256
description:
  `fedmsg <http://fedmsg.com>`_ is a set of tools for knitting together services
  and webapps into a realtime messaging net.  This package contains metadata
  provider plugins for the primary deployment of that system:  `Fedora
  Infrastructure <https://fedoraproject.org/wiki/Infrastructure>`_.
  If you were to deploy fedmsg at another site, you would like want to write your
  own module like this one that could provide textual representations of *your*
  messages.
  Pop into ``#fedora-apps`` on freenode if you have questions or comments.

location_href:
  00003619-python-fedmsg-meta-fedora-infrastructure/python-fedmsg-meta-fedora-infrastructure-0.31.0-1.src.rpm


pkgId: 7df4c7dc4bd3756475ff788efadbfe05c95c71be41dc6bb32df55036083c7025
name: python-fedora-messaging
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: A set of tools for using Fedora's messaging infrastructure
url: https://github.com/fedora-infra/fedora-messaging
rpm_license: GPLv2+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9e15831f-9cc9-436f-8406-9e36d324349a
location_href: 00003622-python-fedora-messaging/python-fedora-messaging-3.2.0-1.src.rpm
checksum_type: sha256
description:
  This package provides tools and APIs to make using Fedora's messaging
  infrastructure easier. These include a framework for declaring message schemas,
  a set of synchronous APIs to publish messages to AMQP brokers, a set of
  asynchronous APIs to consume messages, and services to easily run consumers.
  This library is designed to be a replacement for the `PyZMQ`_-backed `fedmsg`_
  library in Fedora Infrastructure.
  To get started, check out our `user guide`_.
  Looking to contribute? We appreciate it! Check out the `contributor guide`_.


pkgId: de3eaa6ab325b83fe99e0eadfe75bd6cfe09c565af260a27a5d726016d5cb169
name: python-feedfinder2
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Find the feed URLs for a website.
url: https://github.com/dfm/feedfinder2
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8ce53f39-92da-4f3a-ba8f-1a2175a90feb
location_href: 00010978-python-feedfinder2/python-feedfinder2-0.0.4-1.src.rpm
checksum_type: sha256
description:
  This is a Python library for finding links feeds on a website. It is based on
  `feedfinder <http://www.aaronsw.com/2002/feedfinder/>`_ - originally
  written by `Mark
  Pilgrim <http://en.wikipedia.org/wiki/Mark_Pilgrim_(software_developer)>`_ and
  subsequently maintained by `Aaron
  Swartz <http://en.wikipedia.org/wiki/Aaron_Swartz>`_ until his untimely death.


pkgId: 0fe98c31a2f31a1b65a01080bbd9306712c570a5a892f233dd75de29ccc3b49d
name: python-feedgen
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Feed Generator (ATOM, RSS, Podcasts)
url: https://lkiesow.github.io/python-feedgen
rpm_license: FreeBSD and LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1d4510be-41ac-47d2-8584-fbda68c3c02f
location_href: 00003623-python-feedgen/python-feedgen-0.9.0-1.src.rpm
checksum_type: sha256
description:
  This module can be used to generate web feeds in both ATOM and RSS format. It
  has support for extensions. Included is for example an extension to produce
  Podcasts.
  It is licensed under the terms of both, the FreeBSD license and the LGPLv3+.
  Choose the one which is more convenient for you. For more details have a look
  at license.bsd and license.lgpl.


pkgId: 02d9492035ac638700f9204f28c7433a2fa0fcbd434b28e5dc7bf5df125bcdd3
name: python-feedgenerator
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Standalone version of django.utils.feedgenerator
url: https://github.com/getpelican/feedgenerator
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7a258597-a8f5-4e22-b216-b9f01642a4cc
location_href: 00003624-python-feedgenerator/python-feedgenerator-2.0.0-1.src.rpm
checksum_type: sha256
description:
  |githubci| |pypi|
  FeedGenerator is a standalone version of Django’s feedgenerator_ module.
  It has evolved over time and includes numerous enhancements.


pkgId: d765a01d2c5677df8ca4050ba40948cc0b1be361744fb83e46647b255aff3a64
name: python-ffmpy
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A simple Python wrapper for ffmpeg
url: https://github.com/Ch00k/ffmpy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9b99b76d-1e45-462a-bac6-45d3877a23c3
location_href: 00011230-python-ffmpy/python-ffmpy-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ffmpy is a simplistic `FFmpeg <http://ffmpeg.org/>`_ command line wrapper. It implements a Pythonic interface for FFmpeg command line compilation and uses Python `subprocess <https://docs.python.org/2/library/subprocess.html>`_ module to execute compiled command line.


pkgId: ff7f3247e11ca0644d543ba7a4076b99e35abd9e2da4ff17036c5c7e2de5acd2
name: python-fiddler-client
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Python client for Fiddler Service
url: https://fiddler.ai
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-5974e5ea-67a9-4e37-8c63-6f14208b65c7
location_href: 00010324-python-fiddler-client/python-fiddler-client-1.7.0-1.src.rpm
checksum_type: sha256
description:
  Python client for interacting with Fiddler. Provides a user-friendly interface to our REST API and enables event
  publishing for use with our monitoring features.


pkgId: 6ca7727085e58a7a9ab51138d3b58e4a4e196c263167288df5c954a424a5392d
name: python-file-magic
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Python front end for libmagic(3)
url: https://https://darwinsys.com/file/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2012aecc-7fc6-46cb-8c33-d6e9635811f7
location_href: 00003630-python-file-magic/python-file-magic-0.4.1-1.src.rpm
checksum_type: sha256
description:
  This library is a Python ctypes interface to `libmagic`.




  You can install `file-magic` either with:

      python setup.py install
      
      easy_install .
      
      pip install file-magic




      import magic

      detected = magic.detect_from_filename('magic.py')
      print 'Detected MIME type: {}'.format(detected.mime_type)
      print 'Detected encoding: {}'.format(detected.encoding)
      print 'Detected file type name: {}'.format(detected.name)




  To run the tests:

      python setup.py test

rpm_license:
  Copyright (c) Ian F. Darwin 1986-1995. Software written by Ian F. Darwin and others; maintained 1995-present by Christos Zoulas and others. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice immediately at the beginning of the file, without modification, this list of conditions, and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: df0946f9a4308011e83bff5345ac2ceae17529d0f2b32525dd116561f12fe8cc
name: python-filesplit
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Python module that is capable of splitting files and merging it back.
url: https://github.com/ram-jayapalan/filesplit
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c2ad49fe-0dd1-4930-8c8f-85f07988ae82
location_href: 00013104-python-filesplit/python-filesplit-4.0.1-1.src.rpm
checksum_type: sha256
description:
  File splitting and merging made easy for python programmers!
  This module
      * Can split files of any size into multiple chunks and also merge them back.
      * Can handle both structured and unstructured files.


pkgId: 1a24e004988e65c6c4a6e4b19af837837630616439b80dd84896a83a674e108a
name: python-filetype
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Infer file type and MIME type of any file/buffer. No external dependencies.
url: https://github.com/h2non/filetype.py
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b125a5f-2379-4b57-b4b3-f8e6009b1aba
location_href: 00003631-python-filetype/python-filetype-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Small and dependency free `Python`_ package to infer file type and MIME
  type checking the `magic numbers`_ signature of a file or buffer.
  This is a Python port from `filetype`_ Go package.


pkgId: 90e5ee74e914ad26e8278cac04ebcfde1b96bd8f61302d9a9475e8ee0504b345
name: python-fire
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A library for automatically generating command line interfaces.
url: https://github.com/google/python-fire
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-913e2e7e-25af-4adc-a530-5e30792f8be8
location_href: 00009463-python-fire/python-fire-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Python Fire is a library for automatically generating command line interfaces
  (CLIs) with a single line of code.

  It will turn any Python module, class, object, function, etc. (any Python
  component will work!) into a CLI. It's called Fire because when you call Fire(),
  it fires off your command.


pkgId: 8f20767ccd7b288b94ce2cf3592ddf4bd5df86c05c165fcf049b10fa52ef68c8
name: python-firehose
arch: src
version: 0.5
epoch: 0
release: 1
summary: Library for working with output from static code analyzers
url: https://github.com/fedora-static-analysis/firehose
rpm_license: LGPL2.1 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-95d309ce-d3ff-4518-b9d8-e3f189c446bd
location_href: 00003633-python-firehose/python-firehose-0.5-1.src.rpm
checksum_type: sha256
description:
  "firehose" is a Python package intended for managing the results from
  code analysis tools (e.g. compiler warnings, static analysis, linters,
  etc).

  It currently provides parsers for the output of gcc, clang-analyzer, cppcheck,
  and findbugs.  These parsers convert the results into a common data model of
  Python objects, with methods for lossless roundtrips through a provided
  XML format.  There is also a JSON equivalent.

  It is available on pypi here:
    https://pypi.python.org/pypi/firehose

  and via git from:
    https://github.com/fedora-static-analysis/firehose

  The mailing list is:
    https://admin.fedoraproject.org/mailman/listinfo/firehose-devel

  Documentation can be read here:
    http://firehose.readthedocs.io/en/latest/

  Firehose is Free Software, licensed under the LGPLv2.1 or (at your
  option) any later version.

  It requires Python 2.7 or 3.2 onwards, and has been successfully tested
  with PyPy.

  It is currently of alpha quality.

  The API and serialization formats are not yet set in stone (and we're
  keen on hearing feedback before we lock things down more).

  Motivation: http://lists.fedoraproject.org/pipermail/devel/2012-December/175232.html

  I want to slurp the results from static code analysis into a database,
  which means coercing all of the results into some common interchange format,
  codenamed "firehose" (which could also be the name of the database).

  The idea is a common XML format that all tools can emit that:
    * describes a warning
    * gives source-code location of the warning: filename, function,
      line number.
    * optionally with a `CWE <http://cwe.mitre.org/about/index.html>`_
      identifier
    * potentially with other IDs and URLs, e.g. the ID "SIG30-C" with URL
      https://www.securecoding.cert.org/confluence/display/seccode/SIG30-C.+Call+only+asynchronous-safe+functions+within+signal+handlers
    * optionally describes code path to get there (potentially
      interprocedural across source files), potentially with "state"
      annotations (e.g. in the case of a reference-counting bug, it's useful
      to be able to annotate the changes to the refcount).

  together with a simple Python API for working with the format as a
  collection of Python objects (creating, write to XML, read from XML,
  modification, etc)

  I initially considered using JSON, but went with XML because if multiple
  tools are going to emit this, it's good to be able to validate things
  against a schema (see
  `firehose.rng <https://github.com/fedora-static-analysis/firehose/blob/master/firehose.rng>`_,
  a RELAX-NG schema).

  References to source files in the format can include a hash of the source
  file itself (e.g. SHA-1) so that you can uniquely identify which source file
  you were talking about.

  This format would be slurped into the DB for the web UI, and can have other
  things done to it without needing a server:
  e.g.:

    * convert it to the textual form of a gcc compilation error, so that
      Emacs etc can parse it and take you to the source
    * be turned into a simple HTML report locally on your workstation

  Projects using Firehose:

    * `mock-with-analysis <https://github.com/fedora-static-analysis/mock-with-analysis>`_
      can rebuild a source RPM, capturing the results of 4 different code
      analysis tools in Firehose format (along with all source files that
      were mentioned in any report).
    * The `"firehose" branch
      <http://git.fedorahosted.org/cgit/gcc-python-plugin.git/log/?h=firehose>`_
      of
      `cpychecker <https://gcc-python-plugin.readthedocs.org/en/latest/cpychecker.html>`_
      can natively emit Firehose XML reports
    * https://github.com/paultag/storz/blob/master/wrappers/storz-lintian


pkgId: fd2b5e83eda3b02a058f25b1dad81523a90cb3c51021d680d0d4bcf3e47fc3fc
name: python-first
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Return the first true value of an iterable.
url: http://github.com/hynek/first/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-25b13988-0dc6-4a75-a0ff-eb0e444fb34d
location_href: 00003635-python-first/python-first-2.0.2-1.src.rpm
checksum_type: sha256
description:
  ``first`` is an MIT-licensed Python package with a simple function that returns the first true value from an iterable, or ``None`` if there is none.
  If you need more power, you can also supply a ``key`` function that is used to judge the truth value of the element or a ``default`` value if ``None`` doesn’t fit your use case.
  N.B. I’m using the term “true” consistently with Python docs for ``any()`` and ``all()`` — it means that the value evaluates to true like: ``True``, ``1``, ``"foo"``, or ``[None]``.
  But **not**: ``None``, ``False``, ``[]``, or ``0``.
  In JavaScript, they call this “truthy”.


pkgId: c329390aef4c562431cf8f7a4d78f2c45af6ca13b6af3b094f5b8f36f5aa7d48
name: python-fissix
arch: src
version: 21.11.13
epoch: 0
release: 1
summary: Monkeypatches to override default behavior of lib2to3.
url: https://github.com/jreese/fissix
rpm_license: Python Software Foundation License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8d4d8907-7e9d-402d-9eee-40e4e7c5d5b0
location_href: 00003636-python-fissix/python-fissix-21.11.13-1.src.rpm
checksum_type: sha256
description:
  Backport of latest lib2to3, with enhancements.
  [![build status](https://travis-ci.org/jreese/fissix.svg?branch=master)](https://travis-ci.org/jreese/fissix)
  [![version](https://img.shields.io/pypi/v/fissix.svg)](https://pypi.org/project/fissix)
  [![license](https://img.shields.io/pypi/l/fissix.svg)](https://github.com/jreese/fissix/blob/master/LICENSE)
  [![code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)


pkgId: ecbeff2f70297020a425d761a2448b36a80dbbc50fed02590c87d08163d0f4a7
name: python-fitsio
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: A full featured python library to read from and write to FITS files.
url: https://github.com/esheldon/fitsio
rpm_license: GPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-51648e12-e92b-4d74-bc3e-75ee7b46cdf4
location_href: 00003638-python-fitsio/python-fitsio-1.1.8-1.src.rpm
checksum_type: sha256
description:
  A python library to read from and write to FITS files.

  [![Build Status (master)](https://travis-ci.com/esheldon/fitsio.svg?branch=master)](https://travis-ci.com/esheldon/fitsio)
  [![tests](https://github.com/esheldon/fitsio/workflows/tests/badge.svg)](https://github.com/esheldon/fitsio/actions?query=workflow%3Atests)



  This is a python extension written in c and python.  Data are read into
  numerical python arrays.

  A version of cfitsio is bundled with this package, there is no need to install
  your own, nor will this conflict with a version you have installed.




  - Read from and write to image, binary, and ascii table extensions.
  - Read arbitrary subsets of table columns and rows without loading all the data
    to memory.
  - Read image subsets without reading the whole image.  Write subsets to existing images.
  - Write and read variable length table columns.
  - Read images and tables using slice notation similar to numpy arrays.  This is like a more
    powerful memmap, since it is column-aware for tables.
  - Append rows to an existing table.  Delete row sets and row ranges. Resize tables,
      or insert rows.
  - Query the columns and rows in a table.
  - Read and write header keywords.
  - Read and write images in tile-compressed format (RICE,GZIP,PLIO,HCOMPRESS).
  - Read/write gzip files directly.  Read unix compress (.Z,.zip) and bzip2 (.bz2) files.
  - TDIM information is used to return array columns in the correct shape.
  - Write and read string table columns, including array columns of arbitrary
    shape.
  - Read and write complex, bool (logical), unsigned integer, signed bytes types.
  - Write checksums into the header and verify them.
  - Insert new columns into tables in-place.
  - Iterate over rows in a table.  Data are buffered for efficiency.
  - python 3 support, including python 3 strings




  ```python
  import fitsio
  from fitsio import FITS,FITSHDR






  filename='data.fits'
  data = fitsio.read(filename)


  data = fitsio.read(filename, rows=[35,1001], columns=['x','y'], ext=2)


  h = fitsio.read_header(filename)

  data,h = fitsio.read(filename, header=True)




  data = np.zeros(10, dtype=[('id','i8'),('ra','f8'),('dec','f8')])
  fitsio.write(filename, data)





  fitsio.write(filename, image)












  fits=fitsio.FITS('data.fits')


  print(fits)

  file: data.fits
  mode: READONLY
  extnum hdutype         hduname
  0      IMAGE_HDU
  1      BINARY_TBL      mytable



  >>> fits
  file: data.fits
  ... etc



  >>> fits[0]

  file: data.fits
  extension: 0
  type: IMAGE_HDU
  image info:
    data type: f8
    dims: [4096,2048]


  >>> fits['mytable']

  file: data.fits
  extension: 1
  type: BINARY_TBL
  extname: mytable
  rows: 4328342
  column info:
    i1scalar            u1
    f                   f4
    fvec                f4  array[2]
    darr                f8  array[3,2]
    dvarr               f8  varray[10]
    s                   S5
    svec                S6  array[3]
    svar                S0  vstring[8]
    sarr                S2  array[4,3]




  >>> fits[-1]
  ...







  img = fits[0].read()
  img = fits[0][:,:]


  img = fits[0][25:35, 45:55]



  data = fits[1].read()
  data = fits['mytable'].read()
  data = fits[1][:]




  data = fits[1].read(rows=[1,5], columns=['index','x','y'])



  data = fits[1][10:20]
  data = fits[1][10:20:2]
  data = fits[1][[1,5,18]]


  data = fits['SCI',2][10:20]


  data = fits[1][40:25]
  data = fits[1][40:25:-5]


  data = fits[1]['x'][:]



  data = fits[1]['x','y'][:]



  columns=['index','x','y']
  rows=[1,5]
  data = fits[1][columns][rows]



  fits=fitsio.FITS(filename,iter_row_buffer=1000)
  for row in fits[1]:
      print(row)


  for hdu in fits:
      data=hdu.read()










  fits = fitsio.FITS(filename,vstorage='object')

  data = fits[1].read(vstorage='object')
  print(data['dvarr'].dtype)
      dtype('object')



  hdu1 = fits[1]
  data = hdu1['x','y'][35:50]




  w=fits[1].where("x > 0.25 && y < 35.0")
  data = fits[1][w]


  h = fits[0].read_header()
  print(h['BITPIX'])
      -64

  fits.close()



  fits = FITS('test.fits','rw')




  nrows=35
  data = np.zeros(nrows, dtype=[('index','i4'),('vstr','O'),('x','f8'),
                                ('arr','f4',(3,4))])
  data['index'] = np.arange(nrows,dtype='i4')
  data['x'] = np.random.random(nrows)
  data['vstr'] = [str(i) for i in xrange(nrows)]
  data['arr'] = np.arange(nrows*3*4,dtype='f4').reshape(nrows,3,4)


  fits.write(data)


  array_list=[xarray,yarray,namearray]
  names=['x','y','name']
  fits.write(array_list, names=names)


  fits.write(dict_of_arrays)
  fits.write(dict_of_arrays, names=names) # control name order



  fits[-1].append(data2)


  fits[-1].insert_column('newcol', data)


  fits[-1].insert_column('newcol', data, colnum=2)


  fits[-1].write(data)


  fits[-1].write(data, firstrow=350)



  img=np.arange(2*3,dtype='i4').reshape(2,3)


  fits.write(img)


  fits.write(img, compress='rice')


  fimg=np.random.normal(size=2*3).reshape(2, 3)
  fits.write(img, compress='rice', qlevel=16, qmethod='SUBTRACTIVE_DITHER_2')


  fits.write(img, compress='gzip', qlevel=None)
  fits.write(fimg, compress='gzip', qlevel=None)


  fits[ext].write(img2)



  fits[ext].write(img3, start=[300,400])


  fits[ext].reshape([250,100])


  fits[-1].write_checksum()


  fits[-1].verify_checksum()






  hdict = {'somekey': 35, 'location': 'kitt peak'}
  fits.write(data, header=hdict)
  hlist = [{'name':'observer', 'value':'ES', 'comment':'who'},
           {'name':'location','value':'CTIO'},
           {'name':'photometric','value':True}]
  fits.write(data, header=hlist)
  hdr=FITSHDR(hlist)
  fits.write(data, header=hdr)


  fits[1].write_key(name, value, comment="my comment")



  fits[1].write_keys(records)


  fits[1].write_comment("observer JS")
  fits[1].write_comment("we had good weather")


  fits[1].write_history("processed with software X")
  fits[1].write_history("re-processed with software Y")

  fits.close()


  with FITS('path/to/file') as fits:
      data = fits[ext].read()

      
      if 'blah' in fits:
          data=fits['blah'].read()
      if 2 in f:
          data=fits[2].read()


  f[1].get_info()             # lots of info about the extension
  f[1].has_data()             # returns True if data is present in extension
  f[1].get_extname()
  f[1].get_extver()
  f[1].get_extnum()           # return zero-offset extension number
  f[1].get_exttype()          # 'BINARY_TBL' or 'ASCII_TBL' or 'IMAGE_HDU'
  f[1].get_offsets()          # byte offsets (header_start, data_start, data_end)
  f[1].is_compressed()        # for images. True if tile-compressed
  f[1].get_colnames()         # for tables
  f[1].get_colname(colnum)    # for tables find the name from column number
  f[1].get_nrows()            # for tables
  f[1].get_rec_dtype()        # for tables
  f[1].get_rec_column_descr() # for tables
  f[1].get_vstorage()         # for tables, storage mechanism for variable
                              


  f[1].lower           # If True, lower case colnames on output
  f[1].upper           # If True, upper case colnames on output
  f[1].case_sensitive  # if True, names are matched case sensitive
  ```




  The easiest way is using pip or conda. To get the latest release

      pip install fitsio

      
      pip install fitsio --upgrade

      
      pip install fitsio --upgrade --ignore-installed

      
      pip install fitsio --no-deps --upgrade --ignore-installed

      
      conda install -c conda-forge fitsio

  You can also get the latest source tarball release from

      https://pypi.python.org/pypi/fitsio

  or the bleeding edge source from github or use git. To check out
  the code for the first time

      git clone https://github.com/esheldon/fitsio.git

  Or at a later time to update to the latest

      cd fitsio
      git update

  Use tar xvfz to untar the file, enter the fitsio directory and type

      python setup.py install

  optionally with a prefix

      python setup.py install --prefix=/some/path



  - python 2 or python 3
  - a C compiler and build tools like `make`, `patch`, etc.
  - numpy (See the note below. Generally, numpy 1.11 or later is better.)




  There is a serious performance regression in numpy 1.10 that results
  in fitsio running tens to hundreds of times slower.  A fix may be
  forthcoming in a later release.  Please comment here if this
  has already impacted your work https://github.com/numpy/numpy/issues/6467




  The unit tests should all pass for full support.

  ```bash
  python -c "import fitsio; fitsio.test.test()"
  ```

  Some tests may fail if certain libraries are not available, such
  as bzip2.  This failure only implies that bzipped files cannot
  be read, without affecting other functionality.





  We bundle cfitsio partly because many deployed versions of cfitsio in the
  wild do not have support for interesting features like tiled image compression.
  Bundling a version that meets our needs is a safe alternative.



  Since numpy uses C order, FITS uses fortran order, we have to write the TDIM
  and image dimensions in reverse order, but write the data as is.  Then we need
  to also reverse the dims as read from the header when creating the numpy dtype,
  but read as is.



  As of version `1.0.0`, `fitsio` has been transitioned to `setuptools` for packaging
  and installation. There are many reasons to do this (and to not do this). However,
  at a practical level, what this means for you is that you may have trouble uninstalling
  older versions with `pip` via `pip uninstall fitsio`. If you do, the best thing to do is
  to manually remove the files manually. See this [stackoverflow question](https://stackoverflow.com/questions/402359/how-do-you-uninstall-a-python-package-that-was-installed-using-distutils)
  for example.



  As of version `1.0.0`, fitsio now supports Python 3 strings natively. This support
  means that for Python 3, native strings are read from and written correctly to
  FITS files. All byte string columns are treated as ASCII-encoded unicode strings
  as well. For FITS files written with a previous version of fitsio, the data
  in Python 3 will now come back as a string and not a byte string. Note that this
  support is not the same as full unicode support. Internally, fitsio only supports
  the ASCII character set.



  - HDU groups: does anyone use these? If so open an issue!


pkgId: f38dc90acd5f14d0d6ae3f5ee48b340739eb9b79aae40461ad8fe6def2f6f28d
name: python-fixtures
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Fixtures, reusable state for writing clean tests and more.
url: https://github.com/testing-cabal/fixtures
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86209f72-daa2-4c45-872a-66de3fb83b29
location_href: 00010106-python-fixtures/python-fixtures-4.0.1-1.src.rpm
checksum_type: sha256
description:
  * Python 3.6+
    This is the base language fixtures is written in and for.
  * pbr
    Used for version and release management of fixtures.
  The ``fixtures[streams]`` extra adds:
  * testtools <https://launchpad.net/testtools> 0.9.22 or newer.
    testtools provides helpful glue functions for the details API used to report
    information about a fixture (whether its used in a testing or production
    environment).
  For use in a unit test suite using the included glue, one of:
  * bzrlib.tests
  * Or any other test environment that supports TestCase.addCleanup.
  Writing your own glue code is easy, or you can simply use Fixtures directly
  without any support code.
  To run the test suite for fixtures, testtools is needed.


pkgId: f28f92a8a156765c9d1a959dae538a9e76317bfbca6bad68339555f5f1172fcc
name: python-flake8-broken-line
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Flake8 plugin to forbid backslashes for line breaks
url: https://github.com/wemake-services/flake8-broken-line
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-629a861d-78be-4fb0-b3e5-cd9627f0fceb
location_href: 00010610-python-flake8-broken-line/python-flake8-broken-line-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![wemake.services](https://img.shields.io/badge/-wemake.services-green.svg?label=%20&logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABGdBTUEAALGPC%2FxhBQAAAAFzUkdCAK7OHOkAAAAbUExURQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP%2F%2F%2F5TvxDIAAAAIdFJOUwAjRA8xXANAL%2Bv0SAAAADNJREFUGNNjYCAIOJjRBdBFWMkVQeGzcHAwksJnAPPZGOGAASzPzAEHEGVsLExQwE7YswCb7AFZSF3bbAAAAABJRU5ErkJggg%3D%3D)](https://wemake-services.github.io)
  [![Build Status](https://github.com/wemake-services/flake8-broken-line/workflows/test/badge.svg?branch=master&event=push)](https://github.com/wemake-services/flake8-broken-line/actions?query=workflow%3Atest)
  [![codecov](https://codecov.io/gh/wemake-services/flake8-broken-line/branch/master/graph/badge.svg)](https://codecov.io/gh/wemake-services/flake8-broken-line)
  [![Python Version](https://img.shields.io/pypi/pyversions/flake8-broken-line.svg)](https://pypi.org/project/flake8-broken-line/)
  [![PyPI version](https://badge.fury.io/py/flake8-broken-line.svg)](https://pypi.org/project/flake8-broken-line/)
  [![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)

  Do not break the line! 🚨




  ```bash
  pip install flake8-broken-line
  ```

  It is also a valuable part of [`wemake-python-styleguide`](https://github.com/wemake-services/wemake-python-styleguide).




  Things we check with this plugin:

  ```python


  some_string = 'first line\
  second line'



  if 1 == 1 and \
      2 == 2:
      print('Do not do that!')


  some_object \
    .call_method(param1, param2) \
    .call_other(keyword=value) \
    .finalize()


  some_objects.call_method(
      param1, param2,
  ).call_other(
      keyword=value
  ).finalize()

  ```




  | Error code |                   Description                  |
  |:----------:|:----------------------------------------------:|
  |    N400    | Found backslash that is used for line breaking |




  MIT.


pkgId: 796e5f31dc276c6a468d0fa1078f84c009af7f801f7e000577e854d91df034f5
name: python-flake8-bugbear
arch: src
version: 23.3.23
epoch: 0
release: 1
url: https://github.com/PyCQA/flake8-bugbear
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ad239806-0d1f-4ae6-9b1b-e406dae19adc
location_href: 00009563-python-flake8-bugbear/python-flake8-bugbear-23.3.23-1.src.rpm
checksum_type: sha256
summary:
  A plugin for flake8 finding likely bugs and design problems in your program. Contains warnings that don't belong in pyflakes and pycodestyle.


pkgId: 6d5ee3d689c0baca4390d97712ce667c9582d4b965ea1ed4f8980c0652281c5a
name: python-flake8-builtins
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Check for python builtins being used as variables or parameters.
url: https://github.com/gforcada/flake8-builtins
rpm_license: GPL version 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-980116ea-c065-478b-b77f-92fdfc8a8582
location_href: 00010149-python-flake8-builtins/python-flake8-builtins-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Check for python builtins being used as variables or parameters.
  Imagine some code like this:
      def max_values(list, list2):
          max = list[0]
          for x in list:
              if x > 0:
                  max = x
          all_values = list()
          all_values.append(max)
          max = list2[0]
          for x in list2:
              if x > 0:
                  max = x
          all_values.append(max)
          return all_values
      max_values([3, 4, 5, ], [5, 6, 7])
  The last statement is not returning ``[5, 7]`` as one would expect,
  instead is raising this exception::
      Traceback (most recent call last):
        File "test.py", line 17, in <module>
          max_values([3,4,5], [4,5,6])
        File "bla.py", line 6, in max_values
          all_values = list()
      TypeError: 'list' object is not callable
  **Why?** Because ``max_value`` function's first argument is ``list`` a Python builtin.
  Python allows to override them, but although could be useful in some really specific use cases,
  the general approach is to **not** do that as code then can suddenly break without a clear trace.


pkgId: b147d33e526c224b76d46f5ee465ea31537df66194307e4a47fc2435ebbe5a30
name: python-flake8-colors
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Error highlight plugin for Flake8.
url: https://github.com/and3rson/flake8-colors
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e8079b1a-c78e-475d-8296-1ceef26ed674
location_href: 00011792-python-flake8-colors/python-flake8-colors-0.1.9-1.src.rpm
checksum_type: sha256
description:
  ANSI colors highlight for Flake8



  1. Install plugin:

      ```
      pip install flake8-colors
      ```

  2. Use the following example format in your `.flake8` file:

      ```
      format = ${cyan}s${reset}:${yellow_bold}d${reset}:${green_bold}d${reset}: ${red_bold}s${reset} s
      ```

  3. Enjoy!

    ![Example image](https://habrastorage.org/files/0a7/cf5/47c/0a7cf547cd03457385c23691a4f29869.png)



  There are three forms of tags:

    - ${COLOR}
    - ${COLOR_MODIFIER}
    - ${TAG}

  Colors:

    - black
    - red
    - green
    - yellow
    - blue
    - purple
    - cyan
    - white

  Modifiers:

    - fg
    - bold
    - underline
    - bg

  Tags:

    - bold
    - underline
    - reset



  Inspired by [flake8-format-ansi](https://github.com/jayvdb/flake8-format-ansi/)



  Just do whatever you want to do.


pkgId: 0e1c107f15d7e64f97b31d1bc18e3f1d9aa137b83cc42acc9c56ea04bbdbb008
name: python-flake8-debugger
arch: src
version: 4.1.2
epoch: 0
release: 1
summary: ipdb/pdb statement checker plugin for flake8
url: https://github.com/jbkahn/flake8-debugger
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c971d477-0dac-4d9e-85e4-5f10f4fd11ad
location_href: 00010472-python-flake8-debugger/python-flake8-debugger-4.1.2-1.src.rpm
checksum_type: sha256
description:
  Check for pdb;idbp imports and set traces, as well as `from IPython.terminal.embed import InteractiveShellEmbed` and `InteractiveShellEmbed()()`.
  This module provides a plugin for ``flake8``, the Python code checker.


pkgId: 2c8ed39612a778d405e77552910d1ae9c84432dea662c677a86c3f546d2f049a
name: python-flake8-django
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Plugin to catch bad style specific to Django Projects.
url: https://github.com/rocioar/flake8-django
rpm_license: GPL-3.0-or-later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ba9249da-ca09-49ae-ba52-b2d3ba5e7115
location_href: 00012815-python-flake8-django/python-flake8-django-1.1.5-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/flake8-django.svg)](https://pypi.python.org/pypi/flake8-django/)
  ![CI](https://github.com/rocioar/flake8-django/workflows/CI/badge.svg)[![Codecov](https://codecov.io/gh/rocioar/flake8-django/branch/master/graph/badge.svg)](https://codecov.io/gh/rocioar/flake8-django)
  [![Downloads](https://pepy.tech/badge/flake8-django)](https://pepy.tech/project/flake8-django)

  A flake8 plugin to detect bad practices on Django projects.



  Install from pip with:

  ```
  $ pip install flake8-django
  ```



  flake8-django uses pytest for tests. To run them use:

  ```
  $ pytest
  ````

  Run coverage report using:

  ```
  $ pytest --cov=.
  ```



  | Rule | Description |
  | ---- | ----------- |
  | [`DJ01`](https://github.com/rocioar/flake8-django/wiki/%5BDJ01%5D-Avoid-using-null=True-on-string-based-fields-such-as-CharField-and-TextField) | Avoid using null=True on string-based fields such as CharField and TextField |
  | [`DJ03`](https://github.com/rocioar/flake8-django/wiki/%5BDJ03%5D-Avoid-passing-locals()-as-context-to-a-render-function) | Avoid passing locals() as context to a render function |
  | [`DJ06`](https://github.com/rocioar/flake8-django/wiki/%5BDJ06%5D-Do-not-use-exclude-with-ModelForm,-use-fields-instead) | Do not use exclude with ModelForm, use fields instead |
  | [`DJ07`](https://github.com/rocioar/flake8-django/wiki/%5BDJ07%5D-Do-not-set-fields-to-'__all__'-on-ModelForm,-use-fields-instead) | Do not use `__all__` with ModelForm, use fields instead |
  | [`DJ08`](https://github.com/rocioar/flake8-django/wiki/%5BDJ08%5D-Model-does-not-define-__str__-method) | Model does not define `__str__` method |
  | [`DJ12`](https://github.com/rocioar/flake8-django/wiki/%5BDJ12%5D-Order-of-Model's-inner-classes,-methods,-and-fields-does-not-follow-the-Django-Style-Guide) | Order of Model's inner classes, methods, and fields does not follow the [Django Style Guide](https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/coding-style/#model-style) |
  | [`DJ13`](https://github.com/rocioar/flake8-django/wiki/DJ13---@receiver-decorator-must-be-on-top-of-all-the-other-decorators) | @receiver decorator must be on top of all the other decorators |

  More details about each of the Rules can be found on the [wiki page](https://github.com/rocioar/flake8-django/wiki).



  | Rule | Description |
  | ---- | ----------- |
  | [`DJ10`](https://github.com/rocioar/flake8-django/wiki/%5BDJ10%5D-Model-should-define-verbose_name-on-its-Meta-inner-class) | Model should define verbose_name on its Meta inner class |
  | [`DJ11`](https://github.com/rocioar/flake8-django/wiki/%5BDJ11%5D-Model-should-define-verbose_name_plural-on-its-Meta-inner-class) | Model should define verbose_name_plural on its Meta inner class |

  To enable optional rules you can use the `--select` parameter. It's default values are: E,F,W,C90.

  For example, if you wanted to enable `DJ10`, you could call `flake8` in the following way:
  ```
  flake8 --select=E,F,W,C90,DJ,DJ10
  ```

  You could also add it to your configuration file:
  ```
  [flake8]
  max-line-length = 120
  ...
  select = C,E,F,W,DJ,DJ10
  ```



  GPL



  [@stummjr](https://github.com/stummjr) for teaching me AST, and what I could do with it. His [blog](https://stummjr.org/post/building-a-custom-flake8-plugin/) is cool.


pkgId: d8b5214c25d4e4148d39cb3858a11b1d382afc8e385f073d1afd7aff6d6944e1
name: python-flake8-docstrings
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Extension for flake8 which uses pydocstyle to check docstrings
url: https://github.com/pycqa/flake8-docstrings
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4a2287d2-ec92-47c4-93ba-c00934780584
location_href: 00003639-python-flake8-docstrings/python-flake8-docstrings-1.7.0-1.src.rpm
checksum_type: sha256
description:
  A simple module that adds an extension for the fantastic pydocstyle_ tool to
  flake8_.
  Simply install this extension::
      pip install flake8-docstrings
  and run flake8.
  You can set the pydocstyle convention_ at the command line using::
      $ flake8 --docstring-convention numpy ...
  Or, adding ``docstring-convention=numpy`` to your flake8 configuration file.
  The available set of conventions depends on the version of pydocstyle installed.
  The default is ``pep257``, pydocstyle v2.0.0 added ``numpy`` (for the numpydoc
  standard), while pydocstyle v4.0.0 added ``google``.
  In order to choose a custom list of error codes, use the special value
  ``docstring-convention=all``, then choose the codes you want checked using
  flake8_'s built-in ``--ignore``/``--select`` functionality.
  Report any issues on our `bug tracker`_.


pkgId: d62b2adc174d96f3546e787152d437f34bcb26684149d67758f72a582ba124f3
name: python-flake8-eradicate
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Flake8 plugin to find commented out code
url: https://github.com/wemake-services/flake8-eradicate
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-35ce4ca1-a6cd-490a-a134-f220497b6a58
location_href: 00010581-python-flake8-eradicate/python-flake8-eradicate-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![wemake.services](https://img.shields.io/badge/-wemake.services-green.svg?label=%20&logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABGdBTUEAALGPC%2FxhBQAAAAFzUkdCAK7OHOkAAAAbUExURQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP%2F%2F%2F5TvxDIAAAAIdFJOUwAjRA8xXANAL%2Bv0SAAAADNJREFUGNNjYCAIOJjRBdBFWMkVQeGzcHAwksJnAPPZGOGAASzPzAEHEGVsLExQwE7YswCb7AFZSF3bbAAAAABJRU5ErkJggg%3D%3D)](https://wemake-services.github.io)
  [![Build Status](https://github.com/wemake-services/flake8-eradicate/workflows/test/badge.svg?branch=master&event=push)](https://github.com/wemake-services/flake8-eradicate/actions?query=workflow%3Atest)
  [![codecov](https://codecov.io/gh/wemake-services/flake8-eradicate/branch/master/graph/badge.svg)](https://codecov.io/gh/wemake-services/flake8-eradicate)
  [![Python Version](https://img.shields.io/pypi/pyversions/flake8-eradicate.svg)](https://pypi.org/project/flake8-eradicate/)
  [![PyPI version](https://badge.fury.io/py/flake8-eradicate.svg)](https://pypi.org/project/flake8-eradicate/)
  [![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)

  `flake8` plugin to find commented out (or so called "dead") code.

  This is quite important for the project in a long run.
  Based on [`eradicate`](https://github.com/myint/eradicate) project.




  ```bash
  pip install flake8-eradicate
  ```

  It is also a valuable part of [`wemake-python-styleguide`](https://github.com/wemake-services/wemake-python-styleguide).




  Run your `flake8` checker [as usual](http://flake8.pycqa.org/en/latest/user/invocation.html).
  Commented code should raise an error.

  Example:

  ```bash
  flake8 your_module.py
  ```




  - `--eradicate-aggressive` to enable aggressive mode from `eradicate`, can lead to false positives
  - `--eradicate-whitelist` to overwrite the whitelist from `eradicate` (`#` separated list)
  - `--eradicate-whitelist-extend` to extend the whitelist from `eradicate` (`#` separated list)




  | Error code |        Description       |
  |:----------:|:------------------------:|
  |    E800    | Found commented out code |




  Here's how output looks like (we are using [`wemake` formatter](https://wemake-python-stylegui.de/en/latest/pages/usage/formatter.html)):


  ![flake8-eradicate output](https://raw.githubusercontent.com/wemake-services/flake8-eradicate/master/eradicate.png)




  MIT.


pkgId: 47e2d779146729111043f1d1f0ed17b19f0273b847d9ce664a4eadd8e3578932
name: python-flake8-import-order
arch: src
version: 0.18.2
epoch: 0
release: 1
summary: Flake8 and pylama plugin that checks the ordering of import statements.
url: https://github.com/PyCQA/flake8-import-order
rpm_license: LGPLv3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5f2e551-2738-4bd8-b722-d92a228ea872
location_href: 00003640-python-flake8-import-order/python-flake8-import-order-0.18.2-1.src.rpm
checksum_type: sha256
description:
  |Build Status|
  A `flake8 <http://flake8.readthedocs.org/en/latest/>`__ and `Pylama
  <https://github.com/klen/pylama>`__ plugin that checks the ordering of
  your imports. It does not check anything else about the
  imports. Merely that they are grouped and ordered correctly.
  In general stdlib comes first, then 3rd party, then local packages,
  and that each group is individually alphabetized, however this depends
  on the style used. Flake8-Import-Order supports a number of `styles
  <#styles>`_ and is extensible allowing for `custom styles
  <#extending-styles>`_.
  This plugin was originally developed to match the style preferences of
  the `cryptography <https://github.com/pyca/cryptography>`__ project,
  with this style remaining the default.


pkgId: f82e5c9e8305bd87af784832ac884c3471694aa5c895e2e79bec27ac3cc697c5
name: python-flake8-import-restrictions
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A flake8 plugin used to disallow certain forms of imports.
url: https://github.com/atollk/flake8-import-restrictions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c4225705-70ec-456e-a875-be0f0fef6f5c
location_href: 00011736-python-flake8-import-restrictions/python-flake8-import-restrictions-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/tox/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/pylint/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/black/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/flake8/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)

  A flake8 plugin used to disallow certain forms of imports.

  This plugin talks about the `import` syntax (`import X.Y.Z [as foo]`)
  and the `from` syntax (`from X.Y import Z [as foo]`). It talks about
  `import` segments (`import X`), `from` segments (`from Y`), and `as`
  segments (`as Z`).


  For every error `I20xx` listed below, there are options `--i20xx_include` and `--i20xx_exclude`
  which are passed a comma separated list of UNIX wildcard patterns each. The error
  will then only be reported on imports of modules that match a include pattern but no exclude
  pattern.

  By default, I2000, I2001, I2002, I2021, I2023, I2041, and I2043 include all (`*`) modules. Only I2041 excludes the
  `typing` module from checks, the other errors have no excludes by default.




  Imports should only happen on module level, not locally.

  ```python

  def f():
      import os.path
      return os.path.join("a", "b")


  import os.path
  def f():
      return os.path.join("a", "b")
  ```


  Alias identifiers defined from `as` segments should be at
  least two characters long.

  ```python

  import os.path as p


  import os.path as path
  ```


  Alias identifiers should not have the same name as the imported object.

  ```python

  import sys as sys


  import sys
  ```




  When using the `import` syntax, if the imported module is a submodule,
  i.e. not a top level module, an `as` segment should be present.

  ```python

  import os.path


  import sys
  import os.path as path
  ```


  When using the `import` syntax, each import statement should
  only import one module.

  ```python

  import sys, os


  import sys
  import os
  ```


  The `import` syntax should not be used.



  When using the `import` syntax, do not duplicate module names in the `as`
  segment.

  ```python

  import os.path as path


  from os import path
  import os.path as ospath
  ```





  When using the `from` syntax, the `import` segment only contains one
  import.

  ```python

  from os import path, environ


  from os import path
  from os import environ
  ```


  When using the `from` syntax, only submodules are imported, not
  module elements.

  ```python

  from os.path import join


  from os import path
  ```


  When using the `from` syntax, only module elements are imported,
  not submodules.

  ```python

  from os import path


  from os.path import join
  ```


  When using the `from` syntax, `import *` should not be used.

  ```python

  from os.path import *


  from os.path import join
  ```


  Relative imports should not be used.

  ```python

  from . import foo


  from flake8_import_restrictions import foo
  ```


  The `from` syntax should not be used.


pkgId: 1c1a2cfda7d5eceb811b268a3e89eb211636c3738fd2b7eef5f69f275f267091
name: python-flake8-import-restrictions-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for flake8-import-restrictions
url: https://github.com/atollk/flake8-import-restrictions
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c4225705-70ec-456e-a875-be0f0fef6f5c
rpm_sourcerpm: python-flake8-import-restrictions-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/tox/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/pylint/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/black/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)
  [![Build Status](https://github.com/atollk/flake8-import-restrictions/workflows/flake8/badge.svg)](https://github.com/atollk/flake8-import-restrictions/actions)

  A flake8 plugin used to disallow certain forms of imports.

  This plugin talks about the `import` syntax (`import X.Y.Z [as foo]`)
  and the `from` syntax (`from X.Y import Z [as foo]`). It talks about
  `import` segments (`import X`), `from` segments (`from Y`), and `as`
  segments (`as Z`).


  For every error `I20xx` listed below, there are options `--i20xx_include` and `--i20xx_exclude`
  which are passed a comma separated list of UNIX wildcard patterns each. The error
  will then only be reported on imports of modules that match a include pattern but no exclude
  pattern.

  By default, I2000, I2001, I2002, I2021, I2023, I2041, and I2043 include all (`*`) modules. Only I2041 excludes the
  `typing` module from checks, the other errors have no excludes by default.




  Imports should only happen on module level, not locally.

  ```python

  def f():
      import os.path
      return os.path.join("a", "b")


  import os.path
  def f():
      return os.path.join("a", "b")
  ```


  Alias identifiers defined from `as` segments should be at
  least two characters long.

  ```python

  import os.path as p


  import os.path as path
  ```


  Alias identifiers should not have the same name as the imported object.

  ```python

  import sys as sys


  import sys
  ```




  When using the `import` syntax, if the imported module is a submodule,
  i.e. not a top level module, an `as` segment should be present.

  ```python

  import os.path


  import sys
  import os.path as path
  ```


  When using the `import` syntax, each import statement should
  only import one module.

  ```python

  import sys, os


  import sys
  import os
  ```


  The `import` syntax should not be used.



  When using the `import` syntax, do not duplicate module names in the `as`
  segment.

  ```python

  import os.path as path


  from os import path
  import os.path as ospath
  ```





  When using the `from` syntax, the `import` segment only contains one
  import.

  ```python

  from os import path, environ


  from os import path
  from os import environ
  ```


  When using the `from` syntax, only submodules are imported, not
  module elements.

  ```python

  from os.path import join


  from os import path
  ```


  When using the `from` syntax, only module elements are imported,
  not submodules.

  ```python

  from os import path


  from os.path import join
  ```


  When using the `from` syntax, `import *` should not be used.

  ```python

  from os.path import *


  from os.path import join
  ```


  Relative imports should not be used.

  ```python

  from . import foo


  from flake8_import_restrictions import foo
  ```


  The `from` syntax should not be used.

location_href:
  00011736-python-flake8-import-restrictions/python-flake8-import-restrictions-help-1.1.1-1.noarch.rpm


pkgId: b7daa77e5d604220231a7384dafd5c421bc58e24558f63b276076870a91d8ec8
name: python-flake8-junit-report
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Simple tool that converts a flake8 file to junit format
url: https://github.com/initios/flake8-junit-report
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-953d23fd-1f3c-4164-afa8-a428a04eb4e5
location_href: 00012625-python-flake8-junit-report/python-flake8-junit-report-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Simple tool that converts a flake8 file to junit format.
  Use it on your CI server to see the flake8 failures with ease.
      * - Master
        - .. image:: https://travis-ci.org/initios/flake8-junit-report.svg?branch=master
        - .. image:: https://coveralls.io/repos/initios/flake8-junit-report/badge.svg?branch=master
      * - Develop
        - .. image:: https://travis-ci.org/initios/flake8-junit-report.svg?branch=develop
        - .. image:: https://coveralls.io/repos/initios/flake8-junit-report/badge.svg?branch=develop


pkgId: 891cbedf0af003c3d883279ae25b4f239ba39d93739632321529940e9c324ea0
name: python-flake8-logging-format
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/globality-corp/flake8-logging-format
rpm_license: Apache License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-55201956-3478-4971-8dc7-a11fd9410d30
location_href: 00010785-python-flake8-logging-format/python-flake8-logging-format-0.9.0-1.src.rpm
checksum_type: sha256
description:
  Flake8 extension to validate (lack of) logging format strings




  Python [logging](https://docs.python.org/3/library/logging.html#logging.Logger.debug) supports a special `extra` keyword
  for passing a dictionary of user-defined attributes to include in a logging event. One way to ensure consistency and
  rigor in logging is to **always** use `extra` to pass non-constant data and, therefore, to **never** use format strings,
  concatenation, or other similar techniques to construct a log string.

  In other words, do this:

  ```python
  logger.info(
      "Hello {world}",
      extra=dict(
          world="Earth"
      )
  )
  ```

  Instead of:

  ```python
  logger.info(
      "Hello {world}".format(world=Earth)
  )
  ```



  As a further level of rigor, we can enforce that `extra` dictionaries only use keys from a well-known whitelist.

  Usage:

  ```bash
  flake8 --enable-extra-whitelist
  ```

  The built-in `Whitelist` supports plugins using `entry_points` with a key of `"logging.extra.whitelist"`. Each
  registered entry point must be a callable that returns an iterable of string.

  In some cases you may want to log sensitive data only in debugging scenarios.  This is supported in 2 ways:
  1. We do not check the logging.extra.whitelist for lines logged at the `debug` level
  2. You may also prefix a keyword with 'debug\_' and log it at another level.  You can safely assume these will be
     filtered out of shipped logs.



   -  `G001` Logging statements should not use `string.format()` for their first argument
   -  `G002` Logging statements should not use `%` formatting for their first argument
   -  `G003` Logging statements should not use `+` concatenation for their first argument
   -  `G004` Logging statements should not use `f"..."` for their first argument (only in Python 3.6+)
   -  `G010` Logging statements should not use `warn` (use `warning` instead)
   -  `G100` Logging statements should not use `extra` arguments unless whitelisted
   -  `G101` Logging statement should not use `extra` arguments that clash with LogRecord fields
   -  `G200` Logging statements should not include the exception in logged string (use `exception` or `exc_info=True`)
   -  `G201` Logging statements should not use `error(..., exc_info=True)` (use `exception(...)` instead)
   -  `G202` Logging statements should not use redundant `exc_info=True` in `exception`

  These violations are disabled by default. To enable them for your project, specify the code(s) in your `setup.cfg`:

  ```ini
  [flake8]
  enable-extensions=G
  ```



  Our motivation has to do with balancing the needs of our team and those of our customers.
  On the one hand, developers and front-line support should be able to look at application logs. On the other hand, our customers don't want their data shared with anyone, including internal employees.

  The implementation approaches this in two ways:

  1. By trying to prevent the use of string concatenation in logs (vs explicit variable passing in the standard logging `extra` dictionary)

  2. By providing an (optional) mechanism for whitelisting which field names may appear in the `extra` dictionary

  Naturally, this _does not_ prevent developers from doing something like:

  ```python
  extra=dict(
      user_id=user.name,
  )
  ```

  but then avoiding a case like this falls back to other processes around pull-requests, code review and internal policy.


pkgId: 9977102a9c9a16867d66bace5086aea9d809e56f43534246bba30e41f841d43d
name: python-flake8-markdown
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Lints Python code blocks in Markdown files using flake8
url: https://github.com/johnfraney/flake8-markdown
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b07b42d7-e236-44f2-a708-a174e8dc0709
location_href: 00012196-python-flake8-markdown/python-flake8-markdown-0.4.0-1.src.rpm
checksum_type: sha256
description:
  [
  ![PyPI](https://img.shields.io/pypi/v/flake8-markdown.svg)
  ![PyPI](https://img.shields.io/pypi/pyversions/flake8-markdown.svg)
  ![PyPI](https://img.shields.io/github/license/johnfraney/flake8-markdown.svg)
  ](https://pypi.org/project/flake8-markdown/)
  [![TravisCI](https://travis-ci.com/johnfraney/flake8-markdown.svg?branch=master)](https://travis-ci.com/johnfraney/flake8-markdown)

  Flake8 Markdown lints [GitHub-style Python code blocks](https://help.github.com/en/articles/creating-and-highlighting-code-blocks#fenced-code-blocks) in Markdown files using [`flake8`](https://flake8.readthedocs.io/en/stable/).

  This package helps improve a Python project's documentation by ensuring that code samples are error-free.



  - Lints code blocks containing regular Python and Python interpreter code ([`pycon`](http://pygments.org/docs/lexers/#pygments.lexers.python.PythonConsoleLexer))
  - [pre-commit](#pre-commit-hook) hook to lint on commit



  Flake8 Markdown can be installed from PyPI using `pip` or your package manager of choice:

  ```
  pip install flake8-markdown
  ```





  You can use Flake8 Markdown as a CLI tool using the `flake8-markdown` command.

  `flake8-markdown` accepts one or more [globs](https://docs.python.org/3.7/library/glob.html) as its arguments.

  Example:

  ```console
  $ flake8-markdown "tests/samples/*.md"
  tests/samples/emphasized_lines.md:6:1: F821 undefined name 'emphasized_imaginary_function'
  tests/samples/basic.md:8:48: E999 SyntaxError: EOL while scanning string literal
  tests/samples/basic.md:14:7: F821 undefined name 'undefined_variable'
  ```



  You can also add `flake8-markdown` to your project using [pre-commit](https://pre-commit.com/). When configured, any staged Markdown files will be linted using `flake8-markdown` once you run `git commit`.

  To enable this hook in your local repository, add the following `repo` to your `.pre-commit-config.yaml` file:

  ```yaml

  repos:
    - repo: https://github.com/johnfraney/flake8-markdown
      rev: v0.4.0
      hooks:
        - id: flake8-markdown
  ```



  Everyone interacting in the project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [PyPA Code of Conduct](https://www.pypa.io/en/latest/code-of-conduct/).







  - Added support for `flake8` v5
  - Added support for `python` 3.10



  - Dropped support for `python` 3.6





  - Added support for `flake8` v4





  - [`pycon`](http://pygments.org/docs/lexers/#pygments.lexers.python.PythonConsoleLexer) code block support





  - Fixed pre-commit example in README





  - Added code for initial release


pkgId: 39869d03ee5eda2a48693d3ec43828b2349a72d8d8a016cfd7d7bdc8e39f8698
name: python-flake8-mutable
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: mutable defaults flake8 extension
url: https://github.com/ebeweber/flake8-mutable
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dedff7f1-f70e-4d86-b9f6-012d652d3a84
location_href: 00011295-python-flake8-mutable/python-flake8-mutable-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/flake8-mutable.svg)](https://pypi.python.org/pypi/flake8-mutable)

  Python's default arguments are evaluated at definition as opposed to when the function is invoked. This leads to unexpected behavior, as mutations persist between calls. For a more detailed explanation, see [The Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/writing/gotchas/#mutable-default-arguments).

  ```
  def fnc(a, b={}):
      pass
  foo.py:2:14: M511 - mutable default arg of type Dict
  ```

  ```
  pip install flake8-mutable
  ```


  - Callables

  - added MANIFEST.in

  [MIT](https://opensource.org/licenses/MIT)


pkgId: b5eff5306cd505e0275df161c2bf6e3ecaf6b8ee28fcf091d380e0fcffe7d0db
name: python-flake8-pie
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: A flake8 extension that implements misc. lints
url: https://github.com/sbdchd/flake8-pie
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ac9067c-ba63-4fd6-a707-bf1137dc7b4d
location_href: 00012136-python-flake8-pie/python-flake8-pie-0.16.0-1.src.rpm
checksum_type: sha256
description:
  > A flake8 extension that implements misc. lints





  Based on Clippy's
  [`let_and_return`](https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return)
  and Microsoft's TSLint rule
  [`no-unnecessary-local-variable`](https://github.com/Microsoft/tslint-microsoft-contrib).

  For more info on the structure of this lint, see the [accompanying blog
  post](https://steve.dignam.xyz/2018/12/16/creating-a-flake8-lint/).



  ```python

  def foo():
     x = bar()
     return x


  def foo():
     x, _ = bar()
     return x
  ```



  Warn about [Celery](https://pypi.org/project/celery/) task definitions that don't have explicit names.

  Note: this lint is kind of naive considering any decorator with a `.task()`
  method or any decorator called `shared_task()` a Celery decorator.



  ```python

  @app.task()
  def foo():
      pass


  @app.task(name="app_name.tasks.foo")
  def foo():
      pass
  ```



  The `crontab` class provided by Celery has some default args that are
  suprising to new users. Specifically, `crontab(hour="0,12")` won't run a task
  at midnight and noon, it will run the task at every minute during those two
  hours. This lint makes that call an error, forcing you to write
  `crontab(hour="0, 12", minute="*")`.

  Additionally, the lint is a bit more complex in that it requires you specify
  every smaller increment than the largest time increment you provide. So if you
  provide `days_of_week`, then you need to provide `hour`s and `minute`s
  explicitly.

  Note: if you like the default behavior of `crontab()` then you can either
  disable this lint or pass `"*"` for the `kwarg` value, e.g., `minutes="*"`.

  Also, since this lint is essentially a naive search for calls to a
  `crontab()` function, if you have a function named the same then this will
  cause false positives.



  Celery tasks can bunch up if they don't have expirations.

  This enforces specifying expirations in both the celery beat config dict and
  in `.apply_async()` calls.

  The same caveat applies about how this lint is naive.



  Be precise in what exceptions you catch. Bare `except:` handlers, catching `BaseException`, or catching `Exception` can lead to unexpected bugs.



  ```python

  try:
      save_file(name="export.csv")
  except:
      pass


  try:
      save_file(name="export.csv")
  except BaseException:
      pass


  try:
      save_file(name="export.csv")
  except Exception:
      pass


  try:
      save_file(name="export.csv")
  except (ValueError, Exception):
      pass



  try:
      save_file(name="export.csv")
  except OSError:
      pass
  ```



  Empty collections are fasley in Python so calling `len()` is unnecessary when
  checking for emptiness in an if statement/expression.

  Comparing to explicit scalars is allowed.

  ```python

  if len(foo): ...
  if not len(foo): ...


  if foo: ...
  if not foo: ...
  if len(foo) > 0: ...
  if len(foo) == 0: ...
  ```



  If statements/expressions evalute the truthiness of the their test argument,
  so calling `bool()` is unnecessary.

  Comparing to `True`/`False` is allowed.

  ```python

  if bool(foo): ...
  if not bool(foo): ...


  if foo: ...
  if not foo: ...
  if bool(foo) is True: ...
  if bool(foo) is False: ...
  ```



  Using `type()` doesn't take into account subclassess and type checkers won't
  refine the type, use `isinstance` instead.

  ```python

  if type(foo) == str: ...
  if type(foo) is str: ...
  if type(foo) in [int, str]: ...


  if isinstance(foo, str): ...
  if isinstance(foo, (int, str)): ...
  ```



  `pass` is unnecessary when definining a `class` or function with an empty
  body.

  ```python

  class BadError(Exception):
      """
      some doc comment
      """
      pass

  def foo() -> None:
      """
      some function
      """
      pass


  class BadError(Exception):
      """
      some doc comment
      """

  def foo() -> None:
      """
      some function
      """
  ```



  Comparisions without an assignment or assertion are probably a typo.

  ```python

  "foobar" in data
  res.json() == []
  user.is_authenticated() is True


  assert "foobar" in data
  foo = res.json() == []
  use.is_authenticated()
  ```



  Inheriting from `object` isn't necessary in Python 3.

  ```python

  class Foo(object):
      ...


  class Foo:
      ...
  ```



  Attempts to find cases where the `@dataclass` decorator is unintentionally
  missing.

  ```python

  class Foo:
      z: dict[int, int]
      def __init__(self) -> None: ...

  class Bar:
      x: list[str]


  class Bar(Foo):
      z: dict[int, int]

  @dataclass
  class Bar:
      x: list[str]
  ```



  Finds duplicate definitions for the same field, which can occur in large ORM
  model definitions.

  ```python

  class User(BaseModel):
      email = fields.EmailField()
      
      email = fields.EmailField()


  class User(BaseModel):
      email = fields.EmailField()
      
  ```



  Instead of defining various constant properties on a class, use the stdlib
  enum which typecheckers support for type refinement.

  ```python

  class Foo:
      A = "A"
      B = "B"
      C = "C"


  import enum
  class Foo(enum.Enum):
      A = "A"
      B = "B"
      C = "C"
  ```



  By default the stdlib enum allows multiple field names to map to the same
  value, this lint requires each enum value be unique.

  ```python

  class Foo(enum.Enum):
      A = "A"
      B = "B"
      C = "C"
      D = "C"


  class Foo(enum.Enum):
      A = "A"
      B = "B"
      C = "C"
      D = "D"
  ```



  Call `bool()` directly rather than reimplementing its functionality.

  ```python

  foo(is_valid=True if buzz() else False)


  foo(is_valid=bool(buzz()))
  ```



  Instead of using class to namespace functions, use a module.

  ```python

  class UserManager:
      class User(NamedTuple):
          name: str

      @classmethod
      def update_user(cls, user: User) -> None:
          ...

      @staticmethod
      def sync_users() -> None:
          ...


  class User(NamedTuple):
      name: str

  def update_user(user: User) -> None:
      ...

  def sync_users() -> None:
      ...
  ```



  Check that values are passed in when collections are created rather than
  creating an empty collection and then inserting.

  ```python

  bars = []
  bar = bar()
  bars.append(bar)


  bar = bar()
  bars = [bar]


  s = deque()
  s.append(foo)


  s = deque([foo])
  ```



  Check for unnecessary dict unpacking.

  ```python

  {**foo, **{"bar": 10}}


  {**foo, "bar": 10}
  ```



  Return boolean expressions directly instead of returning `True` and `False`.

  ```python

  def main():
      if foo > 5:
          return True
      return False


  def main():
      if foo > 5:
          return True
      else:
          return False


  def main():
      return foo > 5
  ```



  Remove unnecessary comprehensions for `any` and `all`

  ```python

  any([x.id for x in bar])
  all([x.id for x in bar])


  all(x.id for x in bar)
  any(x.id for x in bar)
  any({x.id for x in bar})
  ```



  Don't format strings before logging. Let `logging` interpolate arguments.

  This allows Sentry to aggregate logs, prevents raising exceptions if interpolation fails, and improves performance if the log level is disabled. See ["PyCQA/pylint#1788"](https://github.com/PyCQA/pylint/issues/1788#issuecomment-461279687).

  ```python

  logger.info("Login error for %s" % user)
  logger.info("Login error for %s, %s" % (user_id, name))


  logger.info("Login error for {}".format(user))
  logger.info("Login error for {}, {}".format(user_id, name))


  logger.info(f"Login error for {user}")
  logger.info(f"Login error for {user_id}, {name}")


  logger.info("Login error for %s", user)
  logger.info("Login error for %s, %s", user_id, name)
  ```



  As long as the keys of the dict are valid Python identifier names, we can safely
  remove the surrounding dict.

  ```python

  foo(**{"bar": True})


  foo(bar=True)
  foo(**buzz)
  foo(**{"bar foo": True})
  ```



  ```shell

  poetry install

  s/lint
  s/test
  ```



  Currently only checks for byte string literals.

  ```python

  "foo".encode()


  b"foo"
  "😀".encode()
  ```



  Instead of `assert`ing and catching the exception, use an if statement.

  ```python

  try:
      assert "@" in bar
  except AssertionError:
      ...


  if "@" in bar:
      ...
  ```



  `lambda: []` is equivalent to the builtin `list`

  ```python

  @dataclass
  class Foo:
      foo: List[str] = field(default_factory=lambda: [])


  @dataclass
  class Foo:
      foo: List[str] = field(default_factory=list)
  ```



  We can leave out the first argument to `range` in some cases since the default
  start position is 0.

  ```python

  range(0, 10)


  range(10)
  range(x, 10)
  range(0, 10, x)
  ```



  Bulk create multiple objects instead of executing O(N) queries.

  ```python

  [Item.objects.create(item) for item in items]


  [Item.objects.create(item) for item in [bar for bar in buzz]]


  (Item.objects.create(item) for item in items)


  Item.objects.insert(items)
  Item.objects.create(item)
  ```




  You can use `astpretty` to dump the AST of a piece of code.

  ```shell
  ./.venv/bin/astpretty <(pbpaste)
  ```



  ```shell




  rm -rf dist && poetry publish --build
  ```


pkgId: 56ae9f52678bdc9f63799e6276331ec4767ecbbaa7a3d7c02dedcffb780f5245
name: python-flake8-string-format
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: string format checker, plugin for flake8
url: https://github.com/xZise/flake8-string-format
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7c64b0de-0751-44ce-bfd9-20558983d612
location_href: 00011155-python-flake8-string-format/python-flake8-string-format-0.3.0-1.src.rpm
checksum_type: sha256
description:
  An extension for `Flake8 <https://pypi.python.org/pypi/flake8>`_ to check the
  strings and parameters using ``str.format``. It checks all strings whether they
  use numbered parameters with an implicit index which isn't support in
  Python 2.6.
  In all instances of ``'…'.format(…)`` it will also check whether there are
  enough parameters given. If the format call uses variable arguments, it'll just
  check whether the right types of arguments are present.


pkgId: 299341f24e43fe76ca5c46c950dff8487c30f619ece8657e21442dc18dff83d5
name: python-flameprof
arch: src
version: 0.4
epoch: 0
release: 1
summary: cProfile flamegraph generator
url: https://github.com/baverman/flameprof/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2e1a0fd1-f8db-49be-b971-3b2ae266eac3
location_href: 00012407-python-flameprof/python-flameprof-0.4-1.src.rpm
checksum_type: sha256
description:
  Via pip::
      pip install flameprof
  Or you can invoke ``flameprof.py`` directly::
      python flameprof.py input.prof > output.svg


pkgId: 1a1b7e22c99a3d34c31ceafe73077150a43fe2d10daf0792f27ff222b1bfe01f
name: python-flann
arch: src
version: 1.6.13
epoch: 0
release: 1
summary: flann is the python 3.6 bindings for FLANN - Fast Library for Approximate Nearest Neighbors.
url: https://github.com/pypa/flann
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7bda5fc3-6812-4704-980f-8dcc15b7fb64
location_href: 00003643-python-flann/python-flann-1.6.13-1.src.rpm
checksum_type: sha256
description:
  1. Introduction
  ~~~~~~~~~~~~~~~
  pyflann is the python bindings for `FLANN - Fast Library for Approximate
  Nearest Neighbors <http://www.cs.ubc.ca/research/flann/>`__.
  2. Install
  ~~~~~~~~~~
  For python2
  ^^^^^^^^^^^
  This package uses distutils, which is the default way of installing
  python modules. To install in your home directory, securely run the
  following:
      git clone https://github.com/primetang/pyflann.git
      cd pyflann
      [sudo] python setup.py install
  Or directly through ``pip`` to install it:
      [sudo] pip install pyflann
  For python3
  ^^^^^^^^^^^
  Please refer to `this
  issuse <https://github.com/primetang/pyflann/issues/1>`__ to modify the
  code.
  3. Usage
  ~~~~~~~~
  Use it just like the following code:
      from pyflann import *
      import numpy as np
      dataset = np.array(
          [[1., 1, 1, 2, 3],
           [10, 10, 10, 3, 2],
           [100, 100, 2, 30, 1]
           ])
      testset = np.array(
          [[1., 1, 1, 1, 1],
           [90, 90, 10, 10, 1]
           ])
      flann = FLANN()
      result, dists = flann.nn(
          dataset, testset, 2, algorithm="kmeans", branching=32, iterations=7, checks=16)
      print result
      print dists
      dataset = np.random.rand(10000, 128)
      testset = np.random.rand(1000, 128)
      flann = FLANN()
      result, dists = flann.nn(
          dataset, testset, 5, algorithm="kmeans", branching=32, iterations=7, checks=16)
      print result
      print dists


pkgId: c6660c5d49b67c612c4c54035583c4bff29e874ebdd50f57f9da6ffd17c496b2
name: python-flasgger
arch: src
version: 0.9.5
epoch: 0
release: 1
summary: Extract swagger specs from your flask project
url: https://github.com/flasgger/flasgger/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-911817db-8424-469a-bb59-2264c2263981
location_href: 00010293-python-flasgger/python-flasgger-0.9.5-1.src.rpm
checksum_type: sha256
description:
      parameters:
        - name: palette
          in: path
          type: string
          enum: ['all', 'rgb', 'cmyk']
          required: true
          default: all
      definitions:
        Palette:
          type: object
          properties:
            palette_name:
              type: array
              items:
                $ref: '#/definitions/Color'
        Color:
          type: string
      responses:
        200:
          description: A list of colors (may be filtered by palette)
          schema:
            $ref: '#/definitions/Palette'
          examples:
            rgb: ['red', 'green', 'blue']
      """
      all_colors = {
          'cmyk': ['cian', 'magenta', 'yellow', 'black'],
          'rgb': ['red', 'green', 'blue']
      }
      if palette == 'all':
          result = all_colors
      else:
          result = {palette: all_colors.get(palette)}
      return jsonify(result)
  app.run(debug=True)
  ```
  Now run:
  ```
  python colors.py
  ```
  And go to: [http://localhost:5000/apidocs/](http://localhost:5000/apidocs/)
  You should get:
  ![colors](docs/colors.png)

  Save a new file `colors.yml`
  ```yaml
  Example endpoint returning a list of colors by palette


pkgId: b681760839ce4204e00920b2fe253bdc4f3e2194461efef55f672a1c2030a0cc
name: python-flask-babel
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Adds i18n/l10n support fo Flask applications.
url: https://pypi.org/project/flask-babel/
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-923a76e3-2f07-4795-aac6-f87ae7cdff09
location_href: 00003647-python-flask-babel/python-flask-babel-3.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://github.com/python-babel/flask-babel/workflows/Tests/badge.svg?branch=master)
  [![PyPI](https://img.shields.io/pypi/v/flask-babel.svg?maxAge=2592000)](https://pypi.python.org/pypi/Flask-Babel)

  Implements i18n and l10n support for Flask. This is based on the Python
  [babel][] and [pytz][] modules.



  The latest documentation is available [here][docs].

  [babel]: https://github.com/python-babel/babel
  [pytz]: https://pypi.python.org/pypi/pytz/
  [docs]: https://python-babel.github.io/flask-babel/
  [semver]: https://semver.org/


pkgId: 66bb484164677de987bbf5921bf1c3f7b38828eb3f6df26936f51eeb0a6a5f8e
name: python-flask-healthz
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: A simple module to allow you to easily add health endpoints to your Flask application
url: https://github.com/fedora-infra/flask-healthz
rpm_license: BSD-3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-75e056b0-0cfe-470a-9b34-8f8cefa8798a
location_href: 00003654-python-flask-healthz/python-flask-healthz-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Define endpoints in your Flask application that Kubernetes can use as
  [liveness and readiness probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/).






  Register the blueprint on your Flask application:

  ```python
  from flask import Flask
  from flask_healthz import healthz

  app = Flask(__name__)
  app.register_blueprint(healthz, url_prefix="/healthz")
  ```

  Define the functions you want to use to check health. To signal an error, raise `flask_healthz.HealthError`.

  ```python
  from flask_healthz import HealthError

  def liveness():
      pass

  def readiness():
      try:
          connect_database()
      except Exception:
          raise HealthError("Can't connect to the database")
  ```

  Now point to those functions in the Flask configuration:

  ```python
  HEALTHZ = {
      "live": "yourapp.checks.liveness",
      "ready": "yourapp.checks.readiness",
  }
  ```

  It is possible to directly set callables in the configuration, so you could write something like:

  ```python
  HEALTHZ = {
      "live": lambda: None,
  }
  ```

  Check that the endpoints actually work:

  ```
  $ curl http://localhost/yourapp/healthz/live
  {"status": 200, "title": "OK"}
  $ curl http://localhost/yourapp/healthz/ready
  {"status": 200, "title": "OK"}
  ```

  Now your can configure Kubernetes or OpenShift to check for those endpoints.



  You can also use the provided Flask extension to register the `healthz` blueprint:

  ```python
  from flask import Flask
  from flask_healthz import Healthz

  app = Flask(__name__)
  Healthz(app)
  ```

  The rest of the configuration is identical.

  The extension has an additional option, `no_log`, that can disable logging of the HTTP requests
  handled by your healthz endpoints, to avoid cluttering your web log files with automated requests.
  At the moment, only the [gunicorn](https://gunicorn.org/) web server is supported.

  ```python
  Healthz(app, no_log=True)
  ```



  Here's an example of how you could use flask-healthz in OpenShift's `deploymentconfig`:

  ```yaml
  kind: DeploymentConfig
  spec:
    [...]
    template:
      [...]
      spec:
        containers:
        - name: yourapp
          [...]
          livenessProbe:
            httpGet:
              path: /healthz/live
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 1
          readinessProbe:
            httpGet:
              path: /healthz/ready
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 1
  ```

  Some projects that have setup flask-healthz:

  - Noggin: https://github.com/fedora-infra/noggin/pull/287
  - FASJSON: https://github.com/fedora-infra/fasjson/pull/81




  Copyright 2020-2021 Red Hat

  Flask-Healthz is licensed under the same license as Flask itself: BSD 3-clause.


  [![codecov](https://codecov.io/gh/fedora-infra/flask-healthz/branch/dev/graph/badge.svg?token=lwlZLiSImq)](https://codecov.io/gh/fedora-infra/flask-healthz)


pkgId: b4f7a9fecf66f2e3f873f1cb09cb535b08867adbd4de116c200efb0fb357853e
name: python-flask-marshmallow
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Flask + marshmallow for beautiful APIs
url: https://github.com/marshmallow-code/flask-marshmallow
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b51bedf3-00e8-4991-b142-ce347d251cda
location_href: 00010104-python-flask-marshmallow/python-flask-marshmallow-0.15.0-1.src.rpm
checksum_type: sha256
description:
  Flask-Marshmallow is a thin integration layer for `Flask`_ (a Python web framework) and `marshmallow`_ (an object serialization/deserialization library) that adds additional features to marshmallow, including URL and Hyperlinks fields for HATEOAS-ready APIs. It also (optionally) integrates with `Flask-SQLAlchemy <http://flask-sqlalchemy.pocoo.org/>`_.


pkgId: f8deaa2bd4fb81c16bff8bc7050ca5267cefde5ed3d46ecc484f78bfefe521ae
name: python-flask-mongoengine
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/mongoengine/flask-mongoengine
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2cbacc0c-58e3-4781-8721-08631fda1fba
location_href: 00011945-python-flask-mongoengine/python-flask-mongoengine-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Flask-MongoEngine is a Flask extension that provides integration with MongoEngine and WTF model forms.

description:
  A Flask extension that provides integration with `MongoEngine <http://mongoengine.org/>`_.
  For more information on MongoEngine please check out the `MongoEngine Documentation <http://docs.mongoengine.org/>`_.
  It handles connection management for your app.
  You can also use `WTForms <http://wtforms.simplecodes.com/>`_ as model forms for your models.


pkgId: 915210f22dfbae526223d84fc39aabcc1fc573e4df45fd7b31fc16d4984980b4
name: python-flask-ngrok
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: A simple way to demo Flask apps from your machine.
url: https://github.com/gstaff/flask-ngrok
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-798aabc3-d575-4d8c-a1ff-9e0e36819685
location_href: 00012711-python-flask-ngrok/python-flask-ngrok-0.0.25-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/flask-ngrok.svg)](https://badge.fury.io/py/flask-ngrok)

  A simple way to demo Flask apps from your machine.
  Makes your [Flask](http://flask.pocoo.org/) apps running on localhost available
   over the internet via the excellent [ngrok](https://ngrok.com/) tool.


  Python 3.6+ is required.



  ```bash
  pip install flask-ngrok
  ```

  Notebooks have [an issue](https://stackoverflow.com/questions/51180917/python-flask-unsupportedoperation-not-writable) with newer versions of Flask, so force an older version if working in these environments.
  ```bash
  !pip install flask==0.12.2
  ```


  1. Import with ```from flask_ngrok import run_with_ngrok```
  2. Add `run_with_ngrok(app)` to make your Flask app available upon running
  ```python

  from flask import Flask
  from flask_ngrok import run_with_ngrok

  app = Flask(__name__)
  run_with_ngrok(app)  # Start ngrok when app is run

  @app.route("/")
  def hello():
      return "Hello World!"

  if __name__ == '__main__':
      app.run()
  ```
  Running the example:
  ```bash
  python flask_ngrok_example.py
   * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
   * Running on http://<random-address>.ngrok.io
   * Traffic stats available on http://127.0.0.1:4040
  ```


pkgId: 7689c7a491b16026207b1a2b198bf2a58bb0a9722be0de76cb962657ca027587
name: python-flask-oidc
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: OpenID Connect extension for Flask
url: https://github.com/puiterwijk/flask-oidc
rpm_license: BSD License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fb45b5a0-2de4-4ed6-9e20-6f9d2635dc84
location_href: 00003663-python-flask-oidc/python-flask-oidc-1.4.0-1.src.rpm
checksum_type: sha256
description:
  `OpenID Connect <https://openid.net/connect/>`_ support for `Flask <http://flask.pocoo.org/>`_.
  This library should work with any standards compliant OpenID Connect provider.
  It has been tested with:
  * `Google+ Login <https://developers.google.com/accounts/docs/OAuth2Login>`_
  * `Ipsilon <https://ipsilon-project.org/>`_


pkgId: c64810421279bf8d4ea338657b0353e60c414fbd6194419006b9a17ff4335ab1
name: python-flask-shell-ipython
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Replace default `flask shell` command by similar command running IPython.
url: http://github.com/ei-grad/flask-shell-ipython
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a3fbd49-ec2e-4784-aa1c-c5da5f5c60ad
location_href: 00012168-python-flask-shell-ipython/python-flask-shell-ipython-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Replace default `flask shell` command by similar command running IPython.



  Just install:

      pip install flask-shell-ipython

  And here are you go:

      > flask shell
      Python 3.5.1 (default, Mar  3 2016, 09:29:07)
      [GCC 5.3.0] on linux
      IPython: 5.0.0
      App: discharges [debug]
      Instance: /home/ei-grad/repos/discharges/instance

      In [1]:


pkgId: f8e9cb7da7ad0bb02b4ae2617a1518b11021c86bb8c030b09ac257228b5a0826
name: python-flask-swagger
arch: src
version: 0.2.14
epoch: 0
release: 1
summary: Extract swagger specs from your flask project
url: https://github.com/gangverk/flask-swagger
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-81e02125-027e-4b9d-b115-ae1eb5226a93
location_href: 00009474-python-flask-swagger/python-flask-swagger-0.2.14-1.src.rpm
checksum_type: sha256
description:
  A Swagger 2.0 spec extractor for Flask
  Install:
      pip install flask-swagger
  Flask-swagger provides a method (swagger) that inspects the Flask app
  for endpoints that contain YAML docstrings with Swagger 2.0
  `Operation <https://github.com/swagger-api/swagger-spec/blob/master/versions/2.0.md#operation-object>`__
  objects.
      class UserAPI(MethodView):
          def post(self):
              """


pkgId: 2044c9de37c510e6978b7076c564d7ee27fb1b5ff3473ddc43aef336bb86fc3c
name: python-flask-swagger-ui
arch: src
version: 4.11.1
epoch: 0
release: 1
summary: Swagger UI blueprint for Flask
url: https://github.com/sveint/flask-swagger-ui
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2d10addb-52d8-4e52-abb3-9b25e123ee25
location_href: 00011623-python-flask-swagger-ui/python-flask-swagger-ui-4.11.1-1.src.rpm
checksum_type: sha256
description:
  Simple Flask blueprint for adding [Swagger UI](https://github.com/swagger-api/swagger-ui) to your flask application.

  Included Swagger UI version: 4.11.1.



  `pip install flask-swagger-ui`



  Example application:

  ```python
  from flask import Flask
  from flask_swagger_ui import get_swaggerui_blueprint

  app = Flask(__name__)


  SWAGGER_URL = '/api/docs'  # URL for exposing Swagger UI (without trailing '/')
  API_URL = 'http://petstore.swagger.io/v2/swagger.json'  # Our API url (can of course be a local resource)


  swaggerui_blueprint = get_swaggerui_blueprint(
      SWAGGER_URL,  # Swagger UI static files will be mapped to '{SWAGGER_URL}/dist/'
      API_URL,
      config={  # Swagger UI config overrides
          'app_name': "Test application"
      },
      
      
      
      
      
      
      
      
  )

  app.register_blueprint(swaggerui_blueprint)

  app.run()



  ```



  The blueprint supports overloading all Swagger UI configuration options that can be JSON serialized.
  See https://github.com/swagger-api/swagger-ui#parameters for options.

  Plugins and function parameters are not supported at this time.

  OAuth2 parameters can be found at https://github.com/swagger-api/swagger-ui#oauth2-configuration .


pkgId: ec7aa1c06f1a5778bfb1d09d6e528a708556eeeef95c9c964a8cd9a9040b4b46
name: python-flask-talisman
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: HTTP security headers for Flask.
url: https://github.com/wntrblm/flask-talisman
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4ca11419-1afc-4b28-bed5-c902f7523dcb
location_href: 00010247-python-flask-talisman/python-flask-talisman-1.0.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI Version|
  Talisman is a small Flask extension that handles setting HTTP headers
  that can help protect against a few common web application security
  issues.
  The default configuration:
  -  Forces all connects to ``https``, unless running with debug enabled.
  -  Enables `HTTP Strict Transport
     Security <https://developer.mozilla.org/en-US/docs/Web/Security/HTTP_strict_transport_security>`_.
  -  Sets Flask's session cookie to ``secure``, so it will never be set if
     your application is somehow accessed via a non-secure connection.
  -  Sets Flask's session cookie to ``httponly``, preventing JavaScript
     from being able to access its content. CSRF via Ajax uses a separate
     cookie and should be unaffected.
  -  Sets Flask's session cookie to ``Lax``, preventing the cookie to be leaked
     in CSRF-prone request methods.
  -  Sets
     `X-Frame-Options <https://developer.mozilla.org/en-US/docs/Web/HTTP/X-Frame-Options>`_
     to ``SAMEORIGIN`` to avoid
     `clickjacking <https://en.wikipedia.org/wiki/Clickjacking>`_.
  -  Sets `X-XSS-Protection
     <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-XSS-Protection>`_
     to enable a cross site scripting filter for IE and Safari (note Chrome has
     removed this and Firefox never supported it).
  -  Sets `X-Content-Type-Options
     <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options>`_
     to prevent content type sniffing.
  -  Sets a strict `Content Security
     Policy <https://developer.mozilla.org/en-US/docs/Web/Security/CSP/Introducing_Content_Security_Policy>`__
     of ``default-src: 'self', 'object-src': 'none'``. This is intended to almost completely
     prevent Cross Site Scripting (XSS) attacks. This is probably the only
     setting that you should reasonably change. See the
     `Content Security Policy`_ section.
  -  Sets a strict `Referrer-Policy <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy>`_
     of ``strict-origin-when-cross-origin`` that governs which referrer information should be included with
     requests made.
  In addition to Talisman, you **should always use a cross-site request
  forgery (CSRF) library**. It's highly recommended to use
  `Flask-SeaSurf <https://flask-seasurf.readthedocs.org/en/latest/>`_,
  which is based on Django's excellent library.


pkgId: f702b26e8a0211db4a9375187506ee3ce2a099b7120d781d7634d84f3d1ff731
name: python-flask-whooshee
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: Flask-SQLAlchemy - Whoosh Integration
url: https://github.com/bkabrda/flask-whooshee
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e7b394c3-4b35-45f0-b3b2-040db96d0a86
location_href: 00003676-python-flask-whooshee/python-flask-whooshee-0.8.2-1.src.rpm
checksum_type: sha256
description:
  Adds Whoosh integration to Flask-SQLAlchemy.
  Setup
  `````
  Flask-Whooshee supports two different methods of setting up the extension.
  You can either initialize it directly, thus binding it to a specific
  application instance:
      app = Flask(__name__)
      whooshee = Whooshee(app)
  and the second is to use the factory pattern which will allow you to
  configure whooshee at a later point:
      whooshee = Whooshee()
      def create_app():
          app = Flask(__name__)
          whooshee.init_app(app)
          return app
  Now you can create a basic whoosheer:
      @whooshee.register_model('title', 'content')
      class Entry(db.Model):
          id = db.Column(db.Integer, primary_key=True)
          title = db.Column(db.String)
          content = db.Column(db.Text)
  and finally you can search the model:
      Entry.query.whooshee_search('chuck norris').order_by(Entry.id.desc()).all()
  Links
  `````
  * `Documentation <https://flask-whooshee.readthedocs.io>`_
  * `Source Code <https://github.com/bkabrda/flask-whooshee>`_
  * `Issues <https://github.com/bkabrda/flask-whooshee/issues>`_


pkgId: b9641984c2490a4aeb39ad56c7710bd51cba50b435daa237b85fbeb730be64c5
name: python-flatbuffers
arch: src
version: 23.3.3
epoch: 0
release: 1
summary: The FlatBuffers serialization format for Python
url: https://google.github.io/flatbuffers/
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe1f4556-ae4c-48cf-8459-d6d06e86de2d
location_href: 00009082-python-flatbuffers/python-flatbuffers-23.3.3-1.src.rpm
checksum_type: sha256
description:
  Python runtime library for use with the `Flatbuffers <https://google.github.io/flatbuffers/>`_ serialization format.


pkgId: d2e26f629e2b007d60be08adba2d4e7c9040d38814e4668e9c9d3e2f319194fe
name: python-flatdict
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Python module for interacting with nested dicts as a single level dict with delimited keys.
url: https://github.com/gmr/flatdict
rpm_license: BSD 3-Clause License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f58108ca-3d06-42d8-b569-536591f66a35
location_href: 00010797-python-flatdict/python-flatdict-4.0.1-1.src.rpm
checksum_type: sha256
description:
  |Version| |Status| |Coverage| |License|
  ``FlatDict`` and ``FlatterDict`` are a dict classes that allows for single level,
  delimited key/value pair mapping of nested dictionaries. You can interact with
  ``FlatDict`` and ``FlatterDict`` like a normal dictionary and access child
  dictionaries as you normally would or with the composite key.
  *For example:*
      value = flatdict.FlatDict({'foo': {'bar': 'baz', 'qux': 'corge'}})
  *would be the same as:*
      value == {'foo:bar': 'baz', 'foo:qux': 'corge'}
  *values can be accessed as:*
      print(foo['foo:bar'])
      
      print(foo['foo']['bar'])
  Additionally, lists and tuples are also converted into dicts using ``enumerate()``,
  using the ``FlatterDict`` class.
  *For example:*
      value = flatdict.FlatterDict({'list': ['a', 'b', 'c']})
  *will be the same as:*
      value == {'list:0': 'a', 'list:1': 'b', 'list:2': 'c'}


pkgId: 9250fe37eca699aa347b7b07d794181bd3cd3edf7672095d9b401885c11ef3b2
name: python-flax
arch: src
version: 0.6.8
epoch: 0
release: 1
summary: Flax: A neural network library for JAX designed for flexibility
url: https://github.com/google/flax
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cbb969a0-190a-4ee7-8b28-93388d0dc729
location_href: 00009150-python-flax/python-flax-0.6.8-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
  <img src="https://raw.githubusercontent.com/google/flax/main/images/flax_logo_250px.png" alt="logo"></img>
  </div>



  ![Build](https://github.com/google/flax/workflows/Build/badge.svg?branch=main) [![coverage](https://badgen.net/codecov/c/github/google/flax)](https://codecov.io/github/google/flax)


  [**Overview**](#overview)
  | [**Quick install**](#quick-install)
  | [**What does Flax look like?**](#what-does-flax-look-like)
  | [**Documentation**](https://flax.readthedocs.io/)

  This README is a very short intro. **To learn everything you need to know about Flax, refer to our [full documentation](https://flax.readthedocs.io/).**

  Flax was originally started by engineers and researchers within the Brain Team in Google Research (in close collaboration with the JAX team), and is now developed jointly with the open source community.

  Flax is being used by a growing
  community of hundreds of folks in various Alphabet research departments
  for their daily work, as well as a [growing community
  of open source
  projects](https://github.com/google/flax/network/dependents?dependent_type=REPOSITORY).

  The Flax team's mission is to serve the growing JAX neural network
  research ecosystem -- both within Alphabet and with the broader community,
  and to explore the use-cases where JAX shines. We use GitHub for almost
  all of our coordination and planning, as well as where we discuss
  upcoming design changes. We welcome feedback on any of our discussion,
  issue and pull request threads. We are in the process of moving some
  remaining internal design docs and conversation threads to GitHub
  discussions, issues and pull requests. We hope to increasingly engage
  with the needs and clarifications of the broader ecosystem. Please let
  us know how we can help!

  Please report any feature requests,
  issues, questions or concerns in our [discussion
  forum](https://github.com/google/flax/discussions), or just let us
  know what you're working on!

  We expect to improve Flax, but we don't anticipate significant
  breaking changes to the core API. We use [Changelog](https://github.com/google/flax/tree/main/CHANGELOG.md)
  entries and deprecation warnings when possible.

  In case you want to reach us directly, we're at flax-dev@google.com.



  Flax is a high-performance neural network library and ecosystem for
  JAX that is **designed for flexibility**:
  Try new forms of training by forking an example and by modifying the training
  loop, not by adding features to a framework.

  Flax is being developed in close collaboration with the JAX team and
  comes with everything you need to start your research, including:

  * **Neural network API** (`flax.linen`): Dense, Conv, {Batch|Layer|Group} Norm, Attention, Pooling, {LSTM|GRU} Cell, Dropout

  * **Utilities and patterns**: replicated training, serialization and checkpointing, metrics, prefetching on device

  * **Educational examples** that work out of the box: MNIST, LSTM seq2seq, Graph Neural Networks, Sequence Tagging

  * **Fast, tuned large-scale end-to-end examples**: CIFAR10, ResNet on ImageNet, Transformer LM1b



  You will need Python 3.6 or later, and a working [JAX](https://github.com/google/jax/blob/main/README.md)
  installation (with or without GPU support - refer to [the instructions](https://github.com/google/jax/blob/main/README.md)).
  For a CPU-only version of JAX:

  ```
  pip install --upgrade pip # To support manylinux2010 wheels.
  pip install --upgrade jax jaxlib # CPU-only
  ```

  Then, install Flax from PyPi:

  ```
  pip install flax
  ```

  To upgrade to the latest version of Flax, you can use:

  ```
  pip install --upgrade git+https://github.com/google/flax.git
  ```
  To install some additional dependencies (like `matplotlib`) that are required but not included
  by some dependencies, you can use:

  ```bash
  pip install flax[all]
  ```



  We provide three examples using the Flax API: a simple multi-layer perceptron, a CNN and an auto-encoder.

  To learn more about the `Module` abstraction, check out our [docs](https://flax.readthedocs.io/), our [broad intro to the Module abstraction](https://github.com/google/flax/blob/main/docs/notebooks/linen_intro.ipynb). For additional concrete demonstrations of best practices, refer to our
  [guides](https://flax.readthedocs.io/en/latest/guides/index.html) and
  [developer notes](https://flax.readthedocs.io/en/latest/developer_notes/index.html).

  ```py
  from typing import Sequence

  import numpy as np
  import jax
  import jax.numpy as jnp
  import flax.linen as nn

  class MLP(nn.Module):
    features: Sequence[int]

    @nn.compact
    def __call__(self, x):
      for feat in self.features[:-1]:
        x = nn.relu(nn.Dense(feat)(x))
      x = nn.Dense(self.features[-1])(x)
      return x

  model = MLP([12, 8, 4])
  batch = jnp.ones((32, 10))
  variables = model.init(jax.random.PRNGKey(0), batch)
  output = model.apply(variables, batch)
  ```

  ```py
  class CNN(nn.Module):
    @nn.compact
    def __call__(self, x):
      x = nn.Conv(features=32, kernel_size=(3, 3))(x)
      x = nn.relu(x)
      x = nn.avg_pool(x, window_shape=(2, 2), strides=(2, 2))
      x = nn.Conv(features=64, kernel_size=(3, 3))(x)
      x = nn.relu(x)
      x = nn.avg_pool(x, window_shape=(2, 2), strides=(2, 2))
      x = x.reshape((x.shape[0], -1))  # flatten
      x = nn.Dense(features=256)(x)
      x = nn.relu(x)
      x = nn.Dense(features=10)(x)
      x = nn.log_softmax(x)
      return x

  model = CNN()
  batch = jnp.ones((32, 64, 64, 10))  # (N, H, W, C) format
  variables = model.init(jax.random.PRNGKey(0), batch)
  output = model.apply(variables, batch)
  ```

  ```py
  class AutoEncoder(nn.Module):
    encoder_widths: Sequence[int]
    decoder_widths: Sequence[int]
    input_shape: Sequence[int]

    def setup(self):
      input_dim = np.prod(self.input_shape)
      self.encoder = MLP(self.encoder_widths)
      self.decoder = MLP(self.decoder_widths + (input_dim,))

    def __call__(self, x):
      return self.decode(self.encode(x))

    def encode(self, x):
      assert x.shape[1:] == self.input_shape
      return self.encoder(jnp.reshape(x, (x.shape[0], -1)))

    def decode(self, z):
      z = self.decoder(z)
      x = nn.sigmoid(z)
      x = jnp.reshape(x, (x.shape[0],) + self.input_shape)
      return x

  model = AutoEncoder(encoder_widths=[20, 10, 5],
                      decoder_widths=[5, 10, 20],
                      input_shape=(12,))
  batch = jnp.ones((16, 12))
  variables = model.init(jax.random.PRNGKey(0), batch)
  encoded = model.apply(variables, batch, method=model.encode)
  decoded = model.apply(variables, encoded, method=model.decode)
  ```



  In-detail examples to train and evaluate a variety of Flax models for
  Natural Language Processing, Computer Vision, and Speech Recognition are
  actively maintained in the [🤗 Transformers repository](https://github.com/huggingface/transformers/tree/master/examples/flax).

  As of October 2021, the [19 most-used Transformer architectures](https://huggingface.co/transformers/#supported-frameworks) are supported in Flax
  and over 5000 pretrained checkpoints in Flax have been uploaded to the [🤗 Hub](https://huggingface.co/models?library=jax&sort=downloads).



  To cite this repository:

  ```
  @software{flax2020github,
    author = {Jonathan Heek and Anselm Levskaya and Avital Oliver and Marvin Ritter and Bertrand Rondepierre and Andreas Steiner and Marc van {Z}ee},
    title = {{F}lax: A neural network library and ecosystem for {JAX}},
    url = {http://github.com/google/flax},
    version = {0.6.8},
    year = {2023},
  }
  ```

  In the above bibtex entry, names are in alphabetical order, the version number
  is intended to be that from [flax/version.py](https://github.com/google/flax/blob/main/flax/version.py), and the year corresponds to the project's open-source release.



  Flax is an open source project maintained by a dedicated team in Google Research, but is not an official Google product.


pkgId: a11374dd4b94484f59d03939df944fbc2ee26c1851fee01f06f2f7d2b6130d6c
name: python-flex
arch: src
version: 6.14.1
epoch: 0
release: 1
summary: Swagger Schema validation.
url: https://github.com/pipermerriam/flex
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b9ac1dc3-8908-4cc2-9d96-32d8f6137077
location_href: 00011318-python-flex/python-flex-6.14.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://badgen.net/travis/pipermerriam/flex)](https://travis-ci.org/pipermerriam/flex)
  [![Documentation Status](https://readthedocs.org/projects/flex-swagger/badge/?version=latest)](https://readthedocs.org/projects/flex-swagger/?badge=latest)
  [![PyPi version](https://badgen.net/pypi/v/flex)](https://pypi.org/project/flex/)
  [![PyPi downloads](https://img.shields.io/pypi/dm/flex.svg)](https://pypi.python.org/pypi/flex)


  Validation tooling for [Swagger 2.0](https://github.com/wordnik/swagger-spec/blob/master/versions/2.0.md) specifications.


  [Documentation on ReadTheDocs](http://flex-swagger.readthedocs.org/en/latest/)



  * Validate swagger schemas.
  * JSON Schema Validation
  * Validation of request/response objects against schema.
  * Command Line interface.




  Starting in version 5.0.0 the CLI interface has been changed to `swagger-flex`
  due to a collision with the Apache Flex project.


pkgId: eb172bd79fb21b21477078ade977d51e18f500cf844bf78f9bdde5af06429035
name: python-flexmock
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: flexmock is a testing library for Python that makes it easy to create mocks, stubs and fakes.
url: https://github.com/flexmock/flexmock
rpm_license: BSD-2-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-44965196-cfc5-4aeb-9c38-177ed804f2d6
location_href: 00003681-python-flexmock/python-flexmock-0.11.3-1.src.rpm
checksum_type: sha256
description:
  Flexmock is a testing library for Python that makes it easy to create mocks, stubs, and fakes.

  - **Mock**: Easily create mock objects and make assertions about which methods or attributes were used and arguments they were called with.
  - **Spy**: Proxy calls to object's original methods or attributes and make assertions based on return values or call count.
  - **Fake**: Generate a fake objects to be used in your tests with ease.
  - **Stub**: Create stub objects which replace parts of existing objects and classes with just one call.
  - **No external dependencies**: Flexmock is lightweight and only uses Python standard library. There are no external dependencies.
  - **Simple and intuitive**: Declarations are structured to read more like English sentences than API calls, so they are easy to learn and use.
  - **Fully type annotated**: External API is fully type annotated so it works great with static analysis tools and editor auto-completion.
  - **Integrations with test runners**: Integrates seamlessly with all major test runners like unittest, doctest, and pytest.
  - **Python 3.6+ and PyPy3**: Extensively tested to work with latest Python versions.

  Install with pip:
  ```
  pip install flexmock
  ```

  Flexmock features smooth integration with pretty much every popular test runner, so no special setup is necessary. Simply importing flexmock into your test module is sufficient to get started with any of the following examples:
  ```python
  from flexmock import flexmock
  ```

  Assertions take many flavors and flexmock has many different facilities to generate them:
  ```python

  flexmock(Train).should_receive("get_tickets").once()

  flexmock(Train).should_receive("get_destination").and_return("Paris").once()

  flexmock(Train).should_receive("set_destination").with_args("Seoul").at_least().twice()
  ```

  Instead of mocking, there are also times when you want to execute the actual method and simply find out how many times it was called. Flexmock uses `should_call` to generate this sort of assertions instead of `should_receive`:
  ```python

  flexmock(Train).should_call("get_tickets").at_most().times(3)

  flexmock(Train).should_call("set_destination").with_args("Helsinki").never()

  flexmock(Train).should_call("crash").with_args(str, int).and_raise(AttributeError).once()
  ```
  See more examples in the documentation.

  User guide, examples, and a full API reference is available at: https://flexmock.readthedocs.io

  Contributions are absolutely welcome and encouraged! See [CONTRIBUTING.md](https://github.com/flexmock/flexmock/blob/master/CONTRIBUTING.md) to get started.


pkgId: c610eef76d350161a2147cf9330b264078d60449bbc80a3c1a4e55d81b6acb73
name: python-flock
arch: src
version: 0.1
epoch: 0
release: 1
url: https://github.com/misli/python-flock
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4417bd75-ef2a-4013-8d49-beb5cac40f95
location_href: 00003683-python-flock/python-flock-0.1-1.src.rpm
checksum_type: sha256
summary:
  Flock object uses fcntl.flock to lock (resp. unlock) file descriptor (fd) with operation (op) when entering (resp. leaving) runtime context related to it.


pkgId: 7c5c0c250a86fd9f7ec5b9ce3bd1554fafda9950c744302b73b6f604b842078f
name: python-fluent-logger
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: A Python logging handler for Fluentd event collector
url: https://github.com/fluent/fluent-logger-python
rpm_license: Apache License, Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ff730d2f-c43d-4223-ac05-509e4137bfd5
location_href: 00010299-python-fluent-logger/python-fluent-logger-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Many web/mobile applications generate huge amount of event logs (c,f.
  login, logout, purchase, follow, etc). To analyze these event logs could
  be really valuable for improving the service. However, the challenge is
  collecting these logs easily and reliably.
  `Fluentd <https://github.com/fluent/fluentd>`__ solves that problem by
  having: easy installation, small footprint, plugins, reliable buffering,
  log forwarding, etc.
  **fluent-logger-python** is a Python library, to record the events from
  Python application.


pkgId: bb27567558d42e23ea05f9666cfc13f02c64268faa101e0e8e928011e7c95f2a
name: python-fnvhash
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Pure Python FNV hash implementation
url: https://github.com/znerol/py-fnvhash
rpm_license: UNKNOWN
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7dd56c13-483e-4aa1-801d-3cc86696fc33
location_href: 00012356-python-fnvhash/python-fnvhash-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Pure Python implementation of the FNV_ hash family with 100% test coverage.
  Take a look at pyhash_ for use cases where performance is more important than
  portability.


pkgId: 806c2a249592eaf50ac1ba956dd3498a5ba84cd916cea7dceceb107695d9760a
name: python-folium
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Make beautiful maps with Leaflet.js & Python
url: https://github.com/python-visualization/folium
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-72776cf4-1952-41b6-b8d4-79c58840e92b
location_href: 00009801-python-folium/python-folium-0.14.0-1.src.rpm
checksum_type: sha256
description:
  |folium|
  Python Data, Leaflet.js Maps
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  `folium` builds on the data wrangling strengths of the Python ecosystem and the
  mapping strengths of the Leaflet.js library. Manipulate your data in Python,
  then visualize it in a Leaflet map via `folium`.


pkgId: 89b7a4ffeec422ec46bc26d75ad3eb08db8cb0aec78d17d3c29c7b8efadf38d6
name: python-fontconfig
arch: src
version: 0.1
epoch: 0
release: 1
summary: CFFI bindings for fontconfig
url: https://bitbucket.org/gm/fontconfig
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-9f0a8cc7-658f-4b55-ab32-edd3b15e1abd
location_href: 00003696-python-fontconfig/python-fontconfig-0.1-1.src.rpm
checksum_type: sha256
description:
  This package requires the `enum34`_ package. Install it via pypi:
     $ pip install enum34
  or use your distribution's package:
     $ apt-get install python-enum34
  To compile the ``_fontconfig`` extension, the following C headers are
  required:
     
     
     
     
  and the package `cffi`_. In Debian the following packages are enough:
     $ apt-get install python-cffi libfontconfig1-dev libfreetype6-dev
  Finally, to install the package itself:
     $ pip install fontconfig


pkgId: 7aab70a30387a760e256acec6a72fe3aea3fbfe53e068a2d18588ca60436a421
name: python-fontdump
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A cli tool to dump the CSS and different formats offonts for Google Fonts
url: https://github.com/glasslion/fontdump
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-64d7baf9-532b-4b38-b1cc-bde4ce931346
location_href: 00003697-python-fontdump/python-fontdump-1.3.0-1.src.rpm
checksum_type: sha256
description:
  A command line tool to dump the CSS and different formats of fonts for
  `Google Fonts <https://www.google.com/fonts>`__, so you can serve them
  on your local servers.
  Usage
  ~~~~~
      $ fontdump -h
      fontdump heps you dump google web fonts.
        __            _      _
       / _|          | |    | |
      | |_ ___  _ __ | |_ __| |_   _ _ __ ___  _ __
      |  _/ _ \| '_ \| __/ _` | | | | '_ ` _ \| '_ \
      | || (_) | | | | || (_| | |_| | | | | | | |_) |
      |_| \___/|_| |_|\__\__,_|\__,_|_| |_| |_| .__/
                                              | |
                                              |_|
      Usage:
        fontdump <google-fonts-url> [--font-dir-path=<path>]
        fontdump (-h | --help)
      Options:
        -h --help                 Show this screen.
        --font-dir-path=<path>    Path to the font dir(ends with /).
                                  e.g('staic/fonts/', 'http://cdn/.../fonts/')
        --output=<dir>            The directory saves the dumped css and font files
  FAQs
  ~~~~
  **Question**: What’s wrong with Google Fonts? Why do I want to serve the
  fonts on my own server?
  **Answer**: Google Fonts is Great. You shall use it normally. But for
  users in some countries, Google Fonts is very slow and sometimes even
  inaccessible. Serving your own fonts is the only choice for them.
  Besides, some developers may wish to have more control over web fonts.
  They might want to embed fonts as base64 strings into the css to bypass
  crazy firewalls. They might to store the fonts as jsons to the
  localstorage to speed up page loading.
  **Question**: Why do I need to install a software to download these
  fonts? Can't I just open the Chrome developer tools and download the css
  and fonts manually?
  **Answer**: Making css font rules compatible with different browsers is
  not easy. Thus Google detects the browser's User Agent string and serve
  the css that is only compatible with the given browser.
  As a web developer/designer, it is very likely that you are using a
  modern browser, so the css you get from Google only works in modern
  browsers. To improve the user experience for old browser users , we need
  to download the 4 differnet formats of fonts and merge the css rules
  into a single stylesheet. A tool can simplify the process.
  **Question**: What would the merged css look like?
  **Answer**:
  like this:
      @font-face {
        font-family: 'WebFont';
        src: url('webfont.eot'); /* IE9 Compat Modes */
        src: local('WebFont'),
             url('webfont.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
             url('webfont.woff') format('woff'), /* Modern Browsers */
             url('webfont.ttf')  format('truetype'), /* Safari, Android, iOS */
             url('webfont.svg#svgFontName') format('svg'); /* Legacy iOS */
      }
  Reference:
  ~~~~~~~~~~
  `Using
  @font-face <http://css-tricks.com/snippets/css/using-font-face/>`__
  `Bulletproof @font-face
  Syntax <http://www.paulirish.com/2009/bulletproof-font-face-implementation-syntax/>`__
  `WEBFONT
  GENERATOR <http://www.fontsquirrel.com/tools/webfont-generator>`__
  `Avoiding Faux Weights And Styles With Google Web
  Fonts <http://www.smashingmagazine.com/2012/07/11/avoiding-faux-weights-styles-google-web-fonts/>`__


pkgId: 2df21e0ed65109bd653ae11f006a1db3ef307d40fe25aa3e0853599125c815d8
name: python-fonttools
arch: src
version: 4.39.3
epoch: 0
release: 1
summary: Tools to manipulate font files
url: http://github.com/fonttools/fonttools
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7bc1d872-db02-4a1a-b86c-a82163e898df
location_href: 00009192-python-fonttools/python-fonttools-4.39.3-1.src.rpm
checksum_type: sha256
description:
  The ``fontTools`` package currently has no (required) external dependencies
  besides the modules included in the Python Standard Library.
  However, a few extra dependencies are required by some of its modules, which
  are needed to unlock optional features.
  The ``fonttools`` PyPI distribution also supports so-called "extras", i.e. a
  set of keywords that describe a group of additional dependencies, which can be
  used when installing via pip, or when specifying a requirement.
  For example:
      pip install fonttools[ufo,lxml,woff,unicode]
  This command will install fonttools, as well as the optional dependencies that
  are required to unlock the extra features named "ufo", etc.
  - ``Lib/fontTools/misc/etree.py``
    The module exports a ElementTree-like API for reading/writing XML files, and
    allows to use as the backend either the built-in ``xml.etree`` module or
    `lxml <https://lxml.de>`__. The latter is preferred whenever present,
    as it is generally faster and more secure.
    *Extra:* ``lxml``
  - ``Lib/fontTools/ufoLib``
    Package for reading and writing UFO source files; it requires:
    * `fs <https://pypi.org/pypi/fs>`__: (aka ``pyfilesystem2``) filesystem
      abstraction layer.
    * `enum34 <https://pypi.org/pypi/enum34>`__: backport for the built-in ``enum``
      module (only required on Python < 3.4).
    *Extra:* ``ufo``
  - ``Lib/fontTools/ttLib/woff2.py``
    Module to compress/decompress WOFF 2.0 web fonts; it requires:
    * `brotli <https://pypi.python.org/pypi/Brotli>`__: Python bindings of
      the Brotli compression library.
    *Extra:* ``woff``
  - ``Lib/fontTools/ttLib/sfnt.py``
    To better compress WOFF 1.0 web fonts, the following module can be used
    instead of the built-in ``zlib`` library:
    * `zopfli <https://pypi.python.org/pypi/zopfli>`__: Python bindings of
      the Zopfli compression library.
    *Extra:* ``woff``
  - ``Lib/fontTools/unicode.py``
    To display the Unicode character names when dumping the ``cmap`` table
    with ``ttx`` we use the ``unicodedata`` module in the Standard Library.
    The version included in there varies between different Python versions.
    To use the latest available data, you can install:
    * `unicodedata2 <https://pypi.python.org/pypi/unicodedata2>`__:
      ``unicodedata`` backport for Python 3.x updated to the latest Unicode
      version 15.0.
    *Extra:* ``unicode``
  - ``Lib/fontTools/varLib/interpolatable.py``
    Module for finding wrong contour/component order between different masters.
    It requires one of the following packages in order to solve the so-called
    "minimum weight perfect matching problem in bipartite graphs", or
    the Assignment problem:
    * `scipy <https://pypi.python.org/pypi/scipy>`__: the Scientific Library
      for Python, which internally uses `NumPy <https://pypi.python.org/pypi/numpy>`__
      arrays and hence is very fast;
    * `munkres <https://pypi.python.org/pypi/munkres>`__: a pure-Python
      module that implements the Hungarian or Kuhn-Munkres algorithm.
    *Extra:* ``interpolatable``
  - ``Lib/fontTools/varLib/plot.py``
    Module for visualizing DesignSpaceDocument and resulting VariationModel.
    * `matplotlib <https://pypi.org/pypi/matplotlib>`__: 2D plotting library.
    *Extra:* ``plot``
  - ``Lib/fontTools/misc/symfont.py``
    Advanced module for symbolic font statistics analysis; it requires:
    * `sympy <https://pypi.python.org/pypi/sympy>`__: the Python library for
      symbolic mathematics.
    *Extra:* ``symfont``
  - ``Lib/fontTools/t1Lib.py``
    To get the file creator and type of Macintosh PostScript Type 1 fonts
    on Python 3 you need to install the following module, as the old ``MacOS``
    module is no longer included in Mac Python:
    * `xattr <https://pypi.python.org/pypi/xattr>`__: Python wrapper for
      extended filesystem attributes (macOS platform only).
    *Extra:* ``type1``
  - ``Lib/fontTools/ttLib/removeOverlaps.py``
    Simplify TrueType glyphs by merging overlapping contours and components.
    * `skia-pathops <https://pypi.python.org/pypy/skia-pathops>`__: Python
      bindings for the Skia library's PathOps module, performing boolean
      operations on paths (union, intersection, etc.).
    *Extra:* ``pathops``
  - ``Lib/fontTools/pens/cocoaPen.py`` and ``Lib/fontTools/pens/quartzPen.py``
    Pens for drawing glyphs with Cocoa ``NSBezierPath`` or ``CGPath`` require:
    * `PyObjC <https://pypi.python.org/pypi/pyobjc>`__: the bridge between
      Python and the Objective-C runtime (macOS platform only).
  - ``Lib/fontTools/pens/qtPen.py``
    Pen for drawing glyphs with Qt's ``QPainterPath``, requires:
    * `PyQt5 <https://pypi.python.org/pypi/PyQt5>`__: Python bindings for
      the Qt cross platform UI and application toolkit.
  - ``Lib/fontTools/pens/reportLabPen.py``
    Pen to drawing glyphs as PNG images, requires:
    * `reportlab <https://pypi.python.org/pypi/reportlab>`__: Python toolkit
      for generating PDFs and graphics.
  - ``Lib/fontTools/pens/freetypePen.py``
    Pen to drawing glyphs with FreeType as raster images, requires:
    * `freetype-py <https://pypi.python.org/pypi/freetype-py>`__: Python binding
      for the FreeType library.
  - ``Lib/fontTools/ttLib/tables/otBase.py``
    Use the Harfbuzz library to serialize GPOS/GSUB using ``hb_repack`` method, requires:
    * `uharfbuzz <https://pypi.python.org/pypi/uharfbuzz>`__: Streamlined Cython
      bindings for the harfbuzz shaping engine
    *Extra:* ``repacker``
  How to make a new release
  ~~~~~~~~~~~~~~~~~~~~~~~~~
  1) Update ``NEWS.rst`` with all the changes since the last release. Write a
     changelog entry for each PR, with one or two short sentences summarizing it,
     as well as links to the PR and relevant issues addressed by the PR. Do not
     put a new title, the next command will do it for you.
  2) Use semantic versioning to decide whether the new release will be a 'major',
     'minor' or 'patch' release. It's usually one of the latter two, depending on
     whether new backward compatible APIs were added, or simply some bugs were fixed.
  3) Run ``python setup.py release`` command from the tip of the ``main`` branch.
     By default this bumps the third or 'patch' digit only, unless you pass ``--major``
     or ``--minor`` to bump respectively the first or second digit.
     This bumps the package version string, extracts the changes since the latest
     version from ``NEWS.rst``, and uses that text to create an annotated git tag
     (or a signed git tag if you pass the ``--sign`` option and your git and Github
     account are configured for `signing commits <https://docs.github.com/en/github/authenticating-to-github/managing-commit-signature-verification/signing-commits>`__
     using a GPG key).
     It also commits an additional version bump which opens the main branch for
     the subsequent developmental cycle
  4) Push both the tag and commit to the upstream repository, by running the command
     ``git push --follow-tags``. Note: it may push other local tags as well, be
     careful.
  5) Let the CI build the wheel and source distribution packages and verify both
     get uploaded to the Python Package Index (PyPI).
  6) [Optional] Go to fonttools `Github Releases <https://github.com/fonttools/fonttools/releases>`__
     page and create a new release, copy-pasting the content of the git tag
     message. This way, the release notes are nicely formatted as markdown, and
     users watching the repo will get an email notification. One day we shall
     automate that too.
  Acknowledgements
  ~~~~~~~~~~~~~~~~
  In alphabetical order:
  aschmitz, Olivier Berten, Samyak Bhuta, Erik van Blokland, Petr van Blokland,
  Jelle Bosma, Sascha Brawer, Tom Byrer, Antonio Cavedoni, Frédéric
  Coiffier, Vincent Connare, David Corbett, Simon Cozens, Dave Crossland,
  Simon Daniels, Peter Dekkers, Behdad Esfahbod, Behnam Esfahbod, Hannes
  Famira, Sam Fishman, Matt Fontaine, Takaaki Fuji, Yannis Haralambous, Greg
  Hitchcock, Jeremie Hornus, Khaled Hosny, John Hudson, Denis Moyogo Jacquerye,
  Jack Jansen, Tom Kacvinsky, Jens Kutilek, Antoine Leca, Werner Lemberg, Tal
  Leming, Peter Lofting, Cosimo Lupo, Olli Meier, Masaya Nakamura, Dave Opstad,
  Laurence Penney, Roozbeh Pournader, Garret Rieger, Read Roberts, Colin Rofls,
  Guido van Rossum, Just van Rossum, Andreas Seidel, Georg Seifert, Chris
  Simpkins, Miguel Sousa, Adam Twardoch, Adrien Tétar, Vitaly Volkov,
  Paul Wise.
  Copyrights
  ~~~~~~~~~~
  | Copyright (c) 1999-2004 Just van Rossum, LettError
    (just@letterror.com)
  | See `LICENSE <LICENSE>`__ for the full license.
  Copyright (c) 2000 BeOpen.com. All Rights Reserved.
  Copyright (c) 1995-2001 Corporation for National Research Initiatives.
  All Rights Reserved.
  Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam. All
  Rights Reserved.
  Have fun!
  Changelog
  ~~~~~~~~~


pkgId: 18c908d381cffb5f82fc1dc836cfe69637c1db733b8b58496aeaa6ad7fddce1a
name: python-forex-python
arch: src
version: 1.8
epoch: 0
release: 1
summary: Foreign exchange rates and currency conversion.
url: https://github.com/MicroPyramid/forex-python
rpm_license: MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-664e5305-5223-459c-8d50-51f773ad401b
location_href: 00011179-python-forex-python/python-forex-python-1.8-1.src.rpm
checksum_type: sha256
description:
  Forex Python is a Free Foreign exchange rates and currency conversion.
  Features:
  List all currency rates.
  BitCoin price for all curuncies.
  Converting amount to BitCoins.
  Get historical rates for any day since 1999.
  Conversion rate for one currency(ex; USD to INR).
  Convert amount from one currency to other.('USD 10$' to INR).
  Currency symbols.
  Currency names.

  Documentation: http://forex-python.readthedocs.io/en/latest/usage.html
  GitHub: https://github.com/MicroPyramid/forex-python


pkgId: 62cfa123367a2f41aa412a46800de0a9a419779f9527273f730a2e92a34b9c70
name: python-formats
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Support multiple formats with ease
url: https://github.com/redodo/formats
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-739672bd-2350-4149-b437-0fd5ede175f7
location_href: 00003701-python-formats/python-formats-0.1.1-1.src.rpm
checksum_type: sha256
description:
  |Version| |License|
  Installation via PIP::
      pip install --pre formats
  Quick usage overview::
      >>> import formats
      >>> formats.discover()
      >>> text = '''
      >>> formats.parse('yaml', text)
      {'awesome_things': ['dodos', 'pythons']}
      >>> formats.convert('yaml', 'json', text)
      '{"awesome_things": ["dodos", "pythons"]}'


pkgId: 0a26cff147b441736c1b1a254499da733ccfb6659891491043c4c520e63c2d6a
name: python-fortnitepy
arch: src
version: 3.6.8
epoch: 0
release: 1
summary: Library for interacting with fortnite services
url: https://github.com/Terbau/fortnitepy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7407c345-7bb1-47a9-9a9c-67135449bbea
location_href: 00009327-python-fortnitepy/python-fortnitepy-3.6.8-1.src.rpm
checksum_type: sha256
description:
   

  [![Supported py versions](https://img.shields.io/pypi/pyversions/fortnitepy.svg)](https://pypi.org/project/fortnitepy/)
  [![Current pypi version](https://img.shields.io/pypi/v/fortnitepy.svg)](https://pypi.org/project/fortnitepy/)
  [![Donate link](https://img.shields.io/badge/paypal-donate-blue.svg)](https://www.paypal.me/terbau)

  Asynchronous library for interacting with Fortnite and EpicGames' API and XMPP services.

  **Note:** This library is still under developement so breaking changes might happen at any time.

  **Some key features:**
  - Full support for Friends.
  - Support for XMPP events including friend and party messages + many more.
  - Support for Parties.
  - Support for Battle Royale stats.


  https://fortnitepy.readthedocs.io/en/latest/


  ```

  py -3 -m pip install -U fortnitepy


  python3 -m pip install -U fortnitepy
  ```


  ```py
  import fortnitepy
  import json
  import os

  from fortnitepy.ext import commands

  email = 'email@email.com'
  password = 'password1'
  filename = 'device_auths.json'

  def get_device_auth_details():
      if os.path.isfile(filename):
          with open(filename, 'r') as fp:
              return json.load(fp)
      return {}

  def store_device_auth_details(email, details):
      existing = get_device_auth_details()
      existing[email] = details

      with open(filename, 'w') as fp:
          json.dump(existing, fp)

  device_auth_details = get_device_auth_details().get(email, {})
  bot = commands.Bot(
      command_prefix='!',
      auth=fortnitepy.AdvancedAuth(
          email=email,
          password=password,
          prompt_authorization_code=True,
          prompt_code_if_invalid=True,
          delete_existing_device_auths=True,
          **device_auth_details
      )
  )

  @bot.event
  async def event_device_auth_generate(details, email):
      store_device_auth_details(email, details)

  @bot.event
  async def event_ready():
      print('----------------')
      print('Bot ready as')
      print(bot.user.display_name)
      print(bot.user.id)
      print('----------------')

  @bot.event
  async def event_friend_request(request):
      await request.accept()

  @bot.command()
  async def hello(ctx):
      await ctx.send('Hello!')

  bot.run()
  ```


  How to get a one time authorization code:
  1. Log into the epic games account of your choice [here](https://www.epicgames.com/id/logout?redirectUrl=https%3A//www.epicgames.com/id/login%3FredirectUrl%3Dhttps%253A%252F%252Fwww.epicgames.com%252Fid%252Fapi%252Fredirect%253FclientId%253D3446cd72694c4a4485d81b77adbb2141%2526responseType%253Dcode).
  2. Copy the hex part from the url that shows up as showcased by the image below:

  ![Authorization Code](https://raw.githubusercontent.com/Terbau/fortnitepy/dev/docs/resources/images/authorization_code.png)


  Thanks to [Kysune](https://github.com/SzymonLisowiec), [iXyles](https://github.com/iXyles), [Vrekt](https://github.com/Vrekt) and [amrsatrio](https://github.com/Amrsatrio) for ideas and/or work that this library is built upon.

  Also thanks to [discord.py](https://github.com/Rapptz/discord.py) for much inspiration code-wise.


  If you need more help feel free to join this [discord server](https://discord.gg/rnk869s).


pkgId: 9036286bc0260edda80a9d30502e522d997cff9b68cd92eceb8923e0240963e8
name: python-fpdf
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: Simple PDF generation for Python
url: http://code.google.com/p/pyfpdf
rpm_license: LGPLv3+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6e6499db-20ab-4d10-8b0f-5a790a75c639
location_href: 00010250-python-fpdf/python-fpdf-1.7.2-1.src.rpm
checksum_type: sha256
description:
  PyFPDF is a library for PDF document generation under Python, ported
  from PHP (see `FPDF <http://www.fpdf.org/>`__ "Free"-PDF, a well-known
  PDFlib-extension replacement with many examples, scripts and
  derivatives).
  Compared with other PDF libraries, PyFPDF is simple, small and
  versatile, with advanced capabilities and easy to learn, extend and
  maintain.


pkgId: 8bb25bf24dd269e74f68e85a8a433f3ccebe45617998ee3d32ad8b6e0b7d941b
name: python-fpylll
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: A Python interface for https://github.com/fplll/fplll
url: https://github.com/fplll/fpylll
rpm_license: GNU General Public License, version 2 or later
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c3434b9b-7684-4937-8547-f4b6367b4a08
location_href: 00003703-python-fpylll/python-fpylll-0.5.9-1.src.rpm
checksum_type: sha256
description:
  A Python wrapper for `fplll <https://github.com/fplll/fplll>`__.
      >>> from fpylll import *
      >>> A = IntegerMatrix(50, 50)
      >>> A.randomize("ntrulike", bits=50, q=127)
      >>> A[0].norm()
      3564748886669202.5
      >>> M = GSO.Mat(A)
      >>> M.update_gso()
      >>> M.get_mu(1,0)
      0.815748944429783
      >>> L = LLL.Reduction(M)
      >>> L()
      >>> M.get_mu(1,0)
      0.41812865497076024
      >>> A[0].norm()
      24.06241883103193
  The basic BKZ algorithm can be implemented in about 60 pretty readable lines of Python code (cf. `simple_bkz.py <https://github.com/fplll/fpylll/blob/master/src/fpylll/algorithms/simple_bkz.py>`__).
  For a quick tour of the library, you can check out the `tutorial <https://github.com/fplll/fpylll/blob/master/docs/tutorial.rst>`__.


pkgId: 3ebec23adf82182668bf37a84b3508ddefd8b49ec7d15919098575293e432d3f
name: python-fqdn
arch: src
version: 1.5.1
epoch: 0
release: 1
url: https://github.com/ypcrts/fqdn
rpm_license: MPL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8e4fb495-c590-44b7-90a9-dee87a13549c
location_href: 00011526-python-fqdn/python-fqdn-1.5.1-1.src.rpm
checksum_type: sha256
summary:
  Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers


pkgId: f240b3ea19165c51705c8b2d218e86c16252af4c78fec0ef5b97ecaa90110cb0
name: python-freezegun
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Let your Python tests travel through time
url: https://github.com/spulec/freezegun
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-bf08ee77-3740-4035-8b6d-a50f75675076
location_href: 00009224-python-freezegun/python-freezegun-1.2.2-1.src.rpm
checksum_type: sha256
description:
  FreezeGun is a library that allows your Python tests to travel through time by mocking the datetime module.


pkgId: b2204e2adb43944913a881fe83a9b9edc62634798063f1ff6369040a7e51858b
name: python-frozendict
arch: src
version: 2.3.5
epoch: 0
release: 1
summary: A simple immutable dictionary
url: https://github.com/Marco-Sulla/python-frozendict
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df9361d5-42b3-4e1a-9066-cd380b44c5e2
location_href: 00003709-python-frozendict/python-frozendict-2.3.5-1.src.rpm
checksum_type: sha256
description:
  * [Introduction](#introduction)
  * [API](#api)
  * [Examples](#examples)
  * [Building](#building)
  * [Benchmarks](#benchmarks)


  Welcome, fellow programmer!

  `frozendict` is a simple immutable dictionary. It's fast as `dict`, and
  [sometimes faster](https://github.com/Marco-Sulla/python-frozendict#benchmarks)!

  Unlike other similar implementations, immutability is guaranteed: you can't
  change the internal variables of the class, and they are all immutable
  objects.  Reinvoking `__init__` does not alter the object.

  The API is the same as `dict`, without methods that can change the
  immutability. So it supports also `fromkeys`, unlike other implementations.
  Furthermore it can be `pickle`d, un`pickle`d and have an hash, if all values
  are hashable.

  You can also add any `dict` to a `frozendict` using the `|` operator. The result is a new `frozendict`.


  The API is the same of `dict` of Python 3.10, without the methods and operands which alter the map. Additionally, `frozendict` supports these methods:



  If all the values of the `frozendict` are hashable, returns an hash, otherwise raises a TypeError.



  It returns a new `frozendict`. If key is already in the original `frozendict`, the new one will have it with the new value associated. Otherwise, the new `frozendict` will contain the new (key, value) item.



  It returns a new `frozendict` without the item corresponding to the key. If the key is not present, a KeyError is raised.



  If key is already in `frozendict`, the object itself is returned unchanged. Otherwise, the new `frozendict` will contain the new (key, default) item. The parameter default defaults to None.



  It returns the key at the specified index (determined by the insertion order). If index is not passed, it defaults to 0. If the index is negative, the position will be the size of the `frozendict` + index


  Same as `key(index)`, but it returns the value at the given index.


  Same as `key(index)`, but it returns a tuple with (key, value) at the given index.



  ```python
  from frozendict import frozendict

  fd = frozendict({"Guzzanti": "Corrado", "Hicks": "Bill"})

  print(fd)


  print(fd["Guzzanti"])


  fd["Brignano"]


  len(fd)


  "Guzzanti" in fd


  "Guzzanti" not in fd


  "Brignano" in fd


  hash(fd)


  fd_unhashable = frozendict({1: []})
  hash(fd_unhashable)


  fd | {1: 2}


  fd5 = frozendict(fd)
  id_fd5 = id(fd5)
  fd5 |= {1: 2}
  fd5

  id(fd5) != id_fd5


  fd.set(1, 2)


  fd.set("Guzzanti", "Sabina")


  fd.delete("Guzzanti")


  fd.setdefault("Guzzanti", "Sabina")


  fd.setdefault(1, 2)


  fd.key()


  fd.value(1)


  fd.item(-1)


  fd2 = fd.copy()
  fd2 == fd


  fd3 = frozendict(fd)
  fd3 == fd


  fd4 = frozendict({"Hicks": "Bill", "Guzzanti": "Corrado"})

  print(fd4)


  fd4 == fd


  import pickle
  fd_unpickled = pickle.loads(pickle.dumps(fd))
  print(fd_unpickled)

  fd_unpickled == fd


  frozendict(Guzzanti="Corrado", Hicks="Bill")


  frozendict((("Guzzanti", "Corrado"), ("Hicks", "Bill")))


  fd.get("Guzzanti")


  print(fd.get("Brignano"))


  tuple(fd.keys())


  tuple(fd.values())


  tuple(fd.items())


  frozendict.fromkeys(["Corrado", "Sabina"], "Guzzanti")


  iter(fd)


  fd["Guzzanti"] = "Caterina"

  ```


  You can build `frozendict` directly from the code, using

  ```
  python3 setup.py bdist_wheel
  ```

  The C Extension is not optional by default. You can build the pure py package using the `py` custom argument:

  ```
  python3 setup.py py bdist_wheel
  ```



  Some benchmarks between `dict` and `frozendict`[1]:

  ```

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size:    5; Keys: str; Type:       dict; Time: 8.02e-08; Sigma: 4e-09
  Name: `constructor(d)`;         Size:    5; Keys: str; Type: frozendict; Time: 8.81e-08; Sigma: 3e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size:    5; Keys: int; Type:       dict; Time: 7.96e-08; Sigma: 5e-09
  Name: `constructor(d)`;         Size:    5; Keys: int; Type: frozendict; Time: 8.97e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size: 1000; Keys: str; Type:       dict; Time: 6.38e-06; Sigma: 9e-08
  Name: `constructor(d)`;         Size: 1000; Keys: str; Type: frozendict; Time: 6.21e-06; Sigma: 2e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(d)`;         Size: 1000; Keys: int; Type:       dict; Time: 3.49e-06; Sigma: 3e-07
  Name: `constructor(d)`;         Size: 1000; Keys: int; Type: frozendict; Time: 3.48e-06; Sigma: 2e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(kwargs)`;    Size:    5; Keys: str; Type:       dict; Time: 2.40e-07; Sigma: 1e-09
  Name: `constructor(kwargs)`;    Size:    5; Keys: str; Type: frozendict; Time: 2.48e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(kwargs)`;    Size: 1000; Keys: str; Type:       dict; Time: 4.80e-05; Sigma: 1e-06
  Name: `constructor(kwargs)`;    Size: 1000; Keys: str; Type: frozendict; Time: 2.90e-05; Sigma: 7e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size:    5; Keys: str; Type:       dict; Time: 2.01e-07; Sigma: 9e-10
  Name: `constructor(seq2)`;      Size:    5; Keys: str; Type: frozendict; Time: 2.50e-07; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size:    5; Keys: int; Type:       dict; Time: 2.18e-07; Sigma: 2e-09
  Name: `constructor(seq2)`;      Size:    5; Keys: int; Type: frozendict; Time: 2.73e-07; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size: 1000; Keys: str; Type:       dict; Time: 4.29e-05; Sigma: 6e-07
  Name: `constructor(seq2)`;      Size: 1000; Keys: str; Type: frozendict; Time: 4.33e-05; Sigma: 6e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(seq2)`;      Size: 1000; Keys: int; Type:       dict; Time: 3.04e-05; Sigma: 4e-07
  Name: `constructor(seq2)`;      Size: 1000; Keys: int; Type: frozendict; Time: 3.45e-05; Sigma: 4e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size:    5; Keys: str; Type:       dict; Time: 7.93e-08; Sigma: 3e-09
  Name: `constructor(o)`;         Size:    5; Keys: str; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size:    5; Keys: int; Type:       dict; Time: 7.94e-08; Sigma: 5e-09
  Name: `constructor(o)`;         Size:    5; Keys: int; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size: 1000; Keys: str; Type:       dict; Time: 6.18e-06; Sigma: 3e-07
  Name: `constructor(o)`;         Size: 1000; Keys: str; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `constructor(o)`;         Size: 1000; Keys: int; Type:       dict; Time: 3.47e-06; Sigma: 2e-07
  Name: `constructor(o)`;         Size: 1000; Keys: int; Type: frozendict; Time: 2.41e-08; Sigma: 6e-10

  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size:    5; Keys: str; Type:       dict; Time: 7.28e-08; Sigma: 2e-09
  Name: `o.copy()`;               Size:    5; Keys: str; Type: frozendict; Time: 3.18e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size:    5; Keys: int; Type:       dict; Time: 7.21e-08; Sigma: 4e-09
  Name: `o.copy()`;               Size:    5; Keys: int; Type: frozendict; Time: 3.32e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size: 1000; Keys: str; Type:       dict; Time: 6.16e-06; Sigma: 3e-07
  Name: `o.copy()`;               Size: 1000; Keys: str; Type: frozendict; Time: 3.18e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o.copy()`;               Size: 1000; Keys: int; Type:       dict; Time: 3.46e-06; Sigma: 1e-07
  Name: `o.copy()`;               Size: 1000; Keys: int; Type: frozendict; Time: 3.18e-08; Sigma: 2e-09

  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size:    5; Keys: str; Type:       dict; Time: 7.23e-08; Sigma: 8e-10
  Name: `o == o`;                 Size:    5; Keys: str; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size:    5; Keys: int; Type:       dict; Time: 7.30e-08; Sigma: 1e-09
  Name: `o == o`;                 Size:    5; Keys: int; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size: 1000; Keys: str; Type:       dict; Time: 1.38e-05; Sigma: 1e-07
  Name: `o == o`;                 Size: 1000; Keys: str; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `o == o`;                 Size: 1000; Keys: int; Type:       dict; Time: 1.05e-05; Sigma: 7e-08
  Name: `o == o`;                 Size: 1000; Keys: int; Type: frozendict; Time: 2.44e-08; Sigma: 2e-09

  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size:    5; Keys: str; Type:       dict; Time: 7.33e-08; Sigma: 2e-09
  Name: `for x in o`;             Size:    5; Keys: str; Type: frozendict; Time: 6.70e-08; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size:    5; Keys: int; Type:       dict; Time: 7.33e-08; Sigma: 2e-09
  Name: `for x in o`;             Size:    5; Keys: int; Type: frozendict; Time: 6.70e-08; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size: 1000; Keys: str; Type:       dict; Time: 8.84e-06; Sigma: 5e-08
  Name: `for x in o`;             Size: 1000; Keys: str; Type: frozendict; Time: 7.06e-06; Sigma: 6e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o`;             Size: 1000; Keys: int; Type:       dict; Time: 8.67e-06; Sigma: 7e-08
  Name: `for x in o`;             Size: 1000; Keys: int; Type: frozendict; Time: 6.94e-06; Sigma: 3e-08

  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size:    5; Keys: str; Type:       dict; Time: 7.28e-08; Sigma: 9e-10
  Name: `for x in o.values()`;    Size:    5; Keys: str; Type: frozendict; Time: 6.48e-08; Sigma: 8e-10
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size:    5; Keys: int; Type:       dict; Time: 7.25e-08; Sigma: 1e-09
  Name: `for x in o.values()`;    Size:    5; Keys: int; Type: frozendict; Time: 6.45e-08; Sigma: 1e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size: 1000; Keys: str; Type:       dict; Time: 9.06e-06; Sigma: 5e-07
  Name: `for x in o.values()`;    Size: 1000; Keys: str; Type: frozendict; Time: 7.04e-06; Sigma: 4e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.values()`;    Size: 1000; Keys: int; Type:       dict; Time: 9.53e-06; Sigma: 3e-08
  Name: `for x in o.values()`;    Size: 1000; Keys: int; Type: frozendict; Time: 6.97e-06; Sigma: 3e-08

  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size:    5; Keys: str; Type:       dict; Time: 1.13e-07; Sigma: 3e-09
  Name: `for x in o.items()`;     Size:    5; Keys: str; Type: frozendict; Time: 1.16e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size:    5; Keys: int; Type:       dict; Time: 1.14e-07; Sigma: 3e-09
  Name: `for x in o.items()`;     Size:    5; Keys: int; Type: frozendict; Time: 1.17e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size: 1000; Keys: str; Type:       dict; Time: 1.53e-05; Sigma: 3e-07
  Name: `for x in o.items()`;     Size: 1000; Keys: str; Type: frozendict; Time: 1.53e-05; Sigma: 4e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `for x in o.items()`;     Size: 1000; Keys: int; Type:       dict; Time: 1.53e-05; Sigma: 3e-07
  Name: `for x in o.items()`;     Size: 1000; Keys: int; Type: frozendict; Time: 1.55e-05; Sigma: 4e-07

  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size:    5; Keys: str; Type:       dict; Time: 6.82e-07; Sigma: 2e-08
  Name: `pickle.dumps(o)`;        Size:    5; Keys: str; Type: frozendict; Time: 2.86e-06; Sigma: 1e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size:    5; Keys: int; Type:       dict; Time: 4.77e-07; Sigma: 2e-08
  Name: `pickle.dumps(o)`;        Size:    5; Keys: int; Type: frozendict; Time: 2.72e-06; Sigma: 8e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: str; Type:       dict; Time: 1.24e-04; Sigma: 4e-06
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: str; Type: frozendict; Time: 1.92e-04; Sigma: 5e-06
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: int; Type:       dict; Time: 2.81e-05; Sigma: 6e-07
  Name: `pickle.dumps(o)`;        Size: 1000; Keys: int; Type: frozendict; Time: 7.37e-05; Sigma: 1e-06

  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size:    5; Keys: str; Type:       dict; Time: 9.08e-07; Sigma: 6e-09
  Name: `pickle.loads(dump)`;     Size:    5; Keys: str; Type: frozendict; Time: 1.79e-06; Sigma: 9e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size:    5; Keys: int; Type:       dict; Time: 4.46e-07; Sigma: 6e-09
  Name: `pickle.loads(dump)`;     Size:    5; Keys: int; Type: frozendict; Time: 1.32e-06; Sigma: 7e-08
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: str; Type:       dict; Time: 1.57e-04; Sigma: 8e-06
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: str; Type: frozendict; Time: 1.69e-04; Sigma: 7e-06
  ////////////////////////////////////////////////////////////////////////////////
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: int; Type:       dict; Time: 5.97e-05; Sigma: 5e-06
  Name: `pickle.loads(dump)`;     Size: 1000; Keys: int; Type: frozendict; Time: 6.68e-05; Sigma: 2e-06

  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size:    5; Keys: str; Type:       dict; Time: 1.88e-07; Sigma: 1e-09
  Name: `class.fromkeys()`;       Size:    5; Keys: str; Type: frozendict; Time: 2.22e-07; Sigma: 7e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size:    5; Keys: int; Type:       dict; Time: 2.08e-07; Sigma: 6e-09
  Name: `class.fromkeys()`;       Size:    5; Keys: int; Type: frozendict; Time: 2.44e-07; Sigma: 2e-09
  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size: 1000; Keys: str; Type:       dict; Time: 4.05e-05; Sigma: 4e-06
  Name: `class.fromkeys()`;       Size: 1000; Keys: str; Type: frozendict; Time: 3.84e-05; Sigma: 5e-07
  ////////////////////////////////////////////////////////////////////////////////
  Name: `class.fromkeys()`;       Size: 1000; Keys: int; Type:       dict; Time: 2.93e-05; Sigma: 7e-07
  Name: `class.fromkeys()`;       Size: 1000; Keys: int; Type: frozendict; Time: 3.08e-05; Sigma: 2e-06

  ```

  [1] Benchmarks done under Linux 64 bit, Python 3.10.2, using the C Extension.


pkgId: bf5e07537147b6f084faf3acf34dd8f90b715383496ea103e67b14be3bdc51d0
name: python-frozendict-debuginfo
arch: aarch64
version: 2.3.5
epoch: 0
release: 1
summary: Debug information for package python-frozendict
url: https://github.com/Marco-Sulla/python-frozendict
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-df9361d5-42b3-4e1a-9066-cd380b44c5e2
rpm_sourcerpm: python-frozendict-2.3.5-1.src.rpm
location_href: 00003709-python-frozendict/python-frozendict-debuginfo-2.3.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-frozendict.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 62bff6cf78fe1a5f1e1ff9abf9847a1d0dcdcc09a0264b1247ef9d6086fca785
name: python-frozendict-debugsource
arch: aarch64
version: 2.3.5
epoch: 0
release: 1
summary: Debug sources for package python-frozendict
url: https://github.com/Marco-Sulla/python-frozendict
rpm_license: LGPL v3
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-df9361d5-42b3-4e1a-9066-cd380b44c5e2
rpm_sourcerpm: python-frozendict-2.3.5-1.src.rpm
location_href: 00003709-python-frozendict/python-frozendict-debugsource-2.3.5-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-frozendict.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 3bdc2cacd673e659b10beb9fc725558947d04b82d15fc718b315bf8d547256a6
name: python-frozenlist-debuginfo
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug information for package python-frozenlist
url: https://github.com/aio-libs/frozenlist
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dfc3e073-4926-4d3c-996f-662efce33dea
rpm_sourcerpm: python-frozenlist-1.3.3-1.src.rpm
location_href: 00008967-python-frozenlist/python-frozenlist-debuginfo-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-frozenlist.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: f0571f92d65c09cc17035beb3456f6e8b177d6197c75e75338a728d3a6c5e637
name: python-frozenlist-debugsource
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug sources for package python-frozenlist
url: https://github.com/aio-libs/frozenlist
rpm_license: Apache 2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-dfc3e073-4926-4d3c-996f-662efce33dea
rpm_sourcerpm: python-frozenlist-1.3.3-1.src.rpm
location_href: 00008967-python-frozenlist/python-frozenlist-debugsource-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-frozenlist.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: d62297d078ea000caeb1a025fc09a5d78d35c393e9a50ed672670cc33a0e19cc
name: python-fsleyes
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: FSLeyes, the FSL image viewer
url: https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-70c87f8f-a0c8-426c-a946-3bb33c44bb5b
location_href: 00003711-python-fsleyes/python-fsleyes-1.6.1-1.src.rpm
checksum_type: sha256
description:
  `FSLeyes <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes>`_ is the `FSL
  <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki>`_ image viewer.


pkgId: 560394af08b3b595944095aff4004aa208f8aa533aa31c9f69369c0e8ae3de6d
name: python-fsleyes-props
arch: src
version: 1.9.1
epoch: 0
release: 1
summary: [wx]Python event programming framework
url: https://git.fmrib.ox.ac.uk/fsl/fsleyes/props
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fe8d0839-365e-4727-b86a-ab3cfe81b453
location_href: 00003712-python-fsleyes-props/python-fsleyes-props-1.9.1-1.src.rpm
checksum_type: sha256
description:
  ``fsleyes-props`` is a library which is used by used by `FSLeyes
  <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes>`_, and which allows you to:
    - Listen for change to attributes on a python object,
    - Automatically generate ``wxpython`` widgets which are bound
      to attributes of a python object
    - Automatically generate a command line interface to set
      values of the attributes of a python object.
  To do this, you just need to subclass the ``fsleyes)props.HasProperties``
  class (also available as ``fsleyes_props.Props``), and add some
  ``PropertyBase`` types as class attributes.


pkgId: f039ffe7453b39693501cc54b2343ed5b14bd878bf18f3abab7d786232a2d7f7
name: python-fsleyes-widgets
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: A collection of wxPython widgets used by FSLeyes
url: https://git.fmrib.ox.ac.uk/fsl/fsleyes/widgets
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b936ad86-ae1a-49f0-bf9f-2e339a6aaac9
location_href: 00003713-python-fsleyes-widgets/python-fsleyes-widgets-0.13.0-1.src.rpm
checksum_type: sha256
description:
  The ``fsleyes-widgets`` package contains a collection of GUI widgets and
  utilities, based on `wxPython <http://www.wxpython.org>`_. These widgets are
  used by `fsleyes-props <https://git.fmrib.ox.ac.uk/fsl/fsleyes/props>`_ and
  `FSLeyes <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes>`_,


pkgId: 36910422c9e9127a42d57247e1a80167e727d30bfb851078577755dd5718246d
name: python-fslpy
arch: src
version: 3.11.3
epoch: 0
release: 1
summary: FSL Python library
url: https://git.fmrib.ox.ac.uk/fsl/fslpy
rpm_license: Apache License Version 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ecde4dfc-c6be-4054-91af-768a139baa11
location_href: 00003714-python-fslpy/python-fslpy-3.11.3-1.src.rpm
checksum_type: sha256
description:
  The ``fslpy`` project is a `FSL <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/>`_
  programming library written in Python. It is used by `FSLeyes
  <https://git.fmrib.ox.ac.uk/fsl/fsleyes/fsleyes/>`_.
  ``fslpy`` is tested against Python versions 3.8, 3.9, 3.10, and 3.11.


pkgId: 84c9423e3ef8f0357dc80954165e745dbc2c6bf12951ca2c61686c495c64664c
name: python-fsspec
arch: src
version: 2023.3.0
epoch: 0
release: 1
summary: File-system specification
url: http://github.com/fsspec/filesystem_spec
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3b124682-80f1-46fd-b38e-6a153a51ed87
location_href: 00003715-python-fsspec/python-fsspec-2023.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/fsspec.svg)](https://pypi.python.org/pypi/fsspec/)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/fsspec/badges/version.svg)](https://anaconda.org/conda-forge/fsspec)
  ![Build](https://github.com/fsspec/filesystem_spec/workflows/CI/badge.svg)
  [![Docs](https://readthedocs.org/projects/filesystem-spec/badge/?version=latest)](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)

  A specification for pythonic filesystems.



  ```bash
  pip install fsspec
  ```
  or
  ```bash
  conda install -c conda-forge fsspec
  ```



  To produce a template or specification for a file-system interface, that specific implementations should follow,
  so that applications making use of them can rely on a common behaviour and not have to worry about the specific
  internal implementation decisions with any given backend. Many such implementations are included in this package,
  or in sister projects such as `s3fs` and `gcsfs`.

  In addition, if this is well-designed, then additional functionality, such as a key-value store or FUSE
  mounting of the file-system implementation may be available for all implementations "for free".



  Please refer to [RTD](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)



  fsspec uses GitHub Actions for CI. Environment files can be found
  in the "ci/" directory. Note that the main environment is called "py38",
  but it is expected that the version of python installed be adjustable at
  CI runtime. For local use, pick a version suitable for you.



  Tests can be run in the dev environment, if activated, via ``pytest fsspec``.

  The full fsspec suite requires a system-level docker, docker-compose, and fuse
  installation. If only making changes to one backend implementation, it is
  not generally necessary to run all tests locally.

  It is expected that contributors ensure that any change to fsspec does not
  cause issues or regressions for either other fsspec-related packages such
  as gcsfs and s3fs, nor for downstream users of fsspec. The "downstream" CI
  run and corresponding environment file run a set of tests from the dask
  test suite, and very minimal tests against pandas and zarr from the
  test_downstream.py module in this repo.



  fsspec uses [Black](https://black.readthedocs.io/en/stable) to ensure
  a consistent code format throughout the project.
  Run ``black fsspec`` from the root of the filesystem_spec repository to
  auto-format your code. Additionally, many editors have plugins that will apply
  ``black`` as you edit files. ``black`` is included in the ``tox`` environments.

  Optionally, you may wish to setup [pre-commit hooks](https://pre-commit.com) to
  automatically run ``black`` when you make a git commit.
  Run ``pre-commit install --install-hooks`` from the root of the
  filesystem_spec repository to setup pre-commit hooks. ``black`` will now be run
  before you commit, reformatting any changed files. You can format without
  committing via ``pre-commit run`` or skip these checks with ``git commit
  --no-verify``.


pkgId: 9b3d78c967f71bebffd6c66ef23b47621de71c2e5b1ae52c05b63e8026d9c6ff
name: python-ftfy
arch: src
version: 6.1.1
epoch: 0
release: 1
summary: Fixes mojibake and other problems with Unicode, after the fact
url: https://pypi.org/project/ftfy/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-17006081-7af9-43fa-bc98-aa370fcaf142
location_href: 00009670-python-ftfy/python-ftfy-6.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI package](https://badge.fury.io/py/ftfy.svg)](https://badge.fury.io/py/ftfy)
  [![Docs](https://readthedocs.org/projects/ftfy/badge/?version=latest)](https://ftfy.readthedocs.org/en/latest/)

  ```python
  >>> print(fix_encoding("(à¸‡'âŒ£')à¸‡"))
  (ง'⌣')ง
  ```

  The full documentation of ftfy is available at [ftfy.readthedocs.org](https://ftfy.readthedocs.org). The documentation covers a lot more than this README, so here are
  some links into it:

  - [Fixing problems and getting explanations](https://ftfy.readthedocs.io/en/latest/explain.html)
  - [Configuring ftfy](https://ftfy.readthedocs.io/en/latest/config.html)
  - [Encodings ftfy can handle](https://ftfy.readthedocs.io/en/latest/encodings.html)
  - [“Fixer” functions](https://ftfy.readthedocs.io/en/latest/fixes.html)
  - [Is ftfy an encoding detector?](https://ftfy.readthedocs.io/en/latest/detect.html)
  - [Heuristics for detecting mojibake](https://ftfy.readthedocs.io/en/latest/heuristic.html)
  - [Support for “bad” encodings](https://ftfy.readthedocs.io/en/latest/bad_encodings.html)
  - [Command-line usage](https://ftfy.readthedocs.io/en/latest/cli.html)
  - [Citing ftfy](https://ftfy.readthedocs.io/en/latest/cite.html)



  - “My life is livable again!”
    — [@planarrowspace](https://twitter.com/planarrowspace)
  - “A handy piece of magic”
    — [@simonw](https://twitter.com/simonw)
  - “Saved me a large amount of frustrating dev work”
    — [@iancal](https://twitter.com/iancal)
  - “ftfy did the right thing right away, with no faffing about. Excellent work, solving a very tricky real-world (whole-world!) problem.”
    — Brennan Young
  - “I have no idea when I’m gonna need this, but I’m definitely bookmarking it.”
    — [/u/ocrow](https://reddit.com/u/ocrow)
  - “9.2/10”
    — [pylint](https://bitbucket.org/logilab/pylint/)



  Here are some examples (found in the real world) of what ftfy can do:

  ftfy can fix mojibake (encoding mix-ups), by detecting patterns of characters that were clearly meant to be UTF-8 but were decoded as something else:

      >>> import ftfy
      >>> ftfy.fix_text('âœ” No problems')
      '✔ No problems'

  Does this sound impossible? It's really not. UTF-8 is a well-designed encoding that makes it obvious when it's being misused, and a string of mojibake usually contains all the information we need to recover the original string.

  ftfy can fix multiple layers of mojibake simultaneously:

      >>> ftfy.fix_text('The Mona Lisa doesnÃƒÂ¢Ã¢â€šÂ¬Ã¢â€žÂ¢t have eyebrows.')
      "The Mona Lisa doesn't have eyebrows."

  It can fix mojibake that has had "curly quotes" applied on top of it, which cannot be consistently decoded until the quotes are uncurled:

      >>> ftfy.fix_text("l’humanitÃ©")
      "l'humanité"

  ftfy can fix mojibake that would have included the character U+A0 (non-breaking space), but the U+A0 was turned into an ASCII space and then combined with another following space:

      >>> ftfy.fix_text('Ã\xa0 perturber la rÃ©flexion')
      'à perturber la réflexion'
      >>> ftfy.fix_text('Ã perturber la rÃ©flexion')
      'à perturber la réflexion'

  ftfy can also decode HTML entities that appear outside of HTML, even in cases where the entity has been incorrectly capitalized:

      >>> # by the HTML 5 standard, only 'P&Eacute;REZ' is acceptable
      >>> ftfy.fix_text('P&EACUTE;REZ')
      'PÉREZ'

  These fixes are not applied in all cases, because ftfy has a strongly-held goal of avoiding false positives -- it should never change correctly-decoded text to something else.

  The following text could be encoded in Windows-1252 and decoded in UTF-8, and it would decode as 'MARQUɅ'. However, the original text is already sensible, so it is unchanged.

      >>> ftfy.fix_text('IL Y MARQUÉ…')
      'IL Y MARQUÉ…'



  ftfy is a Python 3 package that can be installed using `pip`:

      pip install ftfy

  (Or use `pip3 install ftfy` on systems where Python 2 and 3 are both globally
  installed and `pip` refers to Python 2.)



  ftfy is developed using `poetry`. Its `setup.py` is vestigial and is not the
  recommended way to install it.

  [Install Poetry](https://python-poetry.org/docs/master/#installing-with-the-official-installer), check out this repository, and run `poetry install` to install ftfy for local development, such as experimenting with the heuristic or running tests.



  I'm Robyn Speer, also known as Elia Robyn Lake. You can find me
  [on GitHub](https://github.com/rspeer) or [Twitter](https://twitter.com/r_speer).



  ftfy has been used as a crucial data processing step in major NLP research.

  It's important to give credit appropriately to everyone whose work you build on
  in research. This includes software, not just high-status contributions such as
  mathematical models. All I ask when you use ftfy for research is that you cite
  it.

  ftfy has a citable record [on Zenodo](https://zenodo.org/record/2591652).
  A citation of ftfy may look like this:

      Robyn Speer. (2019). ftfy (Version 5.5). Zenodo.
      http://doi.org/10.5281/zenodo.2591652

  In BibTeX format, the citation is::

      @misc{speer-2019-ftfy,
        author       = {Robyn Speer},
        title        = {ftfy},
        note         = {Version 5.5},
        year         = 2019,
        howpublished = {Zenodo},
        doi          = {10.5281/zenodo.2591652},
        url          = {https://doi.org/10.5281/zenodo.2591652}
      }


pkgId: 7129adf741aaab9efdc9eb72d0898ef633b05e60971732a1ce7fab8663de3cd0
name: python-ftputil
arch: src
version: 5.0.4
epoch: 0
release: 1
summary: High-level FTP client library (virtual file system and more)
url: https://ftputil.sschwarzer.net/
rpm_license: Open source (revised BSD license)
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-89064f7a-693d-4305-b584-25d42d57198f
location_href: 00012738-python-ftputil/python-ftputil-5.0.4-1.src.rpm
checksum_type: sha256
description:
  ftputil is a high-level FTP client library for the Python programming
  language. ftputil implements a virtual file system for accessing FTP servers,
  that is, it can generate file-like objects for remote files. The library
  supports many functions similar to those in the os, os.path and
  shutil modules. ftputil has convenience functions for conditional uploads
  and downloads, and handles FTP clients and servers in different timezones.


pkgId: 8175d0b5c73d015f1a3f2d2bdac947fdf7a168661f3d0972a7a329d354610742
name: python-fuckit
arch: src
version: 4.8.1
epoch: 0
release: 1
summary: The Python Error Steamroller
url: https://github.com/ajalt/fuckitpy
rpm_license: WTFPL
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b183b80-7e0b-4a5e-89d2-21861c891a8f
location_href: 00003716-python-fuckit/python-fuckit-4.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/travis/ajalt/fuckitpy/master.svg)](https://travis-ci.org/ajalt/fuckitpy)
  [![PyPI version](https://img.shields.io/badge/pypi-4.8.1-brightgreen.svg)](https://pypi.python.org/pypi/fuckit/4.8.1)
  [![Coverage Status](https://img.shields.io/badge/coverage-110%25-brightgreen.svg)](https://coveralls.io/r/ajalt/fuckitpy?branch=master)
  [![Downloads](https://img.shields.io/badge/downloads-1.1M%2Fmonth-brightgreen.svg)](https://pypi.python.org/pypi/fuckit)


  FuckIt.py uses state-of-the-art technology to make sure your Python code runs
  whether it has any right to or not. Some code has an error? Fuck it.


  FuckIt.py uses a combination of dynamic compilation, Abstract Syntax Tree rewriting, live call stack modification, and love to get rid of all those pesky errors that make programming _so hard_.


  All functionality is provided through the fuckit module. Add `import fuckit` to the top of your script, then use fuckit in any of the following ways:


  Use fuckit to replace an import when a module has errors.
  Just change `import some_shitty_module` to `fuckit('some_shitty_module')`. Note that you have to surround the module name with quotes and parentheses.

  ```python
  import fuckit

  fuckit('some_shitty_module')
  some_shitty_module.some_function()
  ```

  Still getting errors? Chain fuckit calls. This module is like violence: if it doesn't work, you just need more of it.

  ```python
  import fuckit
  fuckit(fuckit('some_shitty_module'))

  some_shitty_module.some_function()
  ```


  Use fuckit as a function decorator when a single function is giving you trouble. Exceptions will be silenced, and in most cases the function will continue to run, skipping the statements that cause errors.

  ```python
  @fuckit
  def func():
      problem_solved
  ```

  You can use fuckit as a class decorator, too.

  ```python
  @fuckit
  class C(object):
      def __init__(self):
          everything_works_now
  ```

  Keep in mind that the decorator form of fuckit can't stop syntax errors. For those, you have to use the import form.


  Use fuckit as a context manager to save yourself from having to type out try/except block to silence exceptions yourself.

  ```python
  with fuckit:
      some_code
  ```

  This is functionally equivalent to the following:

  ```python
  try:
      some_code
  except Exception:
      pass
  ```

  The context manager form of fuckit can't allow the code to continue past an error like the decorator and import forms can. If you want the code to continue after an exception, wrap the code block in a function and use the decorator instead.




                  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                         Version 2, December 2004

  	Copyright (C) 2014-2018 AJ Alt

  	Everyone is permitted to copy and distribute verbatim or modified
  	copies of this license document, and changing it is allowed as long
  	as the name is changed.

                  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
         TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

   	0. You just DO WHAT THE FUCK YOU WANT TO.



  This module is inspired by Matt Diamond's [FuckIt.js](https://github.com/mattdiamond/fuckitjs).


pkgId: 5531769b23e025c9fbd3ea9c17781cc8a33533d8d2ee887809487ff1371fa2cf
name: python-funcparserlib
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Recursive descent parsing library based on functional combinators
url: https://funcparserlib.pirx.ru
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-26d08a3b-b74d-40f7-807b-db8d44ecc0f4
location_href: 00003717-python-funcparserlib/python-funcparserlib-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Recursive descent parsing library for Python based on functional combinators.
  [![PyPI](https://img.shields.io/pypi/v/funcparserlib)](https://pypi.org/project/funcparserlib/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/funcparserlib)](https://pypi.org/project/funcparserlib/)


pkgId: 1ba6a2e3c5611199a4c1c2e1c695539c5d0f052aef997c70ea711317ab17484e
name: python-funcy
arch: src
version: 1.18
epoch: 0
release: 1
summary: A fancy and practical functional tools
url: http://github.com/Suor/funcy
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fdf7b2ce-b160-4c84-a975-3c84402c96e9
location_href: 00003718-python-funcy/python-funcy-1.18-1.src.rpm
checksum_type: sha256
description:
  A collection of fancy functional tools focused on practicality.
  Inspired by clojure, underscore and my own abstractions. Keep reading to get an overview
  or `read the docs <http://funcy.readthedocs.org/>`_.
  Or jump directly to `cheatsheet <http://funcy.readthedocs.io/en/stable/cheatsheet.html>`_.
  Works with Python 2.7, 3.4+ and pypy.


pkgId: d3d59c4eafa68216b5e6aef6f02841b90e1e5185d0f2dae110cedfbac0477dfb
name: python-fusepy
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Simple ctypes bindings for FUSE
url: http://github.com/fusepy/fusepy
rpm_license: ISC
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e9db4eb3-0def-44f5-8953-a4fdc0be5716
location_href: 00003720-python-fusepy/python-fusepy-3.0.1-1.src.rpm
checksum_type: sha256
description:
      **NOTE**: *This project has moved to be under a GitHub organization and can
      be found at https://github.com/fusepy/fusepy. The project has new
      maintainers and will be looking to incorporate pull requests in a more
      timely manner. If you would like to help maintain this package please open
      a pull request and demonstrate willingness to help (we will leave
      maintainer criteria up to the current maintainers).*
  ``fusepy`` is a Python module that provides a simple interface to FUSE_ and
  MacFUSE_. It's just one file and is implemented using ctypes.
  The original version of ``fusepy`` was hosted on `Google Code`_, but is now
  `officially hosted on GitHub`_.
  ``fusepy`` is written in 2x syntax, but trying to pay attention to bytes and
  other changes 3x would care about.


pkgId: 9994b94c9a4bb0f76fd792417a7e70704d8c8a44df32297d19de62ff617120a7
name: python-future
arch: src
version: 0.18.3
epoch: 0
release: 1
summary: Clean single-source support for Python 3 and 2
url: https://python-future.org
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-607a96fb-e42b-4a15-aabd-b0b9b33f1402
location_href: 00008948-python-future/python-future-0.18.3-1.src.rpm
checksum_type: sha256
description:
  ``future`` is the missing compatibility layer between Python 2 and Python
  3. It allows you to use a single, clean Python 3.x-compatible codebase to
  support both Python 2 and Python 3 with minimal overhead.
  It is designed to be used as follows::
      from __future__ import (absolute_import, division,
                              print_function, unicode_literals)
      from builtins import (
               bytes, dict, int, list, object, range, str,
               ascii, chr, hex, input, next, oct, open,
               pow, round, super,
               filter, map, zip)
  followed by predominantly standard, idiomatic Python 3 code that then runs
  similarly on Python 2.6/2.7 and Python 3.3+.
  The imports have no effect on Python 3. On Python 2, they shadow the
  corresponding builtins, which normally have different semantics on Python 3
  versus 2, to provide their Python 3 semantics.
  Standard library reorganization
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  ``future`` supports the standard library reorganization (PEP 3108) through the
  following Py3 interfaces:
      >>> # Top-level packages with Py3 names provided on Py2:
      >>> import html.parser
      >>> import queue
      >>> import tkinter.dialog
      >>> import xmlrpc.client
      >>> # etc.
      >>> # Aliases provided for extensions to existing Py2 module names:
      >>> from future.standard_library import install_aliases
      >>> install_aliases()
      >>> from collections import Counter, OrderedDict   # backported to Py2.6
      >>> from collections import UserDict, UserList, UserString
      >>> import urllib.request
      >>> from itertools import filterfalse, zip_longest
      >>> from subprocess import getoutput, getstatusoutput


pkgId: c8216a551e3fdbe67ce89917c368a5335dd2eaf97d285f459e4865b5bbde0758
name: python-fuzzysearch-debuginfo
arch: aarch64
version: 0.7.3
epoch: 0
release: 1
summary: Debug information for package python-fuzzysearch
url: https://github.com/taleinat/fuzzysearch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e64ee0b3-cde8-4303-af7b-5ffaf3983ec6
rpm_sourcerpm: python-fuzzysearch-0.7.3-1.src.rpm
location_href: 00010410-python-fuzzysearch/python-fuzzysearch-debuginfo-0.7.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-fuzzysearch.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 5925f0552c8e350bbed98f763627d777e1e51fa8996155d2b57fcffefa5c57a1
name: python-fuzzysearch-debugsource
arch: aarch64
version: 0.7.3
epoch: 0
release: 1
summary: Debug sources for package python-fuzzysearch
url: https://github.com/taleinat/fuzzysearch
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-e64ee0b3-cde8-4303-af7b-5ffaf3983ec6
rpm_sourcerpm: python-fuzzysearch-0.7.3-1.src.rpm
location_href: 00010410-python-fuzzysearch/python-fuzzysearch-debugsource-0.7.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-fuzzysearch.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 8d36e6c22e24b12e2dabbd18e5093c84e8df0d01a4fcf88fcde1ab59207820f3
name: python-fuzzywuzzy
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Fuzzy string matching in python
url: https://github.com/seatgeek/fuzzywuzzy
rpm_license: GPLv2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0582322e-d5d3-472a-b2de-505df81b8fac
location_href: 00003724-python-fuzzywuzzy/python-fuzzywuzzy-0.18.0-1.src.rpm
checksum_type: sha256
description:
  Fuzzy string matching like a boss. It uses `Levenshtein Distance <https://en.wikipedia.org/wiki/Levenshtein_distance>`_ to calculate the differences between sequences in a simple-to-use package.


pkgId: ef2a2483428af828e3cc2bdb3eee78575833a9e1bc4318c5f67ec26895c85f2b
name: python-fypp
arch: src
version: 3.1
epoch: 0
release: 1
summary: Python powered Fortran preprocessor
url: https://github.com/aradi/fypp
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3a242ee5-43c6-4a51-8f24-564a172e7f35
location_href: 00003725-python-fypp/python-fypp-3.1-1.src.rpm
checksum_type: sha256
description:
  * Definition, evaluation and removal of variables::
      
        print *, "Some debug information"
      
      
      print *, "LOGLEVEL: ${LOGLEVEL}$"
      
  * Macro definitions and macro calls::
      
        
          if (.not. ${cond}$) then
            print *, "Assert failed in file ${_FILE_}$, line ${_LINE_}$"
            error stop
          end if
        
      
      ! Invoked via direct call (argument needs no quotation)
      @:ASSERT(size(myArray) > 0)
      ! Invoked as Python expression (argument needs quotation)
      $:ASSERT('size(myArray) > 0')
  * Conditional output::
      program test
      
        use mpi
      
        use openmp
      
        use serial
      
  * Iterated output (e.g. for generating Fortran templates)::
      interface myfunc
      
        module procedure myfunc_${dtype}$
      
      end interface myfunc
  * Inline directives::
      logical, parameter :: hasMpi = #{if defined('MPI')}# .true. #{else}# .false. #{endif}#
  * Insertion of arbitrary Python expressions::
      character(*), parameter :: comp_date = "${time.strftime('%Y-%m-%d')}$"
  * Inclusion of files during preprocessing::
      
  * Using Fortran-style continutation lines in preprocessor directives::
      
          & or var2 > var4
        print *, "Doing something here"
      
  * Passing (unquoted) multiline string arguments to callables::
      
      
        
          $:code
        
      
      
      
        if (size(array) > 100) then
          print *, "DEBUG: spuriously large array"
        end if
      
      
      
        
          $:code
        
      
      
      
      this will be repeated 3 times
      
  * Preprocessor comments::
      
      
  * Suppressing the preprocessor output in selected regions::
      
      
      
      
  * Explicit request for stopping the preprocessor::
      
        
      
  * Easy check for macro parameter sanity::
      
        
        
      
  * Line numbering directives in output::
      program test
      
      use mpi
      
    transformed to ::
      
      program test
      
      use mpi
      
    when variable ``MPI`` is defined and Fypp was instructed to generate line
    markers.
  * Automatic folding of generated lines exceeding line length limit


pkgId: fcc1dbad1876cc09b2005bc284eaecdb95a7b77fd369cbe2980e6f96683e416c
name: python-gTTS
arch: src
version: 2.3.1
epoch: 0
release: 1
url: https://pypi.org/project/gTTS/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-4b353b50-1506-4325-9cc1-b94738f9b39b
location_href: 00003824-python-gtts/python-gTTS-2.3.1-1.src.rpm
checksum_type: sha256
summary:
  gTTS (Google Text-to-Speech), a Python library and CLI tool to interface with Google Translate text-to-speech API

description:
  **gTTS** (*Google Text-to-Speech*), a Python library and CLI tool to interface with Google Translate's text-to-speech API.
  Write spoken `mp3` data to a file, a file-like object (bytestring) for further audio manipulation, or `stdout`.
  <http://gtts.readthedocs.org/>

  [![PyPI version](https://img.shields.io/pypi/v/gTTS.svg)](https://pypi.org/project/gTTS/)
  [![Python versions](https://img.shields.io/pypi/pyversions/gTTS.svg)](https://pypi.org/project/gTTS/)
  [![Tests workflow](https://github.com/pndurette/gTTS/workflows/Tests/badge.svg)](https://github.com/pndurette/gTTS/actions)
  [![codecov](https://codecov.io/gh/pndurette/gTTS/branch/master/graph/badge.svg)](https://codecov.io/gh/pndurette/gTTS)
  [![Commits Since](https://img.shields.io/github/commits-since/pndurette/gTTS/latest.svg)](https://github.com/pndurette/gTTS/commits/)
  [![PyPi Downloads](http://pepy.tech/badge/gtts)](http://pepy.tech/project/gtts)
  [![Buy me a Coffee](https://img.shields.io/badge/buy%20me%20a-coffee-orange)](https://www.buymeacoffee.com/pndurette)



  -   Customizable speech-specific sentence tokenizer that allows for unlimited lengths of text to be read, all while keeping proper intonation, abbreviations, decimals and more;
  -   Customizable text pre-processors which can, for example, provide pronunciation corrections;



      $ pip install gTTS



  Command Line:

      $ gtts-cli 'hello' --output hello.mp3

  Module:

      >>> from gtts import gTTS
      >>> tts = gTTS('hello')
      >>> tts.save('hello.mp3')

  See <http://gtts.readthedocs.org/> for documentation and examples.



  This project is *not* affiliated with Google or Google Cloud. Breaking upstream changes *can* occur without notice. This project is leveraging the undocumented [Google Translate](https://translate.google.com) speech functionality and is *different* from [Google Cloud Text-to-Speech](https://cloud.google.com/text-to-speech/).



  -   [Questions & community](https://github.com/pndurette/gTTS/discussions)
  -   [Changelog](CHANGELOG.rst)
  -   [Contributing](CONTRIBUTING.rst)



  [The MIT License (MIT)](LICENSE) Copyright © 2014-2022 Pierre Nicolas Durette & [Contributors](https://github.com/pndurette/gTTS/graphs/contributors)


pkgId: ee52bafc97beb35df2e0859632b525c1d786e4ee807859b5e9b395a928c91d66
name: python-gTTS-token
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: Calculates a token to run the Google Translate text to speech
url: https://github.com/boudewijn26/gTTS-token
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-23772271-0203-4ca4-bbe1-d44777894f68
location_href: 00003825-python-gtts-token/python-gTTS-token-1.1.4-1.src.rpm
checksum_type: sha256
description:
  **gTTS-token** (Google Text to Speech token): A python implementation of the token validation of Google Translate
  [![Build Status](https://travis-ci.org/Boudewijn26/gTTS-token.svg?branch=master)](https://travis-ci.org/Boudewijn26/gTTS-token)


pkgId: 8ebb9a58334807a389c6ae7c874e71107c2d94f9417503ecfce63ccc51b436dd
name: python-gabbi
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: Declarative HTTP testing library
url: https://github.com/cdent/gabbi
rpm_license: Apache-2
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7cdbf2da-4270-4b1b-80c1-6ce27fae535b
location_href: 00003726-python-gabbi/python-gabbi-2.8.0-1.src.rpm
checksum_type: sha256
description:
  `Release Notes`_
  Gabbi is a tool for running HTTP tests where requests and responses
  are represented in a declarative YAML-based form. The simplest test
  looks like this::
      tests:
      - name: A test
        GET: /api/resources/id
  See the docs_ for more details on the many features and formats for
  setting request headers and bodies and evaluating responses.
  Gabbi is tested with Python 3.6, 3.7, 3.8, 3.9, 3.10 and pypy3.
  Tests can be run using `unittest`_ style test runners, `pytest`_
  or from the command line with a `gabbi-run`_ script.
  There is a `gabbi-demo`_ repository which provides a tutorial via
  its commit history. The demo builds a simple API using gabbi to
  facilitate test driven development.


pkgId: ba84b8ac3a41246df4a28026289cb0f188b0a7ae25f968de05d3ac418ea49269
name: python-gapic-google-cloud-datastore-v1
arch: src
version: 0.90.4
epoch: 0
release: 1
summary: GAPIC library for the Google Cloud Datastore API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e0037ad-d2f5-4f9d-9e02-1ef2b10fdafe
checksum_type: sha256
description:
  gapic-google-cloud-datastore-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Datastore API`_ (v1) defined in the googleapis_ git repository

location_href:
  00011706-python-gapic-google-cloud-datastore-v1/python-gapic-google-cloud-datastore-v1-0.90.4-1.src.rpm


pkgId: 1d7d222df2c3867b24a46d36d2e563fa1d547119044e7c451e12a62fbf2af934
name: python-gapic-google-cloud-datastore-v1-help
arch: noarch
version: 0.90.4
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-datastore-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-7e0037ad-d2f5-4f9d-9e02-1ef2b10fdafe
rpm_sourcerpm: python-gapic-google-cloud-datastore-v1-0.90.4-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-datastore-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Datastore API`_ (v1) defined in the googleapis_ git repository

location_href:
  00011706-python-gapic-google-cloud-datastore-v1/python-gapic-google-cloud-datastore-v1-help-0.90.4-1.noarch.rpm


pkgId: 6743975e1eeba677a72fae44cbd151fb25136fad7cfc63cbe6577369ad2554b3
name: python-gapic-google-cloud-error-reporting-v1beta1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GAPIC library for the Stackdriver Error Reporting API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-83c2a1e5-7525-4b24-90c5-b610e03c7af5
checksum_type: sha256
description:
  gapic-google-cloud-error-reporting-v1beta1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Error Reporting API`_ (v1beta1) defined in the googleapis_ git repository

location_href:
  00012109-python-gapic-google-cloud-error-reporting-v1beta1/python-gapic-google-cloud-error-reporting-v1beta1-0.15.3-1.src.rpm


pkgId: 15baed4c3de31a4223c54862c53619b001e03b9e3744e7075bf9d59f1b450794
name: python-gapic-google-cloud-error-reporting-v1beta1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-error-reporting-v1beta1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-83c2a1e5-7525-4b24-90c5-b610e03c7af5
rpm_sourcerpm: python-gapic-google-cloud-error-reporting-v1beta1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-error-reporting-v1beta1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Error Reporting API`_ (v1beta1) defined in the googleapis_ git repository

location_href:
  00012109-python-gapic-google-cloud-error-reporting-v1beta1/python-gapic-google-cloud-error-reporting-v1beta1-help-0.15.3-1.noarch.rpm


pkgId: 4c37aaf1ac0ada3d7abf58530f85583d6b0386156bff9922d4d947bfa4de6aef
name: python-gapic-google-cloud-logging-v2
arch: src
version: 0.91.3
epoch: 0
release: 1
summary: GAPIC library for the Stackdriver Logging API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a94de723-df21-4fb3-a33a-8ca0e0d0df0b
location_href: 00011562-python-gapic-google-cloud-logging-v2/python-gapic-google-cloud-logging-v2-0.91.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-logging-v2 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Logging API`_ (v2) defined in the googleapis_ git repository


pkgId: 542e443e326930bcd9ac4b2a297f558d0a78d5073466d84cbc2110d381a5f828
name: python-gapic-google-cloud-logging-v2-help
arch: noarch
version: 0.91.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-logging-v2
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a94de723-df21-4fb3-a33a-8ca0e0d0df0b
rpm_sourcerpm: python-gapic-google-cloud-logging-v2-0.91.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-logging-v2 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Stackdriver Logging API`_ (v2) defined in the googleapis_ git repository

location_href:
  00011562-python-gapic-google-cloud-logging-v2/python-gapic-google-cloud-logging-v2-help-0.91.3-1.noarch.rpm


pkgId: db7514385a41643c0a59a510bf92000785a1ae7d8ef78eeb1f3270651920ac91
name: python-gapic-google-cloud-pubsub-v1
arch: src
version: 0.15.4
epoch: 0
release: 1
summary: GAPIC library for the Google Cloud Pub/Sub API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d735ca58-70d3-41af-a157-f09ae802ad49
location_href: 00012492-python-gapic-google-cloud-pubsub-v1/python-gapic-google-cloud-pubsub-v1-0.15.4-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-pubsub-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Pub/Sub API`_ (v1) defined in the googleapis_ git repository


pkgId: a1f75a39e1b5e9c2519e3e9c25fefcb9299729db023320ac973b3865cee4161e
name: python-gapic-google-cloud-pubsub-v1-help
arch: noarch
version: 0.15.4
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-pubsub-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d735ca58-70d3-41af-a157-f09ae802ad49
rpm_sourcerpm: python-gapic-google-cloud-pubsub-v1-0.15.4-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-pubsub-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Cloud Pub/Sub API`_ (v1) defined in the googleapis_ git repository

location_href:
  00012492-python-gapic-google-cloud-pubsub-v1/python-gapic-google-cloud-pubsub-v1-help-0.15.4-1.noarch.rpm


pkgId: f81299abe4d7e77f080888d46672efe645ad9da1165fcdaa0014da7d80e80efb
name: python-gapic-google-cloud-spanner-admin-database-v1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GAPIC library for the Cloud Spanner Database Admin API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22372065-e447-4587-901e-42f46e35bb35
checksum_type: sha256
description:
  gapic-google-cloud-spanner-admin-database-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner Database Admin API`_ (v1) defined in the googleapis_ git repository

location_href:
  00012997-python-gapic-google-cloud-spanner-admin-database-v1/python-gapic-google-cloud-spanner-admin-database-v1-0.15.3-1.src.rpm


pkgId: e4e372081cd1ce5a04d534a4c1a5b6a62b9a2190dde03db56db610e3335ab2c9
name: python-gapic-google-cloud-spanner-admin-database-v1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-spanner-admin-database-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-22372065-e447-4587-901e-42f46e35bb35
rpm_sourcerpm: python-gapic-google-cloud-spanner-admin-database-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-spanner-admin-database-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner Database Admin API`_ (v1) defined in the googleapis_ git repository

location_href:
  00012997-python-gapic-google-cloud-spanner-admin-database-v1/python-gapic-google-cloud-spanner-admin-database-v1-help-0.15.3-1.noarch.rpm


pkgId: 6a6b27bf340a58e32b9926bd87c40a956a840af9557010326715fc411ae2ebb0
name: python-gapic-google-cloud-spanner-v1
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: GAPIC library for the Cloud Spanner API
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86314ed9-122e-4cdd-9c2a-51663f6b87ce
location_href: 00013000-python-gapic-google-cloud-spanner-v1/python-gapic-google-cloud-spanner-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-spanner-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner API`_ (v1) defined in the googleapis_ git repository


pkgId: ac97deb0866fe02565dd834cdde464f36500f8c66fb999090b77fd49e426a018
name: python-gapic-google-cloud-spanner-v1-help
arch: noarch
version: 0.15.3
epoch: 0
release: 1
summary: Development documents and examples for gapic-google-cloud-spanner-v1
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-86314ed9-122e-4cdd-9c2a-51663f6b87ce
rpm_sourcerpm: python-gapic-google-cloud-spanner-v1-0.15.3-1.src.rpm
checksum_type: sha256
description:
  gapic-google-cloud-spanner-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Cloud Spanner API`_ (v1) defined in the googleapis_ git repository

location_href:
  00013000-python-gapic-google-cloud-spanner-v1/python-gapic-google-cloud-spanner-v1-help-0.15.3-1.noarch.rpm


pkgId: 773d7817cfb349cd0301fbebdfbc8e5daa68c4d264d76a554ca1ba84a2b47cce
name: python-gast
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Python AST that abstracts the underlying Python version
url: https://github.com/serge-sans-paille/gast/
rpm_license: BSD 3-Clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-6ddc16c1-e6b5-4277-a43f-ba18d49d6e8e
location_href: 00009083-python-gast/python-gast-0.5.3-1.src.rpm
checksum_type: sha256
description:
  A generic AST to represent Python2 and Python3's Abstract Syntax Tree(AST).

  GAST provides a compatibility layer between the AST of various Python versions,
  as produced by ``ast.parse`` from the standard ``ast`` module.


pkgId: 2b53ed39ca254186b6cbffa659c8c4ac798fb45ffe236f889034487bfdb94262
name: python-gatspy
arch: src
version: 0.3
epoch: 0
release: 1
summary: General tools for Astronomical Time Series in Python
url: http://github.com/astroml/gatspy
rpm_license: BSD 3-clause
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fc9cfa8a-8c06-4528-af0d-9da4234865e4
location_href: 00003728-python-gatspy/python-gatspy-0.3-1.src.rpm
checksum_type: sha256
description:
  Gatspy (pronounced as F. Scott Fitzgerald might pronounce it) is a collection of tools for analyzing astronomical time series in Python.
  For more information, visit http://github.com/astroml/gatspy/


pkgId: 2af4b84f39011f308b1e042d7b2905807a4be508c946562290715d93c329217a
name: python-gax-google-pubsub-v1
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: DEPRECATED
url: https://github.com/googleapis/googleapis
rpm_license: Apache-2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2bc43eba-49db-4639-a2ae-af7eb8c53ab5
location_href: 00011964-python-gax-google-pubsub-v1/python-gax-google-pubsub-v1-0.8.3-1.src.rpm
checksum_type: sha256
description:
  gax-google-pubsub-v1 uses google-gax_ (Google API extensions) to provide an
  easy-to-use client library for the `Google Pubsub API`_ (v1) defined in the googleapis_ git repository


pkgId: 126fcd9d4734ba6ed18afd8b83aef2dc6985676259114c163e6854d95a754100
name: python-gccinvocation
arch: src
version: 0.1
epoch: 0
release: 1
summary: Library for parsing GCC command-line options
url: https://github.com/fedora-static-analysis/gccinvocation
rpm_license: LGPLv2.1+
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8a34c07c-f07d-4869-85d1-176207812dc1
location_href: 00003730-python-gccinvocation/python-gccinvocation-0.1-1.src.rpm
checksum_type: sha256
description:
  This is a Python module that can parse gcc command lines and extract
  data of interest e.g. include paths, defines, etc


pkgId: a52d683dcc422c5c44f529da05065e87271866b8ca52a58f4571687ba09f0e43
name: python-gcovr
arch: src
version: 6.0
epoch: 0
release: 1
summary: Generate C/C++ code coverage reports with gcov
url: https://gcovr.com
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-e5058234-b4fb-41c6-8c63-369b39aa7351
location_href: 00010931-python-gcovr/python-gcovr-6.0-1.src.rpm
checksum_type: sha256
description:
  generate GCC code coverage reports
  `website and documentation <website_>`__ • bugtracker_ • `GitHub <repo_>`__
  |GitHub-Actions-badge| |pypi-badge| |codecov-badge| |gitter-badge|
  Gcovr provides a utility for managing the use of the GNU gcov_ utility
  and generating summarized code coverage results. This command is
  inspired by the Python coverage.py_ package, which provides a similar
  utility for Python.
  The ``gcovr`` command can produce different kinds of coverage reports:
     * - CLI Option
       - User Guide
       - Description
     * - default, |abstract-option-txt|
       - |abstract-guide-txt|
       - compact human-readable summaries
     * - |abstract-option-html|
       - |abstract-guide-html|
       - overview of all files
     * - |abstract-option-html-details|
       - |abstract-guide-html-details|
       - annotated source files
     * - |abstract-option-cobertura|
       - |abstract-guide-cobertura|
       - machine readable XML reports in Cobertura_ format
     * - |abstract-option-sonarqube|
       - |abstract-guide-sonarqube|
       - machine readable XML reports in Sonarqube format
     * - |abstract-option-json|
       - |abstract-guide-json|
       - JSON report with source file structure and coverage
     * - |abstract-option-json-summary|
       - |abstract-guide-json-summary|
       - JSON summary coverage report
     * - |abstract-option-csv|
       - |abstract-guide-csv|
       - CSV report summarizing the coverage of each file
     * - |abstract-option-coveralls|
       - |abstract-guide-coveralls|
       - machine readable JSON report in Coveralls_ format
  Thus, gcovr can be viewed
  as a command-line alternative to the lcov_ utility, which runs gcov
  and generates an HTML-formatted report.
  The development of gcovr was motivated by the need for
  text summaries and XML reports.
  Example HTML summary:
  Example HTML details:


pkgId: d7f9e72ae2a64ad81d3905b249436e15b5cd7a297ecc022f1f8c32c4d2f1685c
name: python-gcs-oauth2-boto-plugin
arch: src
version: 3.0
epoch: 0
release: 1
url: https://developers.google.com/storage/docs/gspythonlibrary
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-c107cc61-9ab2-4550-a055-ff84041bc4a1
location_href: 00010404-python-gcs-oauth2-boto-plugin/python-gcs-oauth2-boto-plugin-3.0-1.src.rpm
checksum_type: sha256
summary:
  Auth plugin allowing use the use of OAuth 2.0 credentials for Google Cloud Storage in the Boto library.

description:
  gcs-oauth2-boto-plugin is a Python application whose purpose is to behave as an
  auth plugin for the boto auth plugin framework for use with OAuth 2.0
  credentials for the Google Cloud Platform. This plugin is compatible with both
  user accounts and service accounts, and its functionality is essentially a
  wrapper around oauth2client with the addition of automatically caching tokens
  for the machine in a thread- and process-safe fashion.


pkgId: 9fbde3fcc6c6aec9ceca05a707ebf4c387faf3543cdfb0fbc566e6820b8e4c3c
name: python-gcsfs
arch: src
version: 2023.3.0
epoch: 0
release: 1
summary: Convenient Filesystem interface over GCS
url: https://github.com/fsspec/gcsfs
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-dfd2673f-efd8-4742-bed6-f1f438613623
location_href: 00003731-python-gcsfs/python-gcsfs-2023.3.0-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Doc Status|
  Pythonic file-system for Google Cloud Storage
  For documentation, go to readthedocs_.


pkgId: 785ad3a5d40ff957617e72ee414054afd2397f3afa4cdaba825c453c185998fd
name: python-gdown
arch: src
version: 4.7.1
epoch: 0
release: 1
summary: Google Drive direct download of big files.
url: http://github.com/wkentaro/gdown
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b450aa5a-1ee7-4df9-9b8a-7b275b00f784
location_href: 00010671-python-gdown/python-gdown-4.7.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    gdown
  </h1>

  <h4 align="center">
    Download a large file from Google Drive.
  </h4>

  <div align="center">
    <a href="https://pypi.python.org/pypi/gdown"><img src="https://img.shields.io/pypi/v/gdown.svg"></a>
    <a href="https://pypi.org/project/gdown"><img src="https://img.shields.io/pypi/pyversions/gdown.svg"></a>
    <a href="https://github.com/wkentaro/gdown/actions"><img src="https://github.com/wkentaro/gdown/workflows/ci/badge.svg"></a>
  </div>

  <div align="center">
    <img src=".readme/cli.png" width="90%">
    <img src=".readme/python.png" width="90%">
  </div>

  <br/>




  Download a large file from Google Drive.
  If you use curl/wget, it fails with a large file because of
  the security warning from Google Drive.
  Supports downloading from Google Drive folders (max 50 files per folder).




  ```bash
  pip install gdown


  pip install --upgrade gdown
  ```






  ```bash
  $ gdown --help
  usage: gdown [-h] [-V] [-O OUTPUT] [-q] [--fuzzy] [--id] [--proxy PROXY]
               [--speed SPEED] [--no-cookies] [--no-check-certificate]
               [--continue] [--folder] [--remaining-ok]
               url_or_id
  ...

  $ # a large file (~500MB)
  $ gdown https://drive.google.com/uc?id=1l_5RK28JRL19wpT22B-DY9We3TVXnnQQ
  $ md5sum fcn8s_from_caffe.npz
  256c2a8235c1c65e62e48d3284fbd384

  $ # same as the above but with the file ID
  $ gdown 1l_5RK28JRL19wpT22B-DY9We3TVXnnQQ

  $ # a small file
  $ gdown https://drive.google.com/uc?id=0B9P1L--7Wd2vU3VUVlFnbTgtS2c
  $ cat spam.txt
  spam

  $ # download with fuzzy extraction of a file ID
  $ gdown --fuzzy 'https://drive.google.com/file/d/0B9P1L--7Wd2vU3VUVlFnbTgtS2c/view?usp=sharing&resourcekey=0-WWs_XOSctfaY_0-sJBKRSQ'
  $ cat spam.txt
  spam

  $ # --fuzzy option also works with Microsoft Powerpoint files
  $ gdown --fuzzy "https://docs.google.com/presentation/d/15umvZKlsJ3094HNg5S4vJsIhxcFlyTeK/edit?usp=sharing&ouid=117512221203072002113&rtpof=true&sd=true"

  $ # a folder
  $ gdown https://drive.google.com/drive/folders/15uNXeRBIhVvZJIhL4yTw4IsStMhUaaxl -O /tmp/folder --folder

  $ # as an alternative to curl/wget
  $ gdown https://httpbin.org/ip -O ip.json
  $ cat ip.json
  {
    "origin": "126.169.213.247"
  }

  $ # write stdout and pipe to extract
  $ gdown https://github.com/wkentaro/gdown/archive/refs/tags/v4.0.0.tar.gz -O - --quiet | tar zxvf -
  $ ls gdown-4.0.0/
  gdown  github2pypi  LICENSE  MANIFEST.in  pyproject.toml  README.md  setup.cfg  setup.py  tests
  ```



  ```python
  import gdown


  url = "https://drive.google.com/uc?id=1l_5RK28JRL19wpT22B-DY9We3TVXnnQQ"
  output = "fcn8s_from_caffe.npz"
  gdown.download(url, output, quiet=False)


  id = "0B9P1L--7Wd2vNm9zMTJWOGxobkU"
  gdown.download(id=id, output=output, quiet=False)


  url = "https://drive.google.com/file/d/0B9P1L--7Wd2vNm9zMTJWOGxobkU/view?usp=sharing"
  gdown.download(url=url, output=output, quiet=False, fuzzy=True)


  md5 = "fa837a88f0c40c513d975104edf3da17"
  gdown.cached_download(url, output, md5=md5, postprocess=gdown.extractall)


  url = "https://drive.google.com/drive/folders/15uNXeRBIhVvZJIhL4yTw4IsStMhUaaxl"
  gdown.download_folder(url, quiet=True, use_cookies=False)


  id = "15uNXeRBIhVvZJIhL4yTw4IsStMhUaaxl"
  gdown.download_folder(id=id, quiet=True, use_cookies=False)
  ```




  See [LICENSE](LICENSE).


pkgId: f8b81caae9b0176c9af61f7b1137e51b6a7d56b604832c3703321200c30aafaa
name: python-gearbox
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Command line toolkit born as a PasteScript replacement for the TurboGears2 web framework
url: https://github.com/TurboGears/gearbox
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-0171199c-0d81-4d24-bc08-55017f9932c4
location_href: 00003736-python-gearbox/python-gearbox-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Gearbox is a paster command replacement for TurboGears2.
  It has been created during the process of providing Python3 support to the TurboGears2 web framework,
  while still being backward compatible with the existing TurboGears projects.
  Gearbox is based on a stripped down version of *Cliff* command line framework, you might want
  to consider `Cliff <http://docs.openstack.org/developer/cliff/>`_ for more advanced use cases
  and custom command interpreters.


pkgId: ff53da12a855c65d1b52626d9384c6764539b518ab26f7932fc2d086eacda6c8
name: python-gekitchen
arch: src
version: 0.2.20
epoch: 0
release: 1
summary: Python SDK for GE Kitchen Appliances
url: https://github.com/ajmarks/gekitchen
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-31dd394c-bef6-4559-88c6-f54bc50c68a5
location_href: 00003737-python-gekitchen/python-gekitchen-0.2.20-1.src.rpm
checksum_type: sha256
description:
  Python SDK for GE WiFi-enabled kitchen appliances.
  The primary goal is to use this to power integrations for [Home Assistant](https://www.home-assistant.io/), though that
  will probably need to wait on some new entity types.


  ```pip install gekitchen```



  Here we're going to run the client in a pre-existing event loop.  We're also going to register some event callbacks
  to update appliances every five minutes and to turn on our oven the first time we see it.  Because that is safe!
  ```python
  import aiohttp
  import asyncio
  import logging
  from gekitchen.secrets import USERNAME, PASSWORD
  from gekitchen import GeWebsocketClient

  _LOGGER = logging.getLogger(__name__)


  if __name__ == "__main__":
      logging.basicConfig(level=logging.DEBUG, format='-8s s')

      loop = asyncio.get_event_loop()
      client = GeWebsocketClient(loop, USERNAME, PASSWORD)

      session = aiohttp.ClientSession()
      asyncio.ensure_future(client.async_get_credentials_and_run(session), loop=loop)
      loop.run_until_complete(asyncio.sleep(60))

      for appliance in client.appliances:
          print(appliance)
  ```


  The authentication process has a few steps.  First, for both the websocket and XMPP APIs, we use Oauth2 to authenticate
  to the HTTPS API.  From there, we can either get a websocket endpoint with `access_token` or proceed with the XMPP login
  flow.  For XMPP, we get a mobile device token, which in turn be used to get a new `Bearer` token, which, finally,
  is used to get XMPP credentials to authenticate to the Jabber server.  In `gekitchen`, going from username/password
  to XMPP credentials is handled by `do_full_xmpp_flow(username, password)`.



  Function to authenticate to the web API and get XMPP credentials.  Returns a `dict` of XMPP credentials

  Function to authenticate to the web API and get websocket credentials.  Returns a `dict` of WSS credentials



  Main Websocket client
   * `event_loop: asyncio.AbstractEventLoop` Optional event loop.  If `None`, the client will use `asyncio.get_event_loop()`
   * `username`/`password` Optional strings to use when authenticating

   * `async_get_credentials(session, username=None, password=None)` Get new WSS credentials using either the specified
   `username` and `password` or ones already set in the constructor.
   * `get_credentials(username=None, password=None)` Blocking version of the above
   * `add_event_handler(event, callback)` Add an event handler
   * `disconnect()` Disconnect the client
   * `async_run_client()` Run the client
   * `async_get_credentials_and_run(sessions, username=None, password=None)` Authenticate and run the client

   * `appliances` A `Dict[str, GeAppliance]` of all known appliances keyed on the appliances' JIDs.

  * `EVENT_ADD_APPLIANCE` - Triggered immediately after a new appliance is added, before the initial update request has
  even been sent. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_INITIAL_UPDATE` - Triggered when an appliance's type changes, at which point we know at least a
  little about the appliance. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_STATE_CHANGE` - Triggered when an appliance message with a new state, different from the existing, cached
  state is received.  A tuple `(appliance, state_changes)` is passed to the callback, where `appliance` is the
  `GeAppliance` object with the updated state and `state_changes` is a dictionary `{erd_key: new_value}` of the changed
  state.
  * `EVENT_APPLIANCE_UPDATE_RECEIVED` - Triggered after processing an ERD update message whether or not the state changed
  * `EVENT_CONNECTED` - Triggered when the API connects, after adding basic subscriptions
  * `EVENT_DISCONNECTED` - Triggered when the API disconnects
  * `EVENT_GOT_APPLIANCE_LIST` - Triggered when we get the list of appliances


  Main XMPP client, and a subclass of `slixmpp.ClientXMPP`.
   * `xmpp_credentials: dict` A dictionary of XMPP credentials, usually obtained from either `do_full_login_flow` or, in a
   more manual process, `get_xmpp_credentials`
   * `event_loop: asyncio.AbstractEventLoop` Optional event loop.  If `None`, the client will use `asyncio.get_event_loop()`
   * `**kwargs` Passed to `slixmpp.ClientXMPP`

   * `connect()` Connect to the XMPP server
   * `process_in_running_loop(timeout: Optional[int] = None)` Run in an existing event loop.  If `timeout` is given, stop
   running after `timeout` seconds
   * `add_event_handler(name: str, func: Callable)` Add an event handler.  In addition to the events supported by
   `slixmpp.ClientXMPP`, we've added some more event types detailed below.

   * `appliances` A `Dict[str, GeAppliance]` of all known appliances keyed on the appliances' JIDs.

  In addition to the standard `slixmpp` events, the `GeClient` object has support for the following:
  * `EVENT_ADD_APPLIANCE` - Triggered immediately after a new appliance is added, before the initial update request has
  even been sent. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_INITIAL_UPDATE` - Triggered when an appliance's type changes, at which point we know at least a
  little about the appliance. The `GeAppliance` object is passed to the callback.
  * `EVENT_APPLIANCE_STATE_CHANGE` - Triggered when an appliance message with a new state, different from the existing, cached
  state is received.  A tuple `(appliance, state_changes)` is passed to the callback, where `appliance` is the
  `GeAppliance` object with the updated state and `state_changes` is a dictionary `{erd_key: new_value}` of the changed
  state.


  Representation of a single appliance
   * `mac_addr: Union[str, slixmpp.JID]` The appliance's MAC address, which is what GE uses as unique identifiers
   * `client: GeBaseClient` The client used to communicate with the device

   * `decode_erd_value(erd_code: ErdCodeType, erd_value: str)` Decode a raw ERD property value.
   * `encode_erd_value(erd_code: ErdCodeType, erd_value: str)` Decode a raw ERD property value.
   * `get_erd_value(erd_code: ErdCodeType)` Get the cached value of ERD code `erd_code`.  If `erd_code` is a string, this
   function will attempt to convert it to an `ErdCode` object first.
   * `async_request_update()` Request the appliance send an update of all properties
   * `set_available()` Mark the appliance as available
   * `async_set_erd_value(erd_code: ErdType, value)` Tell the device to set the property represented by `erd_code` to `value`
   * `set_unavailable()` Mark the appliance as unavailable
   * `update_erd_value(erd_code: ErdType, value)` Update the local property cache value for `erd_code` to `value`, where
   value is the not yet decoded hex string sent from the API. Returns `True` if that is a change in state, `False` otherwise.
   * `update_erd_values(self, erd_values: Dict[ErdCodeType, str])` Update multiple values in the local property cache.
   Returns a dictionary of changed states or an empty `dict` if nothing actually changed.

   * `appliance_type: Optional[ErdApplianceType]` The type of appliance, `None` if unknown
   * `available: bool` `True` if the appliance is available, otherwise `False`
   * `mac_addr` The appliance's MAC address (used as the appliance ID)



  * `ErdCode` `Enum` of known ERD property codes
  * `ErdApplianceType` Values for `ErdCode.APPLIANCE_TYPE`
  * `ErdMeasurementUnits` Values for `ErdCode.TEMPERATURE_UNIT`
  * `ErdOvenCookMode` Possible oven cook modes, used for `OvenCookSetting` among other things
  * `ErdOvenState` Values for `ErdCode.LOWER_OVEN_CURRENT_STATE` and `ErdCode.UPPER_OVEN_CURRENT_STATE`


  * `OvenCookSetting` A `namedtuple` of an `ErdOvenCookMode` and an `int` temperature
  * `OvenConfiguration` A `namedtuple` of boolean properties representing an oven's physical configuration





  The GE SmartHQ app communicates with devices through (at least) three different APIs: XMPP, HTTP REST, and what they
  seem to call MQTT (though that's not really accurate).  All of them are based around sending (pseudo-)HTTP requests
  back and forth.  Device properties are represented by hex codes (represented by `ErdCode` objects in `gekitchen`), and
  values are sent as hexadecimal strings without leading `"0x"`, then json encoded as a dictionary.  One thing that is
  important to note is that not all appliances support every API.

  1. REST - We can access or set most device properties via HTTP REST.  Unfortunately, relying on this means we need to
   result to constantly polling the devices, which is less than desirable, especially, e.g., for ovens that where we want
   to know exactly when a timer finishes. This API is not directly supported.
  2. Websocket "MQTT" - The WSS "MQTT" API is basically a wrapper around the REST API with the ability to subscribe to a
   device, meaning that we can treat it as (in Home Assistant lingo) IoT Cloud Push instead of IoT Cloud Polling.  In
   `gekitchen`, support for the websocket API is provided by the `GeWebsocketClient` class.
  2. XMPP - As far as I can tell, there seems to be little, if any, benefit to the XMPP API except that it will notify
   the client if a new device becomes available.  I suspect that this can be achieved with websocket API as well via
   subscriptions, but have not yet tested.  Support for the XMPP API is provided by the `GeXmppClient` class, based on
    [`slixmpp`](https://slixmpp.readthedocs.io/), which it requires as an optional dependency.


  The device informs the client of a state change by sending a `PUBLISH` message like this, informing us that the value of
  property 0x5205 (`ErdCode.LOWER_OVEN_KITCHEN_TIMER` in `gekitchen`) is now "002d" (45 minutes):

  ```xml
  <body>
      <publish>
          <method>PUBLISH</method>
          <uri>/UUID/erd/0x5205</uri>
          <json>{"0x5205":"002d"}</json>
      </publish>
  </body>
  ```

  Similarly, we can set the timer to 45 minutes by `POST`ing to the same "endpoint":
  ```xml
  <body>
      <request>
          <method>POST</method>
          <uri>/UUID/erd/0x5205</uri>
          <json>{"0x5205":"002d"}</json>
      </request>
  </body>
  ```
  In `gekitchen`, that would handled by the `GeAppliance.set_erd_value` method:
  ```python
  appliance.async_set_erd_value(ErdCode.LOWER_OVEN_KITCHEN_TIMER, timedelta(minutes=45))
  ```

  We can also get a specific property, or, more commonly, request a full cache refresh by `GET`ing the `/UUID/cache`
  endpoint:

  ```xml
  <body>
      <request>
          <id>0</id>
          <method>GET</method>
          <uri>/UUID/cache</uri>
      </request>
  </body>
  ```

  The device will then respond to the `GET` with a `response` having a json payload:
  ```xml
  <body>
      <response>
          <id>0</id>
          <method>GET</method>
          <uri>/UUID/cache</uri>
          <json>{
              "0x0006":"00",
              "0x0007":"00",
              "0x0008":"07",
              "0x0009":"00",
              "0x000a":"03",
              "0x0089":"",
              ...
          }</json>
      </response>
  </body>
  ```


pkgId: 7ca82d5f8b75ec8956c80544ca45e272089030b5400407f32ac6cbd501f235b4
name: python-geocoder
arch: src
version: 1.38.1
epoch: 0
release: 1
summary: Geocoder is a simple and consistent geocoding library.
url: https://github.com/DenisCarriere/geocoder
rpm_license: The MIT License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-566b5ab2-3177-462c-b757-2c9ff77ce3ed
location_href: 00009321-python-geocoder/python-geocoder-1.38.1-1.src.rpm
checksum_type: sha256
description:
  <!-- TOC -->
  - [Overview](#overview)
  - [A glimpse at the API](#a-glimpse-at-the-api)
      - [Forward](#forward)
      - [Multiple results](#multiple-results)
      - [Reverse](#reverse)
      - [House Addresses](#house-addresses)
      - [IP Addresses](#ip-addresses)
      - [Bounding Box](#bounding-box)
  - [Command Line Interface](#command-line-interface)
  - [Providers](#providers)
  - [Installation](#installation)
      - [PyPi Install](#pypi-install)
      - [GitHub Install](#github-install)
      - [Snap Install](#snap-install)
  - [Feedback](#feedback)
  - [Contribution](#contribution)
      - [Documenting](#documenting)
      - [Coding](#coding)
  - [ChangeLog](#changelog)
  <!-- /TOC -->

  Many online providers such as Google & Bing have geocoding services,
  these providers do not include Python libraries and have different
  JSON responses between each other.
  It can be very difficult sometimes to parse a particular geocoding provider
  since each one of them have their own JSON schema.
  Here is a typical example of retrieving a Lat & Lng from Google using Python,
  things shouldn't be this hard.
  ```python
  >>> import requests
  >>> url = 'https://maps.googleapis.com/maps/api/geocode/json'
  >>> params = {'sensor': 'false', 'address': 'Mountain View, CA'}
  >>> r = requests.get(url, params=params)
  >>> results = r.json()['results']
  >>> location = results[0]['geometry']['location']
  >>> location['lat'], location['lng']
  (37.3860517, -122.0838511)
  ```
  Now lets use Geocoder to do the same task
  ```python
  >>> import geocoder
  >>> g = geocoder.google('Mountain View, CA')
  >>> g.latlng
  (37.3860517, -122.0838511)
  ```

  Many properties are available once the geocoder object is created.

  ```python
  >>> import geocoder
  >>> g = geocoder.google('Mountain View, CA')
  >>> g.geojson
  >>> g.json
  >>> g.wkt
  >>> g.osm
  ```

  ```python
  >>> import geocoder
  >>> g = geocoder.mapquest(['Mountain View, CA', 'Boulder, Co'], method='batch')
  >>> for result in g:
  ('Mountain View', [37.39008, -122.08139])
  ('Boulder', [40.015831, -105.27927])
  ```

  ```python
  >>> import geocoder
  >>> g = geocoder.geonames('Mountain View, CA', maxRows=5)
  >>> print(len(g))
  5
  >>> for result in g:
  Mountain View ['37.38605', '-122.08385']
  Mountain View Elementary School ['34.0271', '-117.59116']
  Best Western Plus Mountainview Inn and Suites ['51.79516', '-114.62793']
  Best Western Mountainview Inn ['49.3338', '-123.1446']
  Mountain View Post Office ['37.393', '-122.07774']
  ```
  > The providers currently supporting multiple results are listed in the table [below](#providers).

  ```python
  >>> g = geocoder.google([45.15, -75.14], method='reverse')
  >>> g.city
  >>> g.state
  >>> g.state_long
  >>> g.country
  >>> g.country_long
  ```

  ```python
  >>> g = geocoder.google("453 Booth Street, Ottawa ON")
  >>> g.housenumber
  >>> g.postal
  >>> g.street
  >>> g.street_long
  ```

  ```python
  >>> g = geocoder.ip('199.7.157.0')
  >>> g = geocoder.ip('me')
  >>> g.latlng
  >>> g.city
  ```

  Accessing the JSON & GeoJSON attributes will be different
  ```python
  >>> g = geocoder.google("Ottawa")
  >>> g.bbox
  {"northeast": [45.53453, -75.2465979], "southwest": [44.962733, -76.3539158]}
  >>> g.geojson['bbox']
  [-76.3539158, 44.962733, -75.2465979, 45.53453]
  >>> g.southwest
  [44.962733, -76.3539158]
  ```

  ```bash
  $ geocode "Ottawa, ON"  >> ottawa.geojson
  $ geocode "Ottawa, ON" \
      --provide google \
      --out geojson \
      --method geocode
  ```

  | Provider                       | Optimal   | Usage Policy                    | Multiple results | Reverse | Proximity | Batch |
  |:-------------------------------|:----------|:--------------------------------|:-----------------|:--------|:----------|:------|
  | [ArcGIS][ArcGIS]               | World     |                                 | yes              | yes     |           |       |
  | [Baidu][Baidu]                 | China     | API key                         |                  | yes     |           |       |
  | [Bing][Bing]                   | World     | API key                         | yes              | yes     |           | yes   |
  | [CanadaPost][CanadaPost]       | Canada    | API key                         | yes              |         |           |       |
  | [FreeGeoIP][FreeGeoIP]         | World     |                                 |                  |         |           |       |
  | [Gaode][Gaode]                 | China     | API key                         |                  | yes     |           |       |
  | [Geocoder.ca][Geocoder.ca] (Geolytica) | CA & US | Rate Limit                |                  |         |           |       |
  | [GeocodeFarm][GeocodeFarm]     | World     | [Policy][GeocodeFarm-Policy]    | yes              | yes     |           |       |
  | [GeoNames][GeoNames]           | World     | Username                        | yes              |         | yes       |       |
  | [GeoOttawa][GeoOttawa]         | Ottawa    |                                 | yes              |         |           |       |
  | [Gisgraphy][Gisgraphy]         | World     | API key                         | yes              | yes     | yes       |       |
  | [Google][Google]               | World     | Rate Limit, [Policy][G-Policy]  | yes              | yes     | yes       |       |
  | [HERE][HERE]                   | World     | API key                         | yes              | yes     |           |       |
  | [IPInfo][IPInfo]               | World     | Rate Limit, [Plans][IP-Plans]   |                  |         |           |       |
  | [Komoot][Komoot] (OSM powered) | World     |                                 | yes              | yes     |           |       |
  | [LocationIQ][LocationIQ]       | World     | API Key                         | yes              | yes     |           |       |
  | [Mapbox][Mapbox]               | World     | API key                         | yes              | yes     | yes       |       |
  | [MapQuest][MapQuest]           | World     | API key                         | yes              | yes     |           | yes   |
  | [~~Mapzen~~][Mapzen]           | Shutdown  | API key                         | yes              | yes     |           |       |
  | [MaxMind][MaxMind]             | World     |                                 |                  |         |           |       |
  | [OpenCage][OpenCage]           | World     | API key                         | yes              | yes     |           |       |
  | [OpenStreetMap][OpenStreetMap] | World     | [Policy][OpenStreetMap-Policy]  | yes              | yes     |           |       |
  | [Tamu][Tamu]                   | US        | API key                         |                  |         |           |       |
  | [TGOS][TGOS]                   | Taiwan    |                                 |                  |         |           |       |
  | [TomTom][TomTom]               | World     | API key                         | yes              |         |           |       |
  | [USCensus][USCensus]           | US        |                                 |                  | yes     |           | yes   |
  | [What3Words][What3Words]       | World     | API key                         |                  | yes     |           |       |
  | [Yahoo][Yahoo]                 | World     |                                 |                  |         |           |       |
  | [Yandex][Yandex]               | Russia    |                                 | yes              | yes     |           |       |


  To install Geocoder, simply:
  ```bash
  $ pip install geocoder
  ```

  Installing the latest version from Github:
  ```bash
  $ git clone https://github.com/DenisCarriere/geocoder
  $ cd geocoder
  $ python setup.py install
  ```

  To install the stable geocoder [snap](https://snapcraft.io) in any of the [supported Linux distros](https://snapcraft.io/docs/core/install):
  ```bash
  $ sudo snap install geocoder
  ```
  If you want to help testing the latest changes from the master branch, you can install it from the edge channel:
  ```bash
  $ sudo snap install geocoder --edge
  ```
  The installed snap will be updated automatically every time a new version is pushed to the store.

  Please feel free to give any feedback on this module.
  Speak up on Twitter [@DenisCarriere](https://twitter.com/DenisCarriere) and tell me how you use this Python Geocoder. New updates will be pushed to Twitter Hashtags [#python](https://twitter.com/search?q=%23python).

  If you find any bugs or any enhancements to recommend please send some of your comments/suggestions to the [Github Issues Page](https://github.com/DenisCarriere/geocoder/issues).
  Some way to contribute, from the most generic to the most detailed:

  If you are not comfortable with development, you can still contibute with the documentation.
  - review the documentation of a specific provider. Most of the time they are lacking details...
  - review the parameters for a specific method, compared to what is supported by the provider
  - review documentation for command line
  If you miss any feature, just create an issue accordingly. Be sure to describe clearly your use case, and to provide links to the correct sources.

  - add support for a new provider. _Documentation TBD_, starting point possible with [wip_guide](https://geocoder.readthedocs.io/wip_guide.html).
  - extend methods for an existing support, i.e support an additionnal API). _Documentation TBD_
  - extend support of an existing API, i.e, support more (json) fields from the response, or more parameters. _Documentation TBD_

  See [CHANGELOG.md](./CHANGELOG.md)
  [TGOS]: http://geocoder.readthedocs.org/providers/TGOS.html
  [Mapbox]: http://geocoder.readthedocs.org/providers/Mapbox.html
  [Google]: http://geocoder.readthedocs.org/providers/Google.html
  [G-Policy]: https://developers.google.com/maps/documentation/geocoding/usage-limits
  [Bing]: http://geocoder.readthedocs.org/providers/Bing.html
  [LocationIQ]: http://geocoder.readthedocs.org/providers/LocationIQ.html
  [OpenStreetMap]: http://geocoder.readthedocs.org/providers/OpenStreetMap.html
  [OpenStreetMap-Policy]: https://operations.osmfoundation.org/policies/nominatim/
  [HERE]: http://geocoder.readthedocs.org/providers/HERE.html
  [TomTom]: http://geocoder.readthedocs.org/providers/TomTom.html
  [MapQuest]: http://geocoder.readthedocs.org/providers/MapQuest.html
  [OpenCage]: http://geocoder.readthedocs.org/providers/OpenCage.html
  [Yahoo]: http://geocoder.readthedocs.org/providers/Yahoo.html
  [ArcGIS]: http://geocoder.readthedocs.org/providers/ArcGIS.html
  [Yandex]: http://geocoder.readthedocs.org/providers/Yandex.html
  [Geocoder.ca]: http://geocoder.readthedocs.org/providers/Geocoder-ca.html
  [Baidu]: http://geocoder.readthedocs.org/providers/Baidu.html
  [GeoOttawa]: http://geocoder.readthedocs.org/providers/GeoOttawa.html
  [FreeGeoIP]: http://geocoder.readthedocs.org/providers/FreeGeoIP.html
  [MaxMind]: http://geocoder.readthedocs.org/providers/MaxMind.html
  [Mapzen]: https://mapzen.com/blog/shutdown
  [What3Words]: http://geocoder.readthedocs.org/providers/What3Words.html
  [CanadaPost]: http://geocoder.readthedocs.org/providers/CanadaPost.html
  [GeoNames]: http://geocoder.readthedocs.org/providers/GeoNames.html
  [IPInfo]: http://geocoder.readthedocs.org/providers/IPInfo.html
  [Tamu]: http://geoservices.tamu.edu/Services/Geocode/WebService/
  [GeocodeFarm]: https://geocode.farm/
  [GeocodeFarm-Policy]: https://geocode.farm/geocoding/free-api-documentation/
  [Gaode]: http://geocoder.readthedocs.org/providers/.html
  [IP-Plans]: http://ipinfo.io/pricing
  [Komoot]: http://photon.komoot.de
  [USCensus]: https://geocoding.geo.census.gov/geocoder/Geocoding_Services_API.html
  [Gisgraphy]: https://premium.gisgraphy.com/


pkgId: a78072c2cda5cebbf66cfe1f3ed8f6ef796be1efba355bb8bb9c225d6053b6b0
name: python-geog
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Numpy-based vectorized geospatial functions
url: https://github.com/jwass/geog
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-cc8316d7-db6e-4f3d-80a3-58119fb54fd1
location_href: 00012875-python-geog/python-geog-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A pure numpy implementation for geodesic functions. The interfaces are
  vectorized according to numpy broadcasting rules compatible with a variety of
  inputs including lists, numpy arrays, and
  [Shapely](http://toblerity.org/shapely/) geometries - allowing for 1-to-1,
  N-to-1, or the element-wise N-to-N calculations in a single call.
  `geog` uses a spherical Earth model (subject to change) with radius 6371.0 km.
  `geog` draws inspiration from [TurfJS](https://www.turfjs.org)


pkgId: 7a360dd919428fed890638620103cd1414a03b363666cb91d97c8d638809f72e
name: python-geographiclib
arch: src
version: 2.0
epoch: 0
release: 1
summary: The geodesic routines from GeographicLib
url: https://geographiclib.sourceforge.io/Python/2.0
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1e4613f6-b833-4dcd-8b8d-b2b6b62556c0
location_href: 00002849-python-GeographicLib/python-geographiclib-2.0-1.src.rpm
checksum_type: sha256
description:
  This is a library to solve geodesic problems on an ellipsoid model of
  the earth.

  Licensed under the MIT/X11 License; see
  [LICENSE.txt](https://geographiclib.sourceforge.io/LICENSE.txt).

  The algorithms are documented in

  * C. F. F. Karney,
    [Algorithms for geodesics](https://doi.org/10.1007/s00190-012-0578-z),
    J. Geodesy **87**(1), 43–55 (2013);
    [Addenda](https://geographiclib.sourceforge.io/geod-addenda.html).

  The documentation for this package is in
  https://geographiclib.sourceforge.io/Python/doc


pkgId: 8e9e231672ba69d236c8caf31a82120ba298c0eb8d37e9e717f9f8315cabc548
name: python-geohash2
arch: src
version: 1.1
epoch: 0
release: 1
url: https://github.com/dbarthe/geohash/
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-a71a7061-6460-4edc-8e59-4deac920501b
location_href: 00011241-python-geohash2/python-geohash2-1.1-1.src.rpm
checksum_type: sha256
summary:
  (Geohash fixed for python3) Module to decode/encode Geohashes to/from latitude and longitude.  See http://en.wikipedia.org/wiki/Geohash

description:
  This module provides functions to decode and encode Geohashes to and from latitude and longitude coordinates.

rpm_license:
  GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.


pkgId: ae243cd37c1a8616f4337cd3edcd5330a2ab2c943ddda382931c843d6dfb025d
name: python-geojson
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Python bindings and utilities for GeoJSON
url: https://github.com/jazzband/geojson
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-df6d5196-ab79-42ee-90c1-a6e2965e4f2a
location_href: 00003743-python-geojson/python-geojson-3.0.1-1.src.rpm
checksum_type: sha256
description:
  This Python library contains:
  - Functions for encoding and decoding GeoJSON_ formatted data
  - Classes for all GeoJSON Objects
  - An implementation of the Python `__geo_interface__ Specification`_
  **Table of Contents**


pkgId: d26e871a9edf9e5ceefb891ca7242a684241adc8c806917acd60b1b9ebf979e7
name: python-geomet
arch: src
version: 1.0.0
epoch: 0
release: 1
description:
  GeoMet

  Convert GeoJSON to WKT/WKB (Well-Known Text/Binary), and vice versa.

url: https://github.com/geomet/geomet
rpm_license: Apache 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-3c646974-25fd-4012-9bbf-c3262b280cf2
location_href: 00003744-python-geomet/python-geomet-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Conversion library for common geospatial data formats (GeoJSON/WKT/EWKT/WKB/EWKB/GeoPackage/EsriJson)


pkgId: 8bd5fd91dfb43c6551a77b816ed2a7745cead59781e54987412d1472b9a3c19e
name: python-geopandas
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: Geographic pandas extensions
url: http://geopandas.org
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-fb35b4d5-821b-4f44-8c95-eb3185488137
location_href: 00003745-python-geopandas/python-geopandas-0.12.2-1.src.rpm
checksum_type: sha256
description:
  GeoPandas is a project to add support for geographic data to
  `pandas`_ objects.

  The goal of GeoPandas is to make working with geospatial data in
  python easier. It combines the capabilities of `pandas`_ and `shapely`_,
  providing geospatial operations in pandas and a high-level interface
  to multiple geometries to shapely. GeoPandas enables you to easily do
  operations in python that would otherwise require a spatial database
  such as PostGIS.

  .. _pandas: http://pandas.pydata.org
  .. _shapely: http://shapely.readthedocs.io/en/latest/


pkgId: a9f726cb1b39d8d525e76638c1ebebbcc8ec26ccdc0a6692870ff893ce241955
name: python-geopy
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Python Geocoding Toolbox
url: https://github.com/geopy/geopy
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-213fff94-76e6-4c02-a097-c64da1f6969c
location_href: 00003747-python-geopy/python-geopy-2.3.0-1.src.rpm
checksum_type: sha256
description:
  geopy is a Python client for several popular geocoding web
  services.
  geopy makes it easy for Python developers to locate the coordinates of
  addresses, cities, countries, and landmarks across the globe using
  third-party geocoders and other data sources.
  geopy includes geocoder classes for the `OpenStreetMap Nominatim`_,
  `Google Geocoding API (V3)`_, and many other geocoding services.
  The full list is available on the `Geocoders doc section`_.
  Geocoder classes are located in `geopy.geocoders`_.
  geopy is tested against CPython (versions 3.7, 3.8, 3.9, 3.10, 3.11)
  and PyPy3. geopy 1.x line also supported CPython 2.7, 3.4 and PyPy2.
  © geopy contributors 2006-2018 (see AUTHORS) under the `MIT
  License <https://github.com/geopy/geopy/blob/master/LICENSE>`__.


pkgId: f891a3cd342b800f9fb9ab2ec63217a81a473d31efd2a642faaca07ce0a3f547
name: python-geospark
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: GeoSpark Python
url: https://github.com/DataSystemsLab/GeoSpark/tree/master/python
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2f3f0d9d-986a-4d77-9980-52f82149c19f
location_href: 00012083-python-geospark/python-geospark-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This library is Python wrapper on GeoSpark library.

  GeoSpark is a cluster computing system for processing large-scale spatial data. GeoSpark extends Apache Spark / SparkSQL with a set of out-of-the-box Spatial Resilient Distributed Datasets (SRDDs)/ SpatialSQL that efficiently load, process, and analyze large-scale spatial data across machines.

  Python version supports:
  <li> GeoSpark core </li>
  <li> GeoSpark SQL </li>

  Please follow tutorial on official GeoSpark website:
  https://datasystemslab.github.io/GeoSpark/


pkgId: 135bb1f9d745b61c3a3d82829d86d7b7d7bd436ac966dfdd277302c8f0998f34
name: python-gerritlib
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Client library for accessing Gerrit.
url: https://opendev.org/opendev/gerritlib
rpm_license: apache
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d7469c72-9314-427a-8b77-0f507cd50eea
location_href: 00003748-python-gerritlib/python-gerritlib-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Gerritlib is a Python library for interacting with Gerrit_.
  It aims to provide a more conventionally pythonic way of managing a
  Gerrit instance.
  To install::
      $ sudo python setup.py install
  Online documentation:
  * http://gerritlib.readthedocs.org/en/latest/


pkgId: 6934980ff99fad4a52b0a71cfbf49ebaa375f4cddbdc8922e46474ce6cc64337
name: python-gerrymander
arch: src
version: 1.5
epoch: 0
release: 1
summary: A client API and command line tool for gerrit
url: https://github.com/berrange/gerrymander
rpm_license: ASL 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-2ef7892a-42df-4e77-9881-44eb00683511
location_href: 00003749-python-gerrymander/python-gerrymander-1.5-1.src.rpm
checksum_type: sha256
description:
  Gerrymander provides a set of APIs and command line tool for interacting with the gerrit code review system


pkgId: 8ade35eeb6614c764127b265d4111fddc464c1433232f9d387637268feebbd94
name: python-gertty
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Gertty is a console-based interface to the Gerrit Code Review system.
url: http://ttygroup.org/
rpm_license: Apache Software License
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-d36a7469-7032-4952-a6d9-20c474a0b78d
location_href: 00003750-python-gertty/python-gertty-1.6.0-1.src.rpm
checksum_type: sha256
description:
  Gertty is a console-based interface to the Gerrit Code Review system.
  As compared to the web interface, the main advantages are:
   * Workflow -- the interface is designed to support a workflow similar
     to reading network news or mail.  In particular, it is designed to
     deal with a large number of review requests across a large number
     of projects.
   * Offline Use -- Gertty syncs information about changes in subscribed
     projects to a local database and local git repos.  All review
     operations are performed against that database and then synced back
     to Gerrit.
   * Speed -- user actions modify locally cached content and need not
     wait for server interaction.
   * Convenience -- because Gertty downloads all changes to local git
     repos, a single command instructs it to checkout a change into that
     repo for detailed examination or testing of larger changes.


pkgId: 0933864e1f34de1c6299ecfff576885a5e1278bbee1ec42c59d2ef40ac33a054
name: python-getmac
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Get MAC addresses of remote hosts and local interfaces
url: https://github.com/GhostofGoes/getmac
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-b6733fd1-51e1-4afa-9be5-46111da0865a
location_href: 00003751-python-getmac/python-getmac-0.9.2-1.src.rpm
checksum_type: sha256
description:
  [![Latest version on PyPI](https://badge.fury.io/py/getmac.svg)](https://pypi.org/project/getmac/)
  [![Coverage Status](https://coveralls.io/repos/github/GhostofGoes/getmac/badge.svg?branch=main)](https://coveralls.io/github/GhostofGoes/getmac?branch=main)
  [![GitHub Actions Pipeline Status](https://github.com/ghostofgoes/getmac/actions/workflows/ci.yml/badge.svg)](https://github.com/GhostofGoes/getmac/actions)
  [![Weekly PyPI downloads](https://pepy.tech/badge/getmac/week)](https://pepy.tech/project/getmac)
  [![PyPI downloads](https://pepy.tech/badge/getmac)](https://pepy.tech/project/getmac)
  [![PyPI downloadss of the old name](https://pepy.tech/badge/get-mac)](https://pepy.tech/project/get-mac)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  Pure-Python package to get the MAC address of network interfaces and hosts on the local network.

  It provides a platform-independent interface to get the MAC addresses of:

  - System network interfaces (by interface name)
  - Remote hosts on the local network (by IPv4/IPv6 address or hostname)

  It provides one function: `get_mac_address()`

  [![asciicast](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus.png)](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus)

  [![asciicast](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv.png)](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv)



  If you only need the addresses of network interfaces, have a limited set of platforms to support, and are able to handle C-extension modules, then you should instead check out the excellent [netifaces](https://pypi.org/project/netifaces/) package by Alastair Houghton ([@al45tair](https://github.com/al45tair)). It's significantly faster (thanks to it being C-code) and has been around a long time and seen widespread usage. However, unfortunately it is no longer maintained as of [May 2021](https://github.com/al45tair/netifaces/commit/ec55b59e27542776f55e0f9e3213a75bf8e0f367), so it may not be a great choice for new projects. Another great option that fits these requirements is the well-known and battle-hardened [psutil](https://github.com/giampaolo/psutil) package by Giampaolo Rodola.

  If the only system you need to run on is Linux, you can run as root, and C-extensions modules are fine, then you should instead check out the [arpreq](https://pypi.org/project/arpreq/) package by Sebastian Schrader. In some cases it can be significantly faster.

  If you want to use `psutil`, `scapy`, or `netifaces`, I have examples of how to do so in a [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  Stable release from PyPI

  ```bash
  pip install getmac
  ```

  Latest development version

  ```bash
  pip install https://github.com/ghostofgoes/getmac/archive/main.tar.gz
  ```


  ```python
  from getmac import get_mac_address
  eth_mac = get_mac_address(interface="eth0")
  win_mac = get_mac_address(interface="Ethernet 3")
  ip_mac = get_mac_address(ip="192.168.0.1")
  ip6_mac = get_mac_address(ip6="::1")
  host_mac = get_mac_address(hostname="localhost")
  updated_mac = get_mac_address(ip="10.0.0.1", network_request=True)


  from getmac import getmac
  getmac.DEBUG = 2  # DEBUG level 2
  print(getmac.get_mac_address(interface="Ethernet 3"))


  from getmac import getmac
  getmac.PORT = 44444  # Default is 55555
  print(getmac.get_mac_address(ip="192.168.0.1", network_request=True))
  ```


  **Python 2 users**: use `getmac2` or `python -m getmac` instead of `getmac`.
  ```bash
  getmac --help
  getmac --version


  getmac


  python3 -m getmac


  getmac --interface ens33
  getmac --ip 192.168.0.1
  getmac --ip6 ::1
  getmac --hostname home.router


  python -m getmac -i 'Ethernet 4'
  python -m getmac -4 192.168.0.1
  python -m getmac -6 ::1
  python -m getmac -n home.router




  getmac --no-network-request --ip 192.168.0.1
  python -m getmac --no-network-request -n home.router


  getmac --verbose


  getmac -v --debug
  python -m getmac -v -d -i enp11s4
  python -m getmac -v -dd -n home.router


  getmac --ip 192.168.0.1 --override-port 9001





  getmac -i eth0 --override-platform linux
  getmac --ip 192.168.0.1 --override-platform windows


  getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost
  ```


  - `interface`: Name of a network interface on the system
  - `ip`: IPv4 address of a remote host
  - `ip6`: IPv6 address of a remote host
  - `hostname`: Hostname of a remote host
  - `network_request`: If an network request should be made to update and populate the ARP/NDP table of remote hosts used to lookup MACs in most circumstances. Disable this if you want to just use what's already in the table, or if you have requirements to prevent network traffic. The network request is a empty UDP packet sent to a high port, `55555` by default. This can be changed by setting `getmac.PORT` to the desired integer value. Additionally, on Windows, this will send a UDP packet to `1.1.1.1:53` to attempt to determine the default interface (Note: the IP is [CloudFlare's DNS server](https://www.cloudflare.com/learning/dns/what-is-1.1.1.1/)).


  - `logging.getLogger("getmac")`: Runtime messages and errors are recorded to the `getmac` logger using Python's [logging](https://docs.python.org/3/library/logging.html) module. They can be configured by using [logging.basicConfig()](https://docs.python.org/3/library/logging.html#logging.basicConfig) or adding handlers to the `"getmac"` logger.
  - `getmac.getmac.DEBUG`: integer value that controls debugging output. The higher the value, the more output you get.
  - `getmac.getmac.PORT`: UDP port used to populate the ARP/NDP table (see the documentation of the `network_request` argument in `get_mac_address()` for details)
  - `getmac.getmac.OVERRIDE_PLATFORM`: Override the platform detection with the given value (e.g. `"linux"`, `"windows"`, `"freebsd"`, etc.'). Any values returned by `platform.system()` are valid.
  - `getmac.getmac.FORCE_METHOD`: Force a specific method to be used, e.g. 'IpNeighborShow'. This will be used regardless of it's method type or platform compatibility, and `Method.test()` will NOT be checked! The list of available methods is in `getmac.getmac.METHODS`.


  - Pure-Python (no compiled C-extensions required!)
  - Python 2.7 and 3.4+
  - Lightweight, with no dependencies and a small package size
  - Can be dropped into a project as a standalone .py file
  - Supports most interpreters: CPython, pypy, pypy3, IronPython 2.7, and Jython 2.7
  - Provides a simple command line tool (when installed as a package)
  - MIT licensed!


  If you are running a old Python (2.6/3.3 and older) or interpreter, then you can install an older version of `getmac` that supported that version. The wheels are available in the [GitHub releases](https://github.com/GhostofGoes/getmac/releases), or from PyPI with a current version of `pip` and some special arguments.

  - Python 2.5: get-mac 0.5.0
  - Python 2.6: getmac 0.6.0
  - Python 3.2: get-mac 0.3.0
  - Python 3.3: get-mac 0.3.0

  NOTE: these versions do not have many of the performance improvements, platform support, and bug fixes that came with later releases. They generally work, just not as well. However, if you're using such an old Python, you probably don't care about all that :)


  - Python 3.10 and 3.11 should work, but are not automatically tested at the moment due to having to support 2.7
  - If none of the arguments are selected, the default network interface for the system will be used. If the default network interface cannot be determined, then it will attempt to fallback to typical defaults for the platform (`Ethernet` on Windows, `em0` on BSD, `en0` on OSX/Darwin, and `eth0` otherwise). If that fails, then it will fallback to `lo` on POSIX systems.
  - "Remote hosts" refer to hosts in your local layer 2 network, also commonly referred to as a "broadcast domain", "LAN", or "VLAN". As far as I know, there is not a reliable method to get a MAC address for a remote host external to the LAN. If you know any methods otherwise, please [open a GitHub issue](https://github.com/GhostofGoes/getmac/issues) or shoot me an email, I'd love to be wrong about this.
  - The first four arguments are mutually exclusive. `network_request` does not have any functionality when the `interface` argument is specified, and can be safely set if using in a script.
  - The physical transport is assumed to be Ethernet (802.3). Others, such as Wi-Fi (802.11), are currently not tested or considered. I plan to address this in the future, and am definitely open to pull requests or issues related to this, including error reports.
  - **Exceptions will be handled silently and returned as a None.** If you run into problems, you can set `DEBUG` to true and get more     information about what's happening. If you're still having issues, please create an [issue on GitHub](https://github.com/GhostofGoes/getmac/issues) and include the output with `DEBUG` enabled.


  - Windows
      - Commands: `getmac.exe`, `ipconfig.exe`, `arp.exe`, `wmic.exe`
      - Libraries: `uuid`, `ctypes`, `socket`
  - Linux/Unix
      - Commands: `arp`, `ip`, `ifconfig`, `netstat`, `ip link`, `lanscan`
      - Libraries: `uuid`, `fcntl`, `socket`
      - Files: `/sys/class/net/{iface}/address`, `/proc/net/arp`
      - Default interfaces: `/proc/net/route`, `route`, `ip route list`
  - Mac OSX (Darwin)
      - `networksetup`
      - Same commands as Linux
  - WSL
      - Windows commands are used for remote hosts
      - Unix commands are used for interfaces
  - OpenBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `route`
  - FreeBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `netstat`
  - Android
      - Commands: `ip link`


  All or almost all features should work on "supported" platforms. While other versions of the same family or distro may work, they are untested and may have bugs or missing features.

  - Windows
      - Desktop: 7, 8, 8.1, 10, 11 (thanks @StevenLooman for testing Windows 11!)
      - Server: TBD
      - Partially supported (untested): 2000, XP, Vista
  - Linux distros
      - CentOS/RHEL 6+
      - Ubuntu 16.04+ (15.10 and older should work, but are untested)
      - Fedora (24+)
  - Mac OSX (Darwin)
      - The latest two versions probably (TBD)
  - Android (6+)
  - Windows Subsystem for Linux (WSL)
  - FreeBSD (11+)
  - OpenBSD
  - Docker


  Add `-v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp` to access arp table of host inside container in bridge network mode.

  ```bash
  docker build -f packaging/Dockerfile -t getmac .
  docker run -it getmac:latest --help
  docker run -it getmac:latest --version
  docker run -it getmac:latest -n localhost
  docker run --rm -it -v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp getmac:latest -n 192.168.0.1
  ```


  - Depending on the platform, there could be a performance detriment, due to heavy usage of regular expressions.
  - Platform test coverage is imperfect. If you're having issues, then you might be using a platform I haven't been able to test. Keep calm, open a GitHub issue, and I'd be more than happy to help.


  - Linux, WSL: Getting the mac of a local interface IP does not currently work (`getmac --ip 10.0.0.4` will fail if `10.0.0.4` is the IP address of a local interface). This issue may be present on other POSIX systems as well.
  - Hostnames for IPv6 devices are not yet supported.
  - Windows: the "default" (used when no arguments set or specified) of selecting the default route interface only works effectively if `network_request` is enabled. If not, `Ethernet` is used as the default.
  - IPv6 support is good but lags behind IPv4 in some places and isn't as well-tested across the supported platform set.


  The Python standard library has a robust set of networking functionality, such as `urllib`, `ipaddress`, `ftplib`, `telnetlib`, `ssl`, and more. Imagine my surprise, then, when I discovered there was not a way to get a seemingly simple piece of information: a MAC address. This package was born out of a need to get the MAC address of hosts on the network without needing admin permissions, and a cross-platform way get the addresses of local interfaces.

  In Fall 2018 the package name changed to `getmac` from `get-mac`. This affected the package name, the CLI script, and some of the documentation. There were no changes to the core library code. While both package names will updated on PyPI, the use of `getmac` is preferred.

  In Summer 2020, the code was significantly refactored, moving to a class-based structure and significantly improving performance and accuracy. See [docs/rewrite.md](docs/rewrite.md) for details.


  Contributors are more than welcome! See the [contribution guide](CONTRIBUTING.md) to get started, and checkout the [todo list](TODO.md) for a full list of tasks and bugs.

  Before submitting a PR, please make sure you've completed the [pull request checklist](CONTRIBUTING.md#Code_requirements)!

  The [Python Discord server](https://discord.gg/python) is a good place to ask questions or discuss the project (Handle: @KnownError#0001).


  - Christopher Goes (@ghostofgoes) - Author and maintainer
  - Calvin Tran (@cyberhobbes) - Windows interface detection improvements
  - Daniel Flanagan (@FlantasticDan) - Code cleanup
  - @emadmahdi - Android fixes
  - Izra Faturrahman (@Frizz925) - Unit tests using the platform samples
  - Jose Gonzalez (@Komish) - Docker container and Docker testing
  - @fortunate-man - Awesome usage videos
  - @martmists - legacy Python compatibility improvements
  - @hargoniX - scripts and specfiles for RPM packaging
  - Ville Skyttä (@scop) - arping lookup support
  - Tomasz Duda (@tomaszduda23) - support for docker in network bridge mode
  - Steven Looman (@StevenLooman) - Windows 11 testing


  Many of the methods used to acquire an address and the core logic framework are attributed to the CPython project's UUID implementation.

  - https://github.com/python/cpython/blob/master/Lib/uuid.py
  - https://github.com/python/cpython/blob/2.7/Lib/uuid.py


  - [_unix_fcntl_by_interface](https://stackoverflow.com/a/4789267/2214380)
  - [_windows_get_remote_mac_ctypes](goo.gl/ymhZ9p)
  - [String joining](https://stackoverflow.com/a/3258612/2214380)


  MIT. Feel free to copy, modify, and use to your heart's content. Enjoy :)




  **NOTE**: if any changes significantly impact your project or use case, please open an issue on [GitHub](https://github.com/GhostofGoes/getmac/issues) or email me (see git commit author info for address).

  **Announcement**: Compatibility with Python versions older than 3.7 (2.7, 3.4, 3.5, and 3.6) is deprecated and will be removed in getmac 1.0.0. If you are stuck on an unsupported Python, consider loosely pinning the version of this package in your dependency list, e.g. `getmac<1.0.0` or `getmac~=0.9.0`.




  * Fix flakyness with UuidArpGetNode on MacOS by making it the last method attempted (Fixes issue [#82](https://github.com/GhostofGoes/getmac/issues/82))




  * Deprecate Python 3.6 support (support will be removed in getmac 1.0.0)


  * Fix links in README and PyPI metadata to use "main" instead of "master" for primary branch
  * Remove "Documentation" link from PyPI (the ReadTheDocs site is broken and hasn't been updated since 0.5.0)
  * Add PyPI classifiers for 3.10 and 3.11
  * Some cleanup of CHANGELOG



  This release is a *complete rewrite of getmac from the ground up*. The public API of `getmac` is **unchanged** as part of this rewrite. `get_mac_address()` is still the primary way of getting a MAC address, it's just the "under the hood" internals that have changed completely.

   It's passing tests and seems to be operable. However, with a change this large there are inevitably issues that the tests or I don't catch, so I'm doing a series of pre-releases until I'm 99% confident in it's stability. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes.

  The new system has a number of benefits
  - Reduction of false-positives and false-negatives by improving method selection accuracy (platform, validity, etc.)
  - *Significantly* faster overall
  - "Misses" have the same performance as "Hits"
  - Easier to test, since each method can be tested directly via it's class
  - Easier to type annotate and analyze with mypy
  - Easier to read, improving reviewability and ease of contributing for newcomers
  - Extensible! Custom methods can be defined and added at runtime (which is perfect if you have some particular edge case but aren't able to open-source it).


  * Fully support Python 3.9 (automated tests in CI)
  * Tentatively support Python 3.10 and 3.11 (unable to test due to the need to be able to still test 2.7)
  * Added default interface detection for MacOS (command: `route get default`)
  * Added initial support for Solaris/SunOS. There were a few existing methods that worked as-is, so just added indicators that those methods support `sunos` (Which applies to any system where `platform.system() == SunOS`).
  * `arping` (POSIX) or `SendARP` (Windows) will now *always* be used instead of sending a UDP packet when looking for the MAC of a IPv4 host, if they're available and operable (otherwise, UDP + ARP table check will be used like before).
  * The amount of time taken to get a result (in seconds) will now be recorded and logged if debugging is enabled (`DEBUG>=1` or `-d`)
  * Added command line argument to override the UDP port for network requests: `--override-port` (this was already possible in Python via `getmac.getmac.PORT`, but wasn't configurable via the CLI. Now it is!).
  * Added ability to override the detected platform via `--override-platform` argument (CLI) or `getmac.getmac.OVERRIDE_PLATFORM` variable (Python). This will force methods for that platform to be used, regardless of the actual platform. Here's an example forcing `linux` to be used as the platform: `getmac -i eth0 --override-platform linux`. In version 1.0.0, this feature will added as an argument to `get_mac_address()`.
  * Added ability to force a specific method to be used via `--force-method` argument (CLI) or `getmac.getmac.FORCE_METHOD` variable (Python). This is useful for troubleshooting issues, general debugging, and testing changes. Example: `getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost`


  * **Complete rewrite of `getmac` from the ground up. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes**
  * Fixed a failure to look up a hostname now returns `None`, as expected, instead of raising an exception (`socket.gaierror`).
  * Fixed numerous false-negative and false-positive bugs
  * Improved overall performance
  * Performance for cases where no MAC is found is now the same as cases where a MAC is found (speed of "misses" now equals that of "hits")
  * Improved the reliability and performance of many methods
  * Fixed `netstat` on older Linux distros (such as Ubuntu 12.04)
  * Overhauled `ifconfig` parsing. It should now be far more reliable and accurate across all platforms.
  * Improved Android support. Note that newer devices are locked down and the amount of information that's obtainable by an unprivileged process is quite limited (Android 7/9 and newer, not sure exactly when they changed this, I'm not an Android guy). That being said, the normal Linux methods should work fine, provided you have the proper permissions (usually, `root`).
  * Fixed bug with `/proc/net/route` parsing (this affected Android and potentially other platforms)
  * Improve default interface detection for FreeBSD (command: `route get default`)


  * Removed man pages from distribution (`getmac.1`/`getmac2.1`). They were severely out of date and unused. May re-add at a later date.


  * Migrate CI to GitHub Actions, remove TravisCI and Appveyor
  * Add flake8 plugins: `flake8-pytest-style` and `flake8-annotations`
  * Add additional samples and tests for WSL1 (with the Ubuntu 18.04 distro)
  * Add additional samples for Windows 10
  * Add additional samples for MacOS
  * Add samples and tests for Ubuntu 12.04
  * Add samples for NetBSD 8 (support coming in a future release)
  * Add samples for Solaris 10 (support TBD)
  * Add samples for several versions of Android
  * Add new tests
  * Improve existing tests
  * Consolidate everything related to RPM packaging to `packaging/rpm/`. This stuff hasn't been updated since 0.6.0, may remove in the future and leave distro packaging to distro maintainers.





  * Added support for Thomas Habets' version of `arping` in addition to the existing iputils one (contributed by Ville Skyttä (@scop) in [#52](https://github.com/GhostofGoes/getmac/pull/52) and [#54](https://github.com/GhostofGoes/getmac/pull/54))
  * Added support for docker in network bridge mode (contributed by Tomasz Duda (@tomaszduda23) in [#57](https://github.com/GhostofGoes/getmac/pull/57))
  * Add CHANGELOG URL to PyPI metadata (contributed by Ville Skyttä (@scop) in [#58](https://github.com/GhostofGoes/getmac/pull/58))
  * Fixed code quality test suite errors (includes changes by Daniel Flanagan (@FlantasticDan) in [#67](https://github.com/GhostofGoes/getmac/pull/67))
  * Improved Android support (contributed by @emadmahdi in [#71](https://github.com/GhostofGoes/getmac/pull/71))
  * Minor code quality fixes (2 years of neglecting master branch)
  * Add [Code of Conduct](https://github.com/GhostofGoes/getmac/blob/main/CODE_OF_CONDUCT.md) for project contributors
  * Add [SECURITY.md](https://github.com/GhostofGoes/getmac/blob/main/SECURITY.md) for reporting security issues (e.g. vulnerabilities)
  * Deprecate Python 3.4 and 3.5
  * Issue deprecation message as a warning in addition to a log message





  * Added warning about Python 2 compatibility being dropped in 1.0.0
  * Officially support Python 3.8
  * Documented a known issue with looking up IP of a local interface on Linux/WSL (See the "Known Issues" section in the README)
  * Added remote host lookup using `arping` as last resort


  * Standardized formatting on [Black](https://github.com/psf/black)
  * Lint additions: `vulture`, several Flake8 plugins
  * Pinned test dependencies (pytest 5 dropped Python 2 support)
  * Various quality-of-life improvements for contributors/developers





  * Fixed sockets being opened and not closed when `ip` or `ip6` were used,
  which could lead to a `ResourceWarning` (GH-42)





  * OpenBSD support
  * FreeBSD support
  * Python logging is now used instead of `print` (logger: `getmac`)
  * Include tests in the source distribution
  * (CLI) Added aliases for `--no-network-requests`: `-N` and `--no-net`
  * (CLI) New argument: `-v`/`--verbose`


  * Errors are now logged instead of raising a `RuntimeWarning`
  * Improved Ubuntu support
  * Performance improvements


  * Significant increase in overall test coverage
  * Fixed and migrated the sample tests to `pytest`
  * Added tests for the CLI





  * Type annotations (PEP 484)


  * Dropped support for Python 2.6
  * Removed the usage of third-party packages (`netifaces`, `psutil`, `scapy`, and `arpreq`).
  This should improve the performance of lookups of non-existent interfaces
  or hosts, since this feature was punishing that path without providing much value.
  If you want to use these packages directly, I have a guide on how to do so on a
  [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  * Significantly improved the performance of the common cases on Linux
  for interfaces and remote hosts
  * Improved POSIX interface performance. Commands specific to OSX
  will be run only on that platform, and vice-versa.
  * Significantly improved the speed and accuracy of determining
  the default interface on Linux
  * Python 2 will install an executor named getmac2 and Python 3 an
  executor named getmac so they do not conflict when both RPMs are
  installed on the same system (Credit: @hargoniX)
  * The `warnings` module will only be imported if a error/warning
  occurs (improve compatibility with some freezers, notably PyInstaller)
  * Improved system platform detection
  * Various other minor performance improvements


  * Added unit tests for the samples (Credit: @Frizz925)
  * Scripts for building RPMs in the /scripts directory (Credit: @hargoniX)
  * Improved code quality and health checks
  * Include the CHANGELOG on the PyPI project page
  * Using `pytest` for all tests now instead of `unittest`


  * Added instructions on how to build a Debian package (Credit: @kofrezo)




  * Windows default interface detection if `network_request` is enabled (Credit: @cyberhobbes)
  * Docker container (Credit: @Komish)


  * Changed project name to `getmac`. This applies to the
  command line tool, GitHub, and the documentation.
  * Use proper Python 2-compatible print functions (Credit: @martmists)


  * Support for Python 2.5. It is not feasible to test, and potentially
  breaks some useful language features, such as `__future__`
  * Variables PORT and DEBUG from top-level package imports, since changing
  them would have no actual effect on execution. Instead, use `getmac.getmac.DEBUG`.


  * Added example videos demonstrating usage (Credit: @fortunate-man)
  * Added contribution guide
  * Added documentation on ReadTheDocs
  * Added a manpage




  * Full support for Windows Subsystem for Linux (WSL). This is working for
  all features, including default interface selection! The only edge case
  is lookup of remote host IP addresses that are actually local interfaces
  will not resolve to a MAC (which should be ff-ff-ff-ff-ff-ff).

  * Require `argparse` if Python version is 2.6 or older

  * Updated tox tests: added Jython and IronPython, removed 2.6




  * New methods for remote host MACs
      * Windows: `arp`
      * POSIX: `arpreq` package
  * New methods for interface MACs
      * Windows: `wmic nic`
  * DEBUG levels: DEBUG value is now an integer, and increasing it will
  increase the amount and verbosity of output. On the CLI, it can be
  configured by increasing the amount of characters for the debug argument,
  e.g. '-dd' for DEBUG level 2.
  * Jython support (Note: on Windows Jython currently only works with interfaces)
  * IronPython support


  * **Significant** performance improvement for remote hosts. Previously,
  the average for `get_mac_address(ip='10.0.0.100')` was 1.71 seconds.
  Now, the average is `12.7 miliseconds`, with the special case of a unpopulated
  arp table being only slightly higher. This was brought about by changes in
  how the arp table is populated. The original method was to use the
  host's `ping` command to send an ICMP packet to the host. This took time,
  which heavily delayed the ability to actually get an address. The solution
  is to instead simply send a empty UDP packet to a high port. The port
  this packet is sent to can be configured using the module variable `getmac.PORT`.
  * "Fixed" resolution of localhost/127.0.0.1 by hardcoding the response.
  This should resolve a lot of problematic edge cases. I'm ok with this
  for now since I don't know of a case when it isn't all zeroes.
  * Greatly increased the reliability of getting host and interface MACs on Windows
  * Improved debugging output
  * Tightened up the size of `getmac.py`
  * Various minor stability and performance improvements
  * Add LICENSE to PyPI package


  * Support for Python 3.2 and 3.3. The total downloads from PyPI with
  those versions in August was ~53k and ~407K, respectfully. The majority
  of those are likely from automated testing (e.g. TravisCI) and not
  actual users. Therefore, I've decided to drop support to simplify
  development, especially since before 3.4 the 3.x series was still
  very much a  "work in progress".


  * Added automated tests for Windows using Appveyor
  * Tox runner for tests
  * Added github.io page
  * Improved TravisCI testing




  * Attempt to use Python modules if they're installed. This is useful
  for larger projects that already have them installed as dependencies,
  as they provide a more reliable means of getting information.
      * `psutil`: Interface MACs on all platforms
      * `scapy`: Interface MACs and Remote MACs on all platforms
      * `netifaces`: Interface MACs on Non-Windows platforms
  * New methods for remote MACs
      * POSIX: `ip neighbor show`, Abuse of `uuid._arp_getnode()`
  * New methods for Interface MACs
      * POSIX: `lanscan -ai` (HP-UX)


  * Certain critical failures that should never happen will now warn
  instead of failing silently.
  * Added a sanity check to the `ip6` argument (IPv6 addresses)
  * Improved performance in some areas
  * Improved debugging output


  * Major Bugfix: search of `proc/net/arp` would return shorter addresses in the
  same subnet if they came earlier in the sequence. Example: a search for
  `192.168.16.2` on Linux would instead return the MAC address of
  `192.168.16.254` with no errors or warning whatsoever.
  * Significantly improved default interface detection. Default
  interfaces are now properly detected on Linux and most other
  POSIX platforms with `ip` or `route` commands available, or the
  `netifaces` Python module.


  * Makefile
  * Vagrantfile to spin up testing VMs for various platforms using [Vagrant](https://www.vagrantup.com/docs/)
  * Added more samples of command output on platforms (Ubuntu 18.04 LTS)




  * Fixed identification of remote host on OSX
  * Resolved hangs and noticeable lag that occurred when "network_request"
  was True (the default)




  * Remote host for Python 3 on Windows




  * Short versions of CLI arguments (e.g. "-i" for "--interface")


  * Improved usage of "ping" across platforms and IP versions
  * Various minor tweaks for performance
  * Improved Windows detection


  * Use of ping command with hostname


  * Improvements to internal code



  Nothing changed. PyPI just won't let me push changes without a new version.




  * Checks for default interface on Linux systems
  * New methods of hunting for addresses on Windows, Mac OS X, and Linux


  * CLI will output nothing if it failed, instead of "None"
  * CLI will return with 1 on failure, 0 on success
  * No CLI arguments now implies the default host network interface
  * Added an argumnent for debugging: `--debug`
  * Removed `-d` option from `--no-network-requests`


  * Interfaces on Windows and Linux (including Bash for Windows)
  * Many bugs


  * Support for Python 2.6 on the CLI


  * Overhaul of internals




  * Addition of a terminal command: `get-mac`
  * Ability to run as a module from the command line: `python -m getmac`


  * `arp_request` argument was renamed to `network_request`
  * Updated docstring
  * Slight reduction in the size of getmac.py


  * Overhauled the README
  * Moved tests into their own folder
  * Added Python 3.7 to list of supported snakes



  * Python 2.6 compatibility



  * Fixed some addresses returning without colons
  * Added more rigorous checks on addresses before returning them



  * Remove print statements and other debugging output



  * Initial pre-alpha


pkgId: 310c9a634b516fcf449b2b04afc114a4336be30b25f0449d0e2cfb3307402da0
name: python-getmac
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Get MAC addresses of remote hosts and local interfaces
url: https://github.com/GhostofGoes/getmac
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-404633c5-515a-4067-beaa-d65dfba120ac
location_href: 00007106-python-getmac/python-getmac-0.9.3-1.src.rpm
checksum_type: sha256
description:
  [![Latest version on PyPI](https://badge.fury.io/py/getmac.svg)](https://pypi.org/project/getmac/)
  [![Coverage Status](https://coveralls.io/repos/github/GhostofGoes/getmac/badge.svg?branch=main)](https://coveralls.io/github/GhostofGoes/getmac?branch=main)
  [![GitHub Actions Pipeline Status](https://github.com/ghostofgoes/getmac/actions/workflows/ci.yml/badge.svg)](https://github.com/GhostofGoes/getmac/actions)
  [![Weekly PyPI downloads](https://pepy.tech/badge/getmac/week)](https://pepy.tech/project/getmac)
  [![PyPI downloads](https://pepy.tech/badge/getmac)](https://pepy.tech/project/getmac)
  [![PyPI downloadss of the old name](https://pepy.tech/badge/get-mac)](https://pepy.tech/project/get-mac)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  Pure-Python package to get the MAC address of network interfaces and hosts on the local network.

  It provides a platform-independent interface to get the MAC addresses of:

  - System network interfaces (by interface name)
  - Remote hosts on the local network (by IPv4/IPv6 address or hostname)

  It provides one function: `get_mac_address()`

  [![asciicast](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus.png)](https://asciinema.org/a/rk6dUACUcZY18taCuIBE5Ssus)

  [![asciicast](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv.png)](https://asciinema.org/a/n3insrxfyECch6wxtJEl3LHfv)



  If you only need the addresses of network interfaces, have a limited set of platforms to support, and are able to handle C-extension modules, then you should instead check out the excellent [netifaces](https://pypi.org/project/netifaces/) package by Alastair Houghton ([@al45tair](https://github.com/al45tair)). It's significantly faster (thanks to it being C-code) and has been around a long time and seen widespread usage. However, unfortunately it is no longer maintained as of [May 2021](https://github.com/al45tair/netifaces/commit/ec55b59e27542776f55e0f9e3213a75bf8e0f367), so it may not be a great choice for new projects. Another great option that fits these requirements is the well-known and battle-hardened [psutil](https://github.com/giampaolo/psutil) package by Giampaolo Rodola.

  If the only system you need to run on is Linux, you can run as root, and C-extensions modules are fine, then you should instead check out the [arpreq](https://pypi.org/project/arpreq/) package by Sebastian Schrader. In some cases it can be significantly faster.

  If you want to use `psutil`, `scapy`, or `netifaces`, I have examples of how to do so in a [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  Stable release from PyPI

  ```bash
  pip install getmac
  ```

  Latest development version

  ```bash
  pip install https://github.com/ghostofgoes/getmac/archive/main.tar.gz
  ```


  ```python
  from getmac import get_mac_address
  eth_mac = get_mac_address(interface="eth0")
  win_mac = get_mac_address(interface="Ethernet 3")
  ip_mac = get_mac_address(ip="192.168.0.1")
  ip6_mac = get_mac_address(ip6="::1")
  host_mac = get_mac_address(hostname="localhost")
  updated_mac = get_mac_address(ip="10.0.0.1", network_request=True)


  from getmac import getmac
  getmac.DEBUG = 2  # DEBUG level 2
  print(getmac.get_mac_address(interface="Ethernet 3"))


  from getmac import getmac
  getmac.PORT = 44444  # Default is 55555
  print(getmac.get_mac_address(ip="192.168.0.1", network_request=True))
  ```


  **Python 2 users**: use `getmac2` or `python -m getmac` instead of `getmac`.
  ```bash
  getmac --help
  getmac --version


  getmac


  python3 -m getmac


  getmac --interface ens33
  getmac --ip 192.168.0.1
  getmac --ip6 ::1
  getmac --hostname home.router


  python -m getmac -i 'Ethernet 4'
  python -m getmac -4 192.168.0.1
  python -m getmac -6 ::1
  python -m getmac -n home.router




  getmac --no-network-request --ip 192.168.0.1
  python -m getmac --no-network-request -n home.router


  getmac --verbose


  getmac -v --debug
  python -m getmac -v -d -i enp11s4
  python -m getmac -v -dd -n home.router


  getmac --ip 192.168.0.1 --override-port 9001





  getmac -i eth0 --override-platform linux
  getmac --ip 192.168.0.1 --override-platform windows


  getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost
  ```


  - `interface`: Name of a network interface on the system
  - `ip`: IPv4 address of a remote host
  - `ip6`: IPv6 address of a remote host
  - `hostname`: Hostname of a remote host
  - `network_request`: If an network request should be made to update and populate the ARP/NDP table of remote hosts used to lookup MACs in most circumstances. Disable this if you want to just use what's already in the table, or if you have requirements to prevent network traffic. The network request is a empty UDP packet sent to a high port, `55555` by default. This can be changed by setting `getmac.PORT` to the desired integer value. Additionally, on Windows, this will send a UDP packet to `1.1.1.1:53` to attempt to determine the default interface (Note: the IP is [CloudFlare's DNS server](https://www.cloudflare.com/learning/dns/what-is-1.1.1.1/)).


  - `logging.getLogger("getmac")`: Runtime messages and errors are recorded to the `getmac` logger using Python's [logging](https://docs.python.org/3/library/logging.html) module. They can be configured by using [logging.basicConfig()](https://docs.python.org/3/library/logging.html#logging.basicConfig) or adding handlers to the `"getmac"` logger.
  - `getmac.getmac.DEBUG`: integer value that controls debugging output. The higher the value, the more output you get.
  - `getmac.getmac.PORT`: UDP port used to populate the ARP/NDP table (see the documentation of the `network_request` argument in `get_mac_address()` for details)
  - `getmac.getmac.OVERRIDE_PLATFORM`: Override the platform detection with the given value (e.g. `"linux"`, `"windows"`, `"freebsd"`, etc.'). Any values returned by `platform.system()` are valid.
  - `getmac.getmac.FORCE_METHOD`: Force a specific method to be used, e.g. 'IpNeighborShow'. This will be used regardless of it's method type or platform compatibility, and `Method.test()` will NOT be checked! The list of available methods is in `getmac.getmac.METHODS`.


  - Pure-Python (no compiled C-extensions required!)
  - Python 2.7 and 3.4+
  - Lightweight, with no dependencies and a small package size
  - Can be dropped into a project as a standalone .py file
  - Supports most interpreters: CPython, pypy, pypy3, IronPython 2.7, and Jython 2.7
  - Provides a simple command line tool (when installed as a package)
  - MIT licensed!


  If you are running a old Python (2.6/3.3 and older) or interpreter, then you can install an older version of `getmac` that supported that version. The wheels are available in the [GitHub releases](https://github.com/GhostofGoes/getmac/releases), or from PyPI with a current version of `pip` and some special arguments.

  - Python 2.5: get-mac 0.5.0
  - Python 2.6: getmac 0.6.0
  - Python 3.2: get-mac 0.3.0
  - Python 3.3: get-mac 0.3.0

  NOTE: these versions do not have many of the performance improvements, platform support, and bug fixes that came with later releases. They generally work, just not as well. However, if you're using such an old Python, you probably don't care about all that :)


  - Python 3.10 and 3.11 should work, but are not automatically tested at the moment due to having to support 2.7
  - If none of the arguments are selected, the default network interface for the system will be used. If the default network interface cannot be determined, then it will attempt to fallback to typical defaults for the platform (`Ethernet` on Windows, `em0` on BSD, `en0` on OSX/Darwin, and `eth0` otherwise). If that fails, then it will fallback to `lo` on POSIX systems.
  - "Remote hosts" refer to hosts in your local layer 2 network, also commonly referred to as a "broadcast domain", "LAN", or "VLAN". As far as I know, there is not a reliable method to get a MAC address for a remote host external to the LAN. If you know any methods otherwise, please [open a GitHub issue](https://github.com/GhostofGoes/getmac/issues) or shoot me an email, I'd love to be wrong about this.
  - The first four arguments are mutually exclusive. `network_request` does not have any functionality when the `interface` argument is specified, and can be safely set if using in a script.
  - The physical transport is assumed to be Ethernet (802.3). Others, such as Wi-Fi (802.11), are currently not tested or considered. I plan to address this in the future, and am definitely open to pull requests or issues related to this, including error reports.
  - **Exceptions will be handled silently and returned as a None.** If you run into problems, you can set `DEBUG` to true and get more     information about what's happening. If you're still having issues, please create an [issue on GitHub](https://github.com/GhostofGoes/getmac/issues) and include the output with `DEBUG` enabled.


  - Windows
      - Commands: `getmac.exe`, `ipconfig.exe`, `arp.exe`, `wmic.exe`
      - Libraries: `uuid`, `ctypes`, `socket`
  - Linux/Unix
      - Commands: `arp`, `ip`, `ifconfig`, `netstat`, `ip link`, `lanscan`
      - Libraries: `uuid`, `fcntl`, `socket`
      - Files: `/sys/class/net/{iface}/address`, `/proc/net/arp`
      - Default interfaces: `/proc/net/route`, `route`, `ip route list`
  - Mac OSX (Darwin)
      - `networksetup`
      - Same commands as Linux
  - WSL
      - Windows commands are used for remote hosts
      - Unix commands are used for interfaces
  - OpenBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `route`
  - FreeBSD
      - Commands: `ifconfig`, `arp`
      - Default interfaces: `netstat`
  - Android
      - Commands: `ip link`


  All or almost all features should work on "supported" platforms. While other versions of the same family or distro may work, they are untested and may have bugs or missing features.

  - Windows
      - Desktop: 7, 8, 8.1, 10, 11 (thanks @StevenLooman for testing Windows 11!)
      - Server: TBD
      - Partially supported (untested): 2000, XP, Vista
  - Linux distros
      - CentOS/RHEL 6+
      - Ubuntu 16.04+ (15.10 and older should work, but are untested)
      - Fedora (24+)
  - Mac OSX (Darwin)
      - The latest two versions probably (TBD)
  - Android (6+)
  - Windows Subsystem for Linux (WSL)
  - FreeBSD (11+)
  - OpenBSD
  - Docker


  Add `-v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp` to access arp table of host inside container in bridge network mode.

  ```bash
  docker build -f packaging/Dockerfile -t getmac .
  docker run -it getmac:latest --help
  docker run -it getmac:latest --version
  docker run -it getmac:latest -n localhost
  docker run --rm -it -v /proc/1/net/arp:/host/arp -e ARP_PATH=/host/arp getmac:latest -n 192.168.0.1
  ```


  - Depending on the platform, there could be a performance detriment, due to heavy usage of regular expressions.
  - Platform test coverage is imperfect. If you're having issues, then you might be using a platform I haven't been able to test. Keep calm, open a GitHub issue, and I'd be more than happy to help.


  - Linux, WSL: Getting the mac of a local interface IP does not currently work (`getmac --ip 10.0.0.4` will fail if `10.0.0.4` is the IP address of a local interface). This issue may be present on other POSIX systems as well.
  - Hostnames for IPv6 devices are not yet supported.
  - Windows: the "default" (used when no arguments set or specified) of selecting the default route interface only works effectively if `network_request` is enabled. If not, `Ethernet` is used as the default.
  - IPv6 support is good but lags behind IPv4 in some places and isn't as well-tested across the supported platform set.


  The Python standard library has a robust set of networking functionality, such as `urllib`, `ipaddress`, `ftplib`, `telnetlib`, `ssl`, and more. Imagine my surprise, then, when I discovered there was not a way to get a seemingly simple piece of information: a MAC address. This package was born out of a need to get the MAC address of hosts on the network without needing admin permissions, and a cross-platform way get the addresses of local interfaces.

  In Fall 2018 the package name changed to `getmac` from `get-mac`. This affected the package name, the CLI script, and some of the documentation. There were no changes to the core library code. While both package names will updated on PyPI, the use of `getmac` is preferred.

  In Summer 2020, the code was significantly refactored, moving to a class-based structure and significantly improving performance and accuracy. See [docs/rewrite.md](docs/rewrite.md) for details.


  Contributors are more than welcome! See the [contribution guide](CONTRIBUTING.md) to get started, and checkout the [todo list](TODO.md) for a full list of tasks and bugs.

  Before submitting a PR, please make sure you've completed the [pull request checklist](CONTRIBUTING.md#Code_requirements)!

  The [Python Discord server](https://discord.gg/python) is a good place to ask questions or discuss the project (Handle: @KnownError#0001).


  - Christopher Goes (@ghostofgoes) - Author and maintainer
  - Calvin Tran (@cyberhobbes) - Windows interface detection improvements
  - Daniel Flanagan (@FlantasticDan) - Code cleanup
  - @emadmahdi - Android fixes
  - Izra Faturrahman (@Frizz925) - Unit tests using the platform samples
  - Jose Gonzalez (@Komish) - Docker container and Docker testing
  - @fortunate-man - Awesome usage videos
  - @martmists - legacy Python compatibility improvements
  - @hargoniX - scripts and specfiles for RPM packaging
  - Ville Skyttä (@scop) - arping lookup support
  - Tomasz Duda (@tomaszduda23) - support for docker in network bridge mode
  - Steven Looman (@StevenLooman) - Windows 11 testing


  Many of the methods used to acquire an address and the core logic framework are attributed to the CPython project's UUID implementation.

  - https://github.com/python/cpython/blob/master/Lib/uuid.py
  - https://github.com/python/cpython/blob/2.7/Lib/uuid.py


  - [_unix_fcntl_by_interface](https://stackoverflow.com/a/4789267/2214380)
  - [_windows_get_remote_mac_ctypes](goo.gl/ymhZ9p)
  - [String joining](https://stackoverflow.com/a/3258612/2214380)


  MIT. Feel free to copy, modify, and use to your heart's content. Enjoy :)




  **NOTE**: if any changes significantly impact your project or use case, please open an issue on [GitHub](https://github.com/GhostofGoes/getmac/issues) or email me (see git commit author info for address).

  **Announcement**: Compatibility with Python versions older than 3.7 (2.7, 3.4, 3.5, and 3.6) is deprecated and will be removed in getmac 1.0.0. If you are stuck on an unsupported Python, consider loosely pinning the version of this package in your dependency list, e.g. `getmac<1.0.0` or `getmac~=0.9.0`.




  * Fix `ArpFile` method being used for IPv6 (`/proc/net/arp`, and ARP in general, is IPv4-only)




  * Fix flakiness with UuidArpGetNode on MacOS by making it the last method attempted (Fixes issue [#82](https://github.com/GhostofGoes/getmac/issues/82))




  * Deprecate Python 3.6 support (support will be removed in getmac 1.0.0)


  * Fix links in README and PyPI metadata to use "main" instead of "master" for primary branch
  * Remove "Documentation" link from PyPI (the ReadTheDocs site is broken and hasn't been updated since 0.5.0)
  * Add PyPI classifiers for 3.10 and 3.11
  * Some cleanup of CHANGELOG



  This release is a *complete rewrite of getmac from the ground up*. The public API of `getmac` is **unchanged** as part of this rewrite. `get_mac_address()` is still the primary way of getting a MAC address, it's just the "under the hood" internals that have changed completely.

   It's passing tests and seems to be operable. However, with a change this large there are inevitably issues that the tests or I don't catch, so I'm doing a series of pre-releases until I'm 99% confident in it's stability. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes.

  The new system has a number of benefits
  - Reduction of false-positives and false-negatives by improving method selection accuracy (platform, validity, etc.)
  - *Significantly* faster overall
  - "Misses" have the same performance as "Hits"
  - Easier to test, since each method can be tested directly via it's class
  - Easier to type annotate and analyze with mypy
  - Easier to read, improving reviewability and ease of contributing for newcomers
  - Extensible! Custom methods can be defined and added at runtime (which is perfect if you have some particular edge case but aren't able to open-source it).


  * Fully support Python 3.9 (automated tests in CI)
  * Tentatively support Python 3.10 and 3.11 (unable to test due to the need to be able to still test 2.7)
  * Added default interface detection for MacOS (command: `route get default`)
  * Added initial support for Solaris/SunOS. There were a few existing methods that worked as-is, so just added indicators that those methods support `sunos` (Which applies to any system where `platform.system() == SunOS`).
  * `arping` (POSIX) or `SendARP` (Windows) will now *always* be used instead of sending a UDP packet when looking for the MAC of a IPv4 host, if they're available and operable (otherwise, UDP + ARP table check will be used like before).
  * The amount of time taken to get a result (in seconds) will now be recorded and logged if debugging is enabled (`DEBUG>=1` or `-d`)
  * Added command line argument to override the UDP port for network requests: `--override-port` (this was already possible in Python via `getmac.getmac.PORT`, but wasn't configurable via the CLI. Now it is!).
  * Added ability to override the detected platform via `--override-platform` argument (CLI) or `getmac.getmac.OVERRIDE_PLATFORM` variable (Python). This will force methods for that platform to be used, regardless of the actual platform. Here's an example forcing `linux` to be used as the platform: `getmac -i eth0 --override-platform linux`. In version 1.0.0, this feature will added as an argument to `get_mac_address()`.
  * Added ability to force a specific method to be used via `--force-method` argument (CLI) or `getmac.getmac.FORCE_METHOD` variable (Python). This is useful for troubleshooting issues, general debugging, and testing changes. Example: `getmac -v -dddd --ip 192.168.0.1 --force-method ctypeshost`


  * **Complete rewrite of `getmac` from the ground up. Refer to `docs/rewrite.md` for a in-depth explanation of the rewrite changes**
  * Fixed a failure to look up a hostname now returns `None`, as expected, instead of raising an exception (`socket.gaierror`).
  * Fixed numerous false-negative and false-positive bugs
  * Improved overall performance
  * Performance for cases where no MAC is found is now the same as cases where a MAC is found (speed of "misses" now equals that of "hits")
  * Improved the reliability and performance of many methods
  * Fixed `netstat` on older Linux distros (such as Ubuntu 12.04)
  * Overhauled `ifconfig` parsing. It should now be far more reliable and accurate across all platforms.
  * Improved Android support. Note that newer devices are locked down and the amount of information that's obtainable by an unprivileged process is quite limited (Android 7/9 and newer, not sure exactly when they changed this, I'm not an Android guy). That being said, the normal Linux methods should work fine, provided you have the proper permissions (usually, `root`).
  * Fixed bug with `/proc/net/route` parsing (this affected Android and potentially other platforms)
  * Improve default interface detection for FreeBSD (command: `route get default`)


  * Removed man pages from distribution (`getmac.1`/`getmac2.1`). They were severely out of date and unused. May re-add at a later date.


  * Migrate CI to GitHub Actions, remove TravisCI and Appveyor
  * Add flake8 plugins: `flake8-pytest-style` and `flake8-annotations`
  * Add additional samples and tests for WSL1 (with the Ubuntu 18.04 distro)
  * Add additional samples for Windows 10
  * Add additional samples for MacOS
  * Add samples and tests for Ubuntu 12.04
  * Add samples for NetBSD 8 (support coming in a future release)
  * Add samples for Solaris 10 (support TBD)
  * Add samples for several versions of Android
  * Add new tests
  * Improve existing tests
  * Consolidate everything related to RPM packaging to `packaging/rpm/`. This stuff hasn't been updated since 0.6.0, may remove in the future and leave distro packaging to distro maintainers.





  * Added support for Thomas Habets' version of `arping` in addition to the existing iputils one (contributed by Ville Skyttä (@scop) in [#52](https://github.com/GhostofGoes/getmac/pull/52) and [#54](https://github.com/GhostofGoes/getmac/pull/54))
  * Added support for docker in network bridge mode (contributed by Tomasz Duda (@tomaszduda23) in [#57](https://github.com/GhostofGoes/getmac/pull/57))
  * Add CHANGELOG URL to PyPI metadata (contributed by Ville Skyttä (@scop) in [#58](https://github.com/GhostofGoes/getmac/pull/58))
  * Fixed code quality test suite errors (includes changes by Daniel Flanagan (@FlantasticDan) in [#67](https://github.com/GhostofGoes/getmac/pull/67))
  * Improved Android support (contributed by @emadmahdi in [#71](https://github.com/GhostofGoes/getmac/pull/71))
  * Minor code quality fixes (2 years of neglecting master branch)
  * Add [Code of Conduct](https://github.com/GhostofGoes/getmac/blob/main/CODE_OF_CONDUCT.md) for project contributors
  * Add [SECURITY.md](https://github.com/GhostofGoes/getmac/blob/main/SECURITY.md) for reporting security issues (e.g. vulnerabilities)
  * Deprecate Python 3.4 and 3.5
  * Issue deprecation message as a warning in addition to a log message





  * Added warning about Python 2 compatibility being dropped in 1.0.0
  * Officially support Python 3.8
  * Documented a known issue with looking up IP of a local interface on Linux/WSL (See the "Known Issues" section in the README)
  * Added remote host lookup using `arping` as last resort


  * Standardized formatting on [Black](https://github.com/psf/black)
  * Lint additions: `vulture`, several Flake8 plugins
  * Pinned test dependencies (pytest 5 dropped Python 2 support)
  * Various quality-of-life improvements for contributors/developers





  * Fixed sockets being opened and not closed when `ip` or `ip6` were used,
  which could lead to a `ResourceWarning` (GH-42)





  * OpenBSD support
  * FreeBSD support
  * Python logging is now used instead of `print` (logger: `getmac`)
  * Include tests in the source distribution
  * (CLI) Added aliases for `--no-network-requests`: `-N` and `--no-net`
  * (CLI) New argument: `-v`/`--verbose`


  * Errors are now logged instead of raising a `RuntimeWarning`
  * Improved Ubuntu support
  * Performance improvements


  * Significant increase in overall test coverage
  * Fixed and migrated the sample tests to `pytest`
  * Added tests for the CLI





  * Type annotations (PEP 484)


  * Dropped support for Python 2.6
  * Removed the usage of third-party packages (`netifaces`, `psutil`, `scapy`, and `arpreq`).
  This should improve the performance of lookups of non-existent interfaces
  or hosts, since this feature was punishing that path without providing much value.
  If you want to use these packages directly, I have a guide on how to do so on a
  [GitHub Gist](https://gist.github.com/GhostofGoes/0a8e82930e75afcefbd879a825ba4c26).


  * Significantly improved the performance of the common cases on Linux
  for interfaces and remote hosts
  * Improved POSIX interface performance. Commands specific to OSX
  will be run only on that platform, and vice-versa.
  * Significantly improved the speed and accuracy of determining
  the default interface on Linux
  * Python 2 will install an executor named getmac2 and Python 3 an
  executor named getmac so they do not conflict when both RPMs are
  installed on the same system (Credit: @hargoniX)
  * The `warnings` module will only be imported if a error/warning
  occurs (improve compatibility with some freezers, notably PyInstaller)
  * Improved system platform detection
  * Various other minor performance improvements


  * Added unit tests for the samples (Credit: @Frizz925)
  * Scripts for building RPMs in the /scripts directory (Credit: @hargoniX)
  * Improved code quality and health checks
  * Include the CHANGELOG on the PyPI project page
  * Using `pytest` for all tests now instead of `unittest`


  * Added instructions on how to build a Debian package (Credit: @kofrezo)




  * Windows default interface detection if `network_request` is enabled (Credit: @cyberhobbes)
  * Docker container (Credit: @Komish)


  * Changed project name to `getmac`. This applies to the
  command line tool, GitHub, and the documentation.
  * Use proper Python 2-compatible print functions (Credit: @martmists)


  * Support for Python 2.5. It is not feasible to test, and potentially
  breaks some useful language features, such as `__future__`
  * Variables PORT and DEBUG from top-level package imports, since changing
  them would have no actual effect on execution. Instead, use `getmac.getmac.DEBUG`.


  * Added example videos demonstrating usage (Credit: @fortunate-man)
  * Added contribution guide
  * Added documentation on ReadTheDocs
  * Added a manpage




  * Full support for Windows Subsystem for Linux (WSL). This is working for
  all features, including default interface selection! The only edge case
  is lookup of remote host IP addresses that are actually local interfaces
  will not resolve to a MAC (which should be ff-ff-ff-ff-ff-ff).

  * Require `argparse` if Python version is 2.6 or older

  * Updated tox tests: added Jython and IronPython, removed 2.6




  * New methods for remote host MACs
      * Windows: `arp`
      * POSIX: `arpreq` package
  * New methods for interface MACs
      * Windows: `wmic nic`
  * DEBUG levels: DEBUG value is now an integer, and increasing it will
  increase the amount and verbosity of output. On the CLI, it can be
  configured by increasing the amount of characters for the debug argument,
  e.g. '-dd' for DEBUG level 2.
  * Jython support (Note: on Windows Jython currently only works with interfaces)
  * IronPython support


  * **Significant** performance improvement for remote hosts. Previously,
  the average for `get_mac_address(ip='10.0.0.100')` was 1.71 seconds.
  Now, the average is `12.7 miliseconds`, with the special case of a unpopulated
  arp table being only slightly higher. This was brought about by changes in
  how the arp table is populated. The original method was to use the
  host's `ping` command to send an ICMP packet to the host. This took time,
  which heavily delayed the ability to actually get an address. The solution
  is to instead simply send a empty UDP packet to a high port. The port
  this packet is sent to can be configured using the module variable `getmac.PORT`.
  * "Fixed" resolution of localhost/127.0.0.1 by hardcoding the response.
  This should resolve a lot of problematic edge cases. I'm ok with this
  for now since I don't know of a case when it isn't all zeroes.
  * Greatly increased the reliability of getting host and interface MACs on Windows
  * Improved debugging output
  * Tightened up the size of `getmac.py`
  * Various minor stability and performance improvements
  * Add LICENSE to PyPI package


  * Support for Python 3.2 and 3.3. The total downloads from PyPI with
  those versions in August was ~53k and ~407K, respectfully. The majority
  of those are likely from automated testing (e.g. TravisCI) and not
  actual users. Therefore, I've decided to drop support to simplify
  development, especially since before 3.4 the 3.x series was still
  very much a  "work in progress".


  * Added automated tests for Windows using Appveyor
  * Tox runner for tests
  * Added github.io page
  * Improved TravisCI testing




  * Attempt to use Python modules if they're installed. This is useful
  for larger projects that already have them installed as dependencies,
  as they provide a more reliable means of getting information.
      * `psutil`: Interface MACs on all platforms
      * `scapy`: Interface MACs and Remote MACs on all platforms
      * `netifaces`: Interface MACs on Non-Windows platforms
  * New methods for remote MACs
      * POSIX: `ip neighbor show`, Abuse of `uuid._arp_getnode()`
  * New methods for Interface MACs
      * POSIX: `lanscan -ai` (HP-UX)


  * Certain critical failures that should never happen will now warn
  instead of failing silently.
  * Added a sanity check to the `ip6` argument (IPv6 addresses)
  * Improved performance in some areas
  * Improved debugging output


  * Major Bugfix: search of `proc/net/arp` would return shorter addresses in the
  same subnet if they came earlier in the sequence. Example: a search for
  `192.168.16.2` on Linux would instead return the MAC address of
  `192.168.16.254` with no errors or warning whatsoever.
  * Significantly improved default interface detection. Default
  interfaces are now properly detected on Linux and most other
  POSIX platforms with `ip` or `route` commands available, or the
  `netifaces` Python module.


  * Makefile
  * Vagrantfile to spin up testing VMs for various platforms using [Vagrant](https://www.vagrantup.com/docs/)
  * Added more samples of command output on platforms (Ubuntu 18.04 LTS)




  * Fixed identification of remote host on OSX
  * Resolved hangs and noticeable lag that occurred when "network_request"
  was True (the default)




  * Remote host for Python 3 on Windows




  * Short versions of CLI arguments (e.g. "-i" for "--interface")


  * Improved usage of "ping" across platforms and IP versions
  * Various minor tweaks for performance
  * Improved Windows detection


  * Use of ping command with hostname


  * Improvements to internal code



  Nothing changed. PyPI just won't let me push changes without a new version.




  * Checks for default interface on Linux systems
  * New methods of hunting for addresses on Windows, Mac OS X, and Linux


  * CLI will output nothing if it failed, instead of "None"
  * CLI will return with 1 on failure, 0 on success
  * No CLI arguments now implies the default host network interface
  * Added an argumnent for debugging: `--debug`
  * Removed `-d` option from `--no-network-requests`


  * Interfaces on Windows and Linux (including Bash for Windows)
  * Many bugs


  * Support for Python 2.6 on the CLI


  * Overhaul of internals




  * Addition of a terminal command: `get-mac`
  * Ability to run as a module from the command line: `python -m getmac`


  * `arp_request` argument was renamed to `network_request`
  * Updated docstring
  * Slight reduction in the size of getmac.py


  * Overhauled the README
  * Moved tests into their own folder
  * Added Python 3.7 to list of supported snakes



  * Python 2.6 compatibility



  * Fixed some addresses returning without colons
  * Added more rigorous checks on addresses before returning them



  * Remove print statements and other debugging output



  * Initial pre-alpha


pkgId: f823eb11ad1dd13ac91364ca1ebc94dda01527b75c5a92971080da712afa8c84
name: python-gevent-debuginfo
arch: aarch64
version: 22.10.2
epoch: 0
release: 1
summary: Debug information for package python-gevent
url: http://www.gevent.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4bd4e930-b4c3-4ac9-b53e-53110ced9c14
rpm_sourcerpm: python-gevent-22.10.2-1.src.rpm
location_href: 00009114-python-gevent/python-gevent-debuginfo-22.10.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-gevent.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: acc78d385c0163fcd65990516ed447788f393382e58a5edb3770d8aafb5d3dfc
name: python-gevent-debugsource
arch: aarch64
version: 22.10.2
epoch: 0
release: 1
summary: Debug sources for package python-gevent
url: http://www.gevent.org/
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-4bd4e930-b4c3-4ac9-b53e-53110ced9c14
rpm_sourcerpm: python-gevent-22.10.2-1.src.rpm
location_href: 00009114-python-gevent/python-gevent-debugsource-22.10.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-gevent.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 94840ec6fceead0ea78c4c0883e01302f5daa01d2c0cdfa405c5b614ffa96dc9
name: python-gevent-websocket
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Websocket handler for the gevent pywsgi server, a Python network library
url: https://www.gitlab.com/noppo/gevent-websocket
rpm_license: Copyright 2011-2017 Jeffrey Gelens <jeffrey@noppo.pro>
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-f5710f71-ce11-4e32-89c7-695decd66fe6
location_href: 00010304-python-gevent-websocket/python-gevent-websocket-0.10.1-1.src.rpm
checksum_type: sha256
description:
          `gevent-websocket`_ is a WebSocket library for the gevent_ networking library.
          Features include:
          - Integration on both socket level or using an abstract interface.
          - RPC and PubSub framework using `WAMP`_ (WebSocket Application
            Messaging Protocol).
          - Easily extendible using a simple WebSocket protocol plugin API
              from geventwebsocket import WebSocketServer, WebSocketApplication, Resource
              class EchoApplication(WebSocketApplication):
                  def on_open(self):
                      print "Connection opened"
                  def on_message(self, message):
                      self.ws.send(message)
                  def on_close(self, reason):
                      print reason
              WebSocketServer(
                  ('', 8000),
                  Resource({'/': EchoApplication})
              ).serve_forever()
          or a low level implementation::
              from gevent import pywsgi
              from geventwebsocket.handler import WebSocketHandler
              def websocket_app(environ, start_response):
                  if environ["PATH_INFO"] == '/echo':
                      ws = environ["wsgi.websocket"]
                      message = ws.receive()
                      ws.send(message)
              server = pywsgi.WSGIServer(("", 8000), websocket_app,
                  handler_class=WebSocketHandler)
              server.serve_forever()
          More examples can be found in the ``examples`` directory. Hopefully more
          documentation will be available soon.


pkgId: 6045c2851072a67dc6493832b8747641507d3207f00ea00ac2ba0cbb6ccff66f
name: python-geventhttpclient
arch: src
version: 2.0.9
epoch: 0
release: 1
summary: http client library for gevent
url: http://github.com/gwik/geventhttpclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-ba510c57-aff1-4f8b-9000-0e41b760cf52
location_href: 00009958-python-geventhttpclient/python-geventhttpclient-2.0.9-1.src.rpm
checksum_type: sha256
description:
  A high performance, concurrent HTTP client library for python using gevent.

  gevent.httplib support was removed in gevent 1.0, geventhttpclient now
  provides that missing functionality.

  geventhttpclient uses a fast http parser, written in C, originating from
  nginx, extracted and modified by Joyent.

  geventhttpclient has been specifically designed for high concurrency,
  streaming and support HTTP 1.1 persistent connections. More generally it is
  designed for efficiently pulling from REST APIs and streaming APIs
  like Twitter's.

  Safe SSL support is provided by default. geventhttpclient depends on
  the certifi CA Bundle. This is the same CA Bundle which ships with the
  Requests codebase, and is derived from Mozilla Firefox's canonical set.

  As of 1.5, only Python 3.6+ is fully supported (with prebuilt wheels),
  but Python 2.7 and 3.5 *should* work too.

  Use of SSL/TLS with python 2.7.9 is not recommended and may be broken.


pkgId: bcd0a793490879d665a4f2ec26287332aa0198c9eeb06e2a8ef92a870630a504
name: python-geventhttpclient-debuginfo
arch: aarch64
version: 2.0.9
epoch: 0
release: 1
summary: Debug information for package python-geventhttpclient
url: http://github.com/gwik/geventhttpclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ba510c57-aff1-4f8b-9000-0e41b760cf52
rpm_sourcerpm: python-geventhttpclient-2.0.9-1.src.rpm
location_href: 00009958-python-geventhttpclient/python-geventhttpclient-debuginfo-2.0.9-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-geventhttpclient.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: fa4bf38024f19d54f30e38ecd1d459e2d3fa67c7b2a11af8f4bf459fa33cfb20
name: python-geventhttpclient-debugsource
arch: aarch64
version: 2.0.9
epoch: 0
release: 1
summary: Debug sources for package python-geventhttpclient
url: http://github.com/gwik/geventhttpclient
rpm_license: MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-ba510c57-aff1-4f8b-9000-0e41b760cf52
rpm_sourcerpm: python-geventhttpclient-2.0.9-1.src.rpm
location_href: 00009958-python-geventhttpclient/python-geventhttpclient-debugsource-2.0.9-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-geventhttpclient.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 53f94c312472043e9df020a071b40485efa53529b7677a7c9840f6893d0702d5
name: python-geventhttpclient-wheels
arch: src
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Pre-built wheels for geventhttpclient
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
location_href: 00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  A high performance, concurrent HTTP client library for python using gevent.

  gevent.httplib support was removed in gevent 1.0, geventhttpclient now
  provides that missing functionality.

  geventhttpclient uses a fast http parser, written in C, originating from
  nginx, extracted and modified by Joyent.

  geventhttpclient has been specifically designed for high concurrency,
  streaming and support HTTP 1.1 persistent connections. More generally it is
  designed for efficiently pulling from REST APIs and streaming APIs
  like Twitter's.

  Safe SSL support is provided by default. geventhttpclient depends on
  the certifi CA Bundle. This is the same CA Bundle which ships with the
  Requests codebase, and is derived from Mozilla Firefox's canonical set.

  Python 2.7 and 3.4+ are supported.
  Python 2.6 is no longer supported.

  Use of SSL/TLS with python 2.7.9 is not recommended and may be broken.


pkgId: 41ef90067713333f7a84df9e1c06c2fb39e2f796de5384e28aecf816720f79b1
name: python-geventhttpclient-wheels-debuginfo
arch: aarch64
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Debug information for package python-geventhttpclient-wheels
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
rpm_sourcerpm: python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-geventhttpclient-wheels.
  Debug information is useful when developing applications that use this
  package or when debugging this package.

location_href:
  00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-debuginfo-1.3.1.dev3-1.aarch64.rpm


pkgId: 9715284642c0ef72c9f22da79bf7f3492a03bc948a0b88955c3607f6c387b42d
name: python-geventhttpclient-wheels-debugsource
arch: aarch64
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Debug sources for package python-geventhttpclient-wheels
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Development/Debug
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
rpm_sourcerpm: python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-geventhttpclient-wheels.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.

location_href:
  00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-debugsource-1.3.1.dev3-1.aarch64.rpm


pkgId: a41d31d878e224238ed9e34b8bb36b343021ce7047792f1210131bc41831d870
name: python-geventhttpclient-wheels-help
arch: aarch64
version: 1.3.1.dev3
epoch: 0
release: 1
summary: Development documents and examples for geventhttpclient-wheels
url: http://github.com/gwik/geventhttpclient
rpm_license: LICENSE-MIT
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-1c4a7792-6850-4438-afad-184228551adb
rpm_sourcerpm: python-geventhttpclient-wheels-1.3.1.dev3-1.src.rpm
checksum_type: sha256
description:
  A high performance, concurrent HTTP client library for python using gevent.

  gevent.httplib support was removed in gevent 1.0, geventhttpclient now
  provides that missing functionality.

  geventhttpclient uses a fast http parser, written in C, originating from
  nginx, extracted and modified by Joyent.

  geventhttpclient has been specifically designed for high concurrency,
  streaming and support HTTP 1.1 persistent connections. More generally it is
  designed for efficiently pulling from REST APIs and streaming APIs
  like Twitter's.

  Safe SSL support is provided by default. geventhttpclient depends on
  the certifi CA Bundle. This is the same CA Bundle which ships with the
  Requests codebase, and is derived from Mozilla Firefox's canonical set.

  Python 2.7 and 3.4+ are supported.
  Python 2.6 is no longer supported.

  Use of SSL/TLS with python 2.7.9 is not recommended and may be broken.

location_href:
  00011482-python-geventhttpclient-wheels/python-geventhttpclient-wheels-help-1.3.1.dev3-1.aarch64.rpm


pkgId: f3e27985e3110b96d3e3cc703286a9900e0e432a60f7b3d38bd113f236d17c4e
name: python-ggplot
arch: src
version: 0.11.5
epoch: 0
release: 1
summary: ggplot for python
url: https://github.com/yhat/ggplot/
rpm_license: BSD
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-8aa7fcc6-2a6a-416e-90d1-b66937324d46
location_href: 00011507-python-ggplot/python-ggplot-0.11.5-1.src.rpm
checksum_type: sha256
description:
  What is it?
  ~~~~~~~~~~~
  ``ggplot`` is a Python implementation of the grammar of graphics. It is
  not intended to be a feature-for-feature port of
  ```ggplot2 for R`` <https://github.com/hadley/ggplot2>`__--though there
  is much greatness in ``ggplot2``, the Python world could stand to
  benefit from it. So there **will be feature overlap**, but not
  neccessarily mimicry (after all, R is a little weird).
  You can do cool things like this:
      ggplot(diamonds, aes(x='price', color='clarity')) + \
          geom_density() + \
          scale_color_brewer(type='div', palette=7) + \
          facet_wrap('cut')
  Installation
  ~~~~~~~~~~~~
      $ pip install -U ggplot
      
      $ conda install -c conda-forge ggplot
      
      pip install git+https://github.com/yhat/ggplot.git
  Examples
  ~~~~~~~~
  Examples are the best way to learn. There is a Jupyter Notebook full of
  them. There are also notebooks that show how to do particular things
  with ggplot (i.e. `make a scatter
  plot <./docs/how-to/Making%20a%20Scatter%20Plot.ipynb>`__ or `make a
  histogram <./docs/how-to/Making%20a%20Scatter%20Plot.ipynb>`__).
  -  `docs <./docs>`__
  -  `gallery <./docs/Gallery.ipynb>`__
  -  `various examples <./examples.md>`__
  What happened to the old version that didn't work?
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  It's gone--the windows, the doors,
  `everything <https://www.youtube.com/watch?v=YuxCKv_0GZc>`__. Just
  kidding, `you can find it
  here <https://github.com/yhat/ggplot/tree/v0.6.6>`__, though I'm not
  sure why you'd want to look at it. The data grouping and manipulation
  bits were re-written (so they actually worked) with things like facets
  in mind.
  Contributing
  ~~~~~~~~~~~~
  Thanks to all of the ggplot
  `contributors <./contributors.md#contributors>`__! See
  *`contributing.md <./contributing.md>`__*.


pkgId: b43e6d6e6dc06b4d4fb5422ea7ab88cd55ddfef0e8066952869d0604fa1bc630
name: python-ghapi
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: A python client for the GitHub API
url: https://github.com/fastai/ghapi
rpm_license: Apache Software License 2.0
rpm_vendor: openEuler Copr - user mywaaagh_admin
rpm_group: Unspecified
rpm_buildhost: resalloc-37beb733-cfdc-490f-a839-0361834b0b33
location_href: 00010619-python-ghapi/python-ghapi-1.0.3-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) provides 100%
  always-updated coverage of the entire [GitHub
  API](https://docs.github.com/rest). Because we automatically convert the
  [OpenAPI
  spec](https://docs.github.com/rest/overview/openapi-description) to a
  Pythonic API, [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) is always
  up to date with the latest changes to GitHub APIs. Furthermore, because
  this is all done dynamically, the entire package is only 35kB in size!
  Using [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi), you can automate
  nearly anything that you can do through the GitHub web interface or
  through the `git` client, such as:
  - Open, list, comment on, or modify
    [issues](https://guides.github.com/features/issues/) or [pull
    requests](https://docs.github.com/github/collaborating-with-issues-and-pull-requests/about-pull-requests)
  - Create, list, or modify [git
    tags](https://git-scm.com/book/en/v2/Git-Basics-Tagging) or [GitHub
    releases](https://docs.github.com/github/administering-a-repository/managing-releases-in-a-repository),
    including uploading release assets
  - Configure and run GitHub
    [Actions](https://github.com/features/actions) and
    [webhooks](https://docs.github.com/developers/webhooks-and-events/about-webhooks)
  - Set up GitHub [users](https://docs.github.com/rest/reference/users)
    and
    [organizations](https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/about-organizations)
  - Manage your
    [deployments](https://docs.github.com/rest/guides/delivering-deployments)
  - …and much, much more.
  There are two ways to use
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi): either through Python,
  or from the command line. An overview of each is provided below.

  To install, run either `pip install ghapi` or
  `conda install -c fastai ghapi`.

  Throughout this documentation, you will see code inputs and outputs
  shown in this format:
  ``` python
  1+1
  ```
      2
  We recommend reading the documentation on the [official
  site](https://ghapi.fast.ai/), rather than on GitHub, since not all the
  functionality described on this page is available through the GitHub
  viewer.
  All of the documentation is available directly as Jupyter Notebooks, for
  instance the current page you’re reading is available as a notebook
  [here](https://github.com/fastai/ghapi/blob/master/index.ipynb). To open
  any page as an interactive notebook in Google Colab, click the *Colab*
  badge at the top of the page.
  To access the GitHub API, first create a
  [`GhApi`](https://ghapi.fast.ai/core.html#ghapi) object:
  ``` python
  from ghapi.all import GhApi
  api = GhApi()
  ```
  Every part of the API includes documentation directly in the `api`
  object itself. For instance, here’s how to explore the groups of
  functionality provided by the API by displaying the object:
  ``` python
  api
  ```
  - [actions](https://docs.github.com/rest/reference/actions)
  - [activity](https://docs.github.com/rest/reference/activity)
  - [apps](https://docs.github.com/rest/reference/apps)
  - [billing](https://docs.github.com/rest/reference/billing)
  - [checks](https://docs.github.com/rest/reference/checks)
  - [code_scanning](https://docs.github.com/rest/reference/code-scanning)
  - [codes_of_conduct](https://docs.github.com/rest/reference/codes-of-conduct)
  - [emojis](https://docs.github.com/rest/reference/emojis)
  - [enterprise_admin](https://docs.github.com/rest/reference/enterprise-admin)
  - [gists](https://docs.github.com/rest/reference/gists)
  - [git](https://docs.github.com/rest/reference/git)
  - [gitignore](https://docs.github.com/rest/reference/gitignore)
  - [interactions](https://docs.github.com/rest/reference/interactions)
  - [issues](https://docs.github.com/rest/reference/issues)
  - [licenses](https://docs.github.com/rest/reference/licenses)
  - [markdown](https://docs.github.com/rest/reference/markdown)
  - [meta](https://docs.github.com/rest/reference/meta)
  - [migrations](https://docs.github.com/rest/reference/migrations)
  - [oauth_authorizations](https://docs.github.com/rest/reference/oauth-authorizations)
  - [orgs](https://docs.github.com/rest/reference/orgs)
  - [projects](https://docs.github.com/rest/reference/projects)
  - [pulls](https://docs.github.com/rest/reference/pulls)
  - [rate_limit](https://docs.github.com/rest/reference/rate-limit)
  - [reactions](https://docs.github.com/rest/reference/reactions)
  - [repos](https://docs.github.com/rest/reference/repos)
  - [scim](https://docs.github.com/rest/reference/scim)
  - [search](https://docs.github.com/rest/reference/search)
  - [secret_scanning](https://docs.github.com/rest/reference/secret-scanning)
  - [teams](https://docs.github.com/rest/reference/teams)
  - [users](https://docs.github.com/rest/reference/users)
  Then we can explore the endpoints provided by the API in each group,
  e.g. for the `git` group:
  ``` python
  api.git
  ```
  - [git.create_blob](https://docs.github.com/rest/reference/git#create-a-blob)(owner,
    repo, content, encoding): *Create a blob*
  - [git.get_blob](https://docs.github.com/rest/reference/git#get-a-blob)(owner,
    repo, file_sha): *Get a blob*
  - [git.create_commit](https://docs.github.com/rest/reference/git#create-a-commit)(owner,
    repo, message, tree, parents, author, committer, signature): *Create a
    commit*
  - [git.get_commit](https://docs.github.com/rest/reference/git#get-a-commit)(owner,
    repo, commit_sha): *Get a commit*
  - [git.list_matching_refs](https://docs.github.com/rest/reference/git#list-matching-references)(owner,
    repo, ref, per_page, page): *List matching references*
  - [git.get_ref](https://docs.github.com/rest/reference/git#get-a-reference)(owner,
    repo, ref): *Get a reference*
  - [git.create_ref](https://docs.github.com/rest/reference/git#create-a-reference)(owner,
    repo, ref, sha, key): *Create a reference*
  - [git.update_ref](https://docs.github.com/rest/reference/git#update-a-reference)(owner,
    repo, ref, sha, force): *Update a reference*
  - [git.delete_ref](https://docs.github.com/rest/reference/git#delete-a-reference)(owner,
    repo, ref): *Delete a reference*
  - [git.create_tag](https://docs.github.com/rest/reference/git#create-a-tag-object)(owner,
    repo, tag, message, object, type, tagger): *Create a tag object*
  - [git.get_tag](https://docs.github.com/rest/reference/git#get-a-tag)(owner,
    repo, tag_sha): *Get a tag*
  - [git.create_tree](https://docs.github.com/rest/reference/git#create-a-tree)(owner,
    repo, tree, base_tree): *Create a tree*
  - [git.get_tree](https://docs.github.com/rest/reference/git#get-a-tree)(owner,
    repo, tree_sha, recursive): *Get a tree*
  Here’s how to learn about an endpoint you want to use, e.g.:
  ``` python
  api.git.get_ref
  ```
  [git.get_ref](https://docs.github.com/rest/reference/git#get-a-reference)(owner,
  repo, ref): *Get a reference*
  In Jupyter Notebook full tab completion, parameter lists, etc are
  provided for all endpoints. Endpoints are called as standard Python
  methods:
  ``` python
  api.git.get_ref(owner='fastai', repo='fastcore', ref='heads/master')
  ```
  - ref: refs/heads/master
  - node_id: MDM6UmVmMjI1NDYwNTk5OnJlZnMvaGVhZHMvbWFzdGVy
  - url:
    https://api.github.com/repos/fastai/fastcore/git/refs/heads/master
  - object:
    - sha: 0e3084ed009baa51db38a640ae7c23d638af2756
    - type: commit
    - url:
      https://api.github.com/repos/fastai/fastcore/git/commits/0e3084ed009baa51db38a640ae7c23d638af2756
  To use [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) to access
  authenticated operations (other than when running through GitHub
  Actions), you will need a GitHub [personal access
  token](https://docs.github.com/github/authenticating-to-github/creating-a-personal-access-token),
  which is a secret code used to access your account. If you don’t have
  one, [click here](https://github.com/settings/tokens/new) to create one.
  You’ll be asked to enter a name – choose anything you like, for instance
  “*ghapi*”. You’ll also be asked to choose “scopes”; this limits what
  you’ll be able to do with the API using this token. If you’re not sure,
  click “*repo*” “*gist*”, “*notifications*”, and “*workflow*”. Then click
  “Generate Token” at the bottom of the screen, and copy the token (the
  long string of letters and numbers shown). You can easily do that by
  clicking the little clipboard icon next to the token.
  Rather than pasting that token into every script, it’s easiest to save
  it as an environment variable. If you save it as `$GITHUB_TOKEN` then it
  will be most convenient, so add this to the end of your `.bashrc` or
  `.zshrc` file:
      export GITHUB_TOKEN=xxx
  …replacing the `xxx` with the token you just copied. (Don’t forget to
  `source` that file after you change it.), pass a \[GitHub token\].
  As well as your `token`, you can also pass any parameters you want
  auto-inserted into relevant methods, such as `owner` and `repo`:
  ``` python
  api = GhApi(owner='fastai', repo='fastcore', token=github_token)
  ```
  We can now repeat the previous method, but only need to pass `ref`:
  ``` python
  api.git.get_ref('heads/master')
  ```
  - ref: refs/heads/master
  - node_id: MDM6UmVmMjI1NDYwNTk5OnJlZnMvaGVhZHMvbWFzdGVy
  - url:
    https://api.github.com/repos/fastai/fastcore/git/refs/heads/master
  - object:
    - sha: 0e3084ed009baa51db38a640ae7c23d638af2756
    - type: commit
    - url:
      https://api.github.com/repos/fastai/fastcore/git/commits/0e3084ed009baa51db38a640ae7c23d638af2756
  Now that we’ve provided our token, we can use authenticated endpoints
  such as creating an issue:
  ``` python
  issue = api.issues.create("Remember to check out GhApi!")
  ```
  Since we’ve now checked out GhApi, let’s close this issue. 😎
  ``` python
  api.issues.update(issue.number, state='closed')
  ```

  You can use [`GhApi`](https://ghapi.fast.ai/core.html#ghapi) via the
  command line, and can access nearly everything in the [GitHub
  API](https://docs.github.com/rest). We provide an overview here of one
  of the command line programs,
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi) – see the full CLI docs
  page for details on all the programs available.
  We strongly recommend enabling tab completion for
  [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi), which you can do by
  placing the following command at the end of your `~/.bashrc` or
  `~/.zshrc` file:
  ``` bash
  eval "$(completion-ghapi --install)"
  ```
  To get started with the [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi)
  command, first find the name of the operation you wish to perform, for
  instance by searching the [full API
  reference](https://ghapi.fast.ai/fullapi.html).
  To use [`ghapi`](https://ghapi.fast.ai/cli.html#ghapi), pass the method
  name (exactly the same as you’d use in the Python API) as the first
  parameter, followed by any positional parameters required, and then
  keyword arguments with “`--`” before each parameter name.
  For instance, [git.get_ref](https://ghapi.fast.ai/fullapi.html#git)
  takes three parameters: `owner`, `repo`, and `ref`. If we wish to pass
  the first two as positional parameters, and the last as a named
  argument, then we’d call:
  ``` bash
  ghapi git.get_ref fastai ghapi-test --ref heads/master
  ```
  If you have enabled tab completion, then after you’ve typed `ghapi g`
  try pressing <kbd>Tab</kbd>, and you’ll see all the operation groups
  available in the GitHub API that start with `g`. If you keep typing,
  e.g. `ghapi git.`, and hit <kbd>Tab</kbd> again, you’ll now see all the
  operations available in the `git` group, i.e:
      git.create_blob git.create_commit git.create_ref git.create_tag git.create_tree git.delete_ref git.get_blob git.get_commit git.get_ref git.get_tag git.get_tree git.list_matching_refs git.name git.update_ref git.verbs
  If you pass just `--help` after the operation name, you’ll see a full
  list of all parameters accepted, and a link to the official GitHub
  documentation.
  ``` bash
  ghapi git.get_ref --help
  >>> git.get_ref(owner, repo, ref)
  >>> https://docs.github.com/rest/reference/git#get-a-reference
  ```
  In addition to `--help` and the GitHub operation parameters, you can
  also pass the following:
  - `--headers`: A list of extra headers to pass, JSON-encoded
  - `--token`: A GitHub authentation token
  - `--debug`: Print requests before sending them


