# packages

pkgId: 13463d33aed20628a1a904b1b91695cc229408ede541a669f989b9897089a91b
name: python-ascnii
arch: src
version: 0.0.1.dev21
epoch: 0
release: 1
summary: View brain images in terminal using ASCII characters
url: https://pypi.org/project/ascnii/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascnii-0.0.1.dev21-1.src.rpm
checksum_type: sha256
description:
  If you always wanted to plot NIfTI images in terminal using ASCII characters,
  you can do so now using the command line tool `ascnii`.

  However, for now, `ascnii` assumes that the image is in MNI space, and will
  likely not work for other kinds of inputs (at the moment)!



  You can simply install from PyPI:

  `pip install ascnii`

  You may or may not want to set up a virtual environment.

  ```sh
  python3 -m venv .examplevenv
  source .examplevenv/bin/activate
  pip install -U pip
  ```

  Alternatively, you can install from github.
  Clone the repository to where you would like to install it.

  ```
  git clone https://github.com/LeSasse/ascnii.git
  cd ascnii
  pip install -e .
  ```



  Run `ascnii --help`:

  ```
  usage: ascnii [-h] [-o OUTPUT] [-H] [-C COLUMNS] [-c] [-m COLORMAP]
                [-b {black,red,red,green,yellow,blue,magenta,cyan,white}]
                [-t THRESHOLD] [-cc CUT_COORDS CUT_COORDS CUT_COORDS] [-a] [-d]
                nifti

  View NIfTI images in terminal using ASCII characters.

  positional arguments:
    nifti                 Path to the NIfTI file.

  optional arguments:
    -h, --help            show this help message and exit
    -o OUTPUT, --output OUTPUT
                          How to output the brain image. By default, prints to
                          {'terminal'}. Otherwise, accepts a path to a html file or a
                          txt file.
    -H, --header          If activated, print out the image header as well.
    -C COLUMNS, --columns COLUMNS
                          Number of character columns (in terminal) to use for
                          plotting.
    -c, --colorbar        If activated, a colorbar is plotted with the brain images.
    -m COLORMAP, --colormap COLORMAP
                          Choose a colormap for the image.
    -b {black,red,red,green,yellow,blue,magenta,cyan,white}, --background {black,red,red,green,yellow,blue,magenta,cyan,white}
                          Choose a terminal color for the background.
    -t THRESHOLD, --threshold THRESHOLD
                          Threshold the given image below this value.
    -cc CUT_COORDS CUT_COORDS CUT_COORDS, --cut_coords CUT_COORDS CUT_COORDS CUT_COORDS
                          MNI coordinates at which to plot the image.
    -a, --annotate        If activated, positions and left/right annotation are
                          added.
    -d, --draw_cross      If activated, a cross is drawn on the plot to indicate the
                          cut position.
  ```





  `ascnii example_img.nii.gz`:

  ![plot](./examples/example_default.png)

  You can also plot 4D NIfTI images, `ascnii` will simply plot the mean image.



  By default, `ascnii` will use the complete width of the terminal, but you may want
  to adjust width manually.
  Make sure to zoom out a bit, so your terminal has enough space and
  run `ascnii example_img.nii.gz --columns 600`:

  ![plot](./examples/example_columns.png)

  This is also useful if you want to output the ASCII image as an html to achieve higher
  resolution. For example `ascnii example_img.nii.gz --columns 700 -o example_html.html`
  results in the image [here](https://raw.githack.com/LeSasse/ascnii/main/examples/example_html.html).



  In order to change the colormap choose any of the [matplotlib colormaps](https://matplotlib.org/stable/tutorials/colors/colormaps.html)
  and hand them over as strings to the `--colormap` option. At the same time you can
  also change the background color by handing any of the values listed for the
  `--background` option. Run `ascnii example_img.nii.gz -m plasma -b white`:

  ![plot](./examples/example_color.png)


pkgId: ffec05acf4e30664a25713c8f39ebed628dea14ebe402ae7656d85b76d60f804
name: python-asconnect
arch: src
version: 3.0.6
epoch: 0
release: 1
summary: A wrapper around the Apple App Store Connect APIs
url: https://github.com/microsoft/asconnect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asconnect-3.0.6-1.src.rpm
checksum_type: sha256
description:
  asconnect is a Python wrapper around the [Apple App Store Connect REST APIs](https://developer.apple.com/documentation/appstoreconnectapi).

  This wrapper does not cover every API, but does cover the basics, including:

  * Uploading a build
  * Creating a new TestFlight version
  * Setting TestFlight review information
  * Creating a new app store version
  * Setting the app review information
  * Submitting for app review





  The package is available on PyPI, so you can run `pip install asconnect` to get the latest version.



  To begin, you need to [generate a key](https://developer.apple.com/documentation/appstoreconnectapi/creating_api_keys_for_app_store_connect_api), then get it's ID, the contents of the key itself, and the issuer ID.

  Once you have those, you can create a new client by running:

  ```python
  client = asconnect.Client(key_id="...", key_contents="...", issuer_id="...")
  ```



  Most operations require an app identifier. This is not the same as the bundle ID you choose, but is an ID generated by Apple. The easiest way to get this is to run this code:

  ```python
  app = client.app.get_from_bundle_id("com.example.my_bundle_id")
  ```



  Uploading a build isn't technically part of the App Store Connect APIs, but a wrapper around altool is included to make things as easy as possible. Let's upload a build for your app:

  ```python
  client.build.upload(
    ipa_path="/path/to/the/app.ipa",
    platform=asconnect.Platform.ios,
  )
  ```

  And if you want to wait for your build to finish processing:

  ```python
  build = client.build.wait_for_build_to_process("com.example.my_bundle_id", build_number)
  ```

  `build_number` is the build number you gave your build when you created it. It's used by the app store to identify the build.



  Let's take that build, create a new app store version and submit it,

  ```python

  version = client.app.create_new_version(version="1.2.3", app_id=app.identifier)


  client.version.set_build(version_id=version.identifier, build_id=build.identifier)


  client.version.submit_for_review(version_id=version.identifier)
  ```

  It's that easy. Most of the time at least. If you don't have previous version to inherit information from you'll need to do things like set screenshots, reviewer info, etc. All of which is possible through this library.

  ```python

  version = client.app.create_new_version(version="1.2.3", app_id=app.identifier)


  phased_release = client.version.create_phased_release(version_id=version.identifier)


  phased_release = client.version.get_phased_release(version_id=version.identifier)


  phased_release = client.version.patch_phased_release(phased_release_id=phased_release.identifier, phased_release_state=PhasedReleaseState.active)
  phased_release = client.version.patch_phased_release(phased_release_id=phased_release.identifier, phased_release_state=PhasedReleaseState.pause)
  phased_release = client.version.patch_phased_release(phased_release_id=phased_release.identifier, phased_release_state=PhasedReleaseState.complete)


  client.version.delete_phased_release(phased_release_id=phased_release.identifier)
  ```


  For development `asconnect` uses [`poetry`](https://github.com/python-poetry/poetry)



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

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

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


pkgId: 2721afb019e8ef4c3ed095839c2655d0f8d9042c4deb9d2bedab9907a48c5178
name: python-ascvd
arch: src
version: 0.5
epoch: 0
release: 1
summary: Module for calculating ASCVD 10-year estimate
url: https://github.com/brandones/ascvd
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ascvd-0.5-1.src.rpm
checksum_type: sha256
description:
  Install it: `pip install ascvd`

  Should be compatible with Python 2 and 3 alike.

  Should agree with http://tools.acc.org/ASCVD-Risk-Estimator-Plus/#!/calculate/estimate/

  Code mostly borrowed from https://github.com/cerner/ascvd-risk-calculator

  Referring to the README for that project, this calculates the ASCVD risk according
  to the [2013 ACC/AHA Guideline on the Assessment of Cardiovascular Risk](http://circ.ahajournals.org/content/circulationaha/129/25_suppl_2/S49.full.pdf)
  and the [2013 ACC/AHA Guideline on the Treatment of Blood Cholesterol to Reduce Atherosclerotic Cardiovascular Risk in Adults](http://circ.ahajournals.org/content/circulationaha/129/25_suppl_2/S1.full.pdf).




  It's a single function.

  ```
  compute_ten_year_score -> int
      Args:
          isMale (bool)
          isBlack (bool)
          smoker (bool)
          hypertensive (bool)
          diabetic (bool)
          age (int)
          systolicBloodPressure (int)
          totalCholesterol (int)
          hdl (int)
  ```



  This could really use some tests! The code right now pretty much just assumes
  that the good folks at Cerner are superhumans who don't make mistakes.

  Feel free to fork and open a pull request. Please, one pull request per
  functional change.


pkgId: edc7795577fdd3a6f3219087e3b256b5b35a346be07263cafcccfb31e2686e44
name: python-asdcontroller
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: ASD Fieldspec 4 interface
url: https://github.com/GOA-UVa/asdcontroller
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdcontroller-0.0.12-1.src.rpm
checksum_type: sha256
description:
  Python library for the management of the ASD FieldSpec 4

  Made by the Atmospheric Optics Group of the Valladolid University (GOA-UVa) for a campaign
  at Izaña, Tenerife, Spain.


pkgId: ea064ae26172172f37c66789647f55706ce47e0ee31eceba1d087deac21a9735
name: python-asdf
arch: src
version: 3.4.0
epoch: 0
release: 1
summary: Python implementation of the ASDF Standard
url: https://pypi.org/project/asdf/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-3.4.0-1.src.rpm
checksum_type: sha256
description:
  The **A**\ dvanced **S**\ cientific **D**\ ata **F**\ ormat (ASDF) is a
  next-generation interchange format for scientific data. This package
  contains the Python implementation of the ASDF Standard. More
  information on the ASDF Standard itself can be found
  `here <https://asdf-standard.readthedocs.io>`__.
  The ASDF format has the following features:
  * A hierarchical, human-readable metadata format (implemented using `YAML
    <http://yaml.org>`__)
  * Numerical arrays are stored as binary data blocks which can be memory
    mapped. Data blocks can optionally be compressed.
  * The structure of the data can be automatically validated using schemas
    (implemented using `JSON Schema <http://json-schema.org>`__)
  * Native Python data types (numerical types, strings, dicts, lists) are
    serialized automatically
  * ASDF can be extended to serialize custom data types
  ASDF is under active development `on github
  <https://github.com/asdf-format/asdf>`__. More information on contributing
  can be found `below <#contributing>`__.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2021 Association of Universities for Research in Astronomy. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: a7cabeb706a96fba4c9bc6c893b9e1369cfc6a4a20a62338d8c08b3addc5e96d
name: python-asdf-astropy
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: ASDF serialization support for astropy
url: https://pypi.org/project/asdf-astropy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-astropy-0.6.1-1.src.rpm
checksum_type: sha256
description:
  This package includes plugins that provide ASDF serialization support for astropy
  objects.  The plugins are automatically enabled when the package is installed.
  The plugins in this package supersede those in the ``astropy.io.misc.asdf`` module;
  when this package is installed, the astropy plugins will be ignored.  The
  ``astropy.io.misc.asdf`` module will be removed in a future version of astropy.

rpm_license:
  Copyright (c) 2011-2022, Astropy Developers  All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the Astropy Team nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 286c375aa0c64365ee2c908e1f2c0481466c13626e9901aa26a3ceff60757b09
name: python-asdf-coordinates-schemas
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: ASDF schemas for coordinates
url: https://pypi.org/project/asdf-coordinates-schemas/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-coordinates-schemas-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/asdf-format/asdf-coordinates-schemas/workflows/CI/badge.svg)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

  This package provides ASDF schemas for validating coordinates tags.  Users should not
  need to install this directly; instead, install an implementation package such
  as asdf-astropy, which includes asdf-coordinates-schemas as a dependency.

rpm_license:
  Copyright (c) 2021 Association of Universities for Research in Astronomy. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 325258af54a9b9cf41e5004d40e073846bbdf8d04f6ac6533c5b97d54bc637b7
name: python-asdf-pydantic
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Create ASDF tags with pydantic models
url: https://pypi.org/project/asdf-pydantic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-pydantic-1.1.0-1.src.rpm
checksum_type: sha256
description:
  asdf_library: !core/software-1.0.0 {
      author: The ASDF Developers,
      homepage: 'http://github.com/asdf-format/asdf',
      name: asdf,
      version: 2.14.3}
  history:
    extensions:
    - !core/extension_metadata-1.0.0
      extension_class: asdf.extension.BuiltinExtension
      software: !core/software-1.0.0 {
          name: asdf,
          version: 2.14.3}
    - !core/extension_metadata-1.0.0 {
      extension_class: mypackage.shapes.ShapesExtension,
      extension_uri: 'asdf://asdf-pydantic/shapes/extensions/shapes-1.0.0'}
  rect: !<asdf://asdf-pydantic/shapes/tags/rectangle-1.0.0> {
      height: 1.0,
      width: 1.0}
  ```
  </div>

  - [x] Create ASDF tag from your *pydantic* models with batteries ([converters](https://asdf.readthedocs.io/en/stable/asdf/extending/converters.html)) included.
  - [x] Validates data models as you create them and not only when reading and writing ASDF files.
  - [x] Preserve Python types when deserializing ASDF files.
  - [x] All the cool things that comes with *pydantic* (e.g., JSON encoder, JSON schema, Pydantic types).
  - [ ] <span style="color: #757575!important">Comes with ASDF schemas (TBD).</span>

  ```console
  pip install asdf-pydantic
  ```

  Define your data model with `AsdfPydanticModel`. For *pydantic* fans, this has
  all the features of pydantic's BaseModel.
  ```py

  from asdf_pydantic import AsdfPydanticModel
  class Rectangle(AsdfPydanticModel):
      _tag = "asdf://asdf-pydantic/examples/tags/rectangle-1.0.0"
      width: float
      height: float
  ```
  Then create an extension with the converter included with *asdf-pydantic*:
  ```py

  from asdf.extension import Extension
  from asdf_pydantic.converter import AsdfPydanticConverter
  from mypackage.shapes import Rectangle
  AsdfPydanticConverter.add_models(Rectangle)
  class ShapesExtension(Extension):
      extension_uri = "asdf://asdf-pydantic/examples/extensions/shapes-1.0.0"
      converters = [AsdfPydanticConverter()]
      tags = [*AsdfPydanticConverter().tags]
  ```
  Install the extension either by entry point specification or add it to
  `asdf.get_config()`:
  ```py
  import asdf
  from mypackage.extensions import ShapeExtension
  asdf.get_config().add_extension(ShapesExtension())
  af = asdf.AsdfFile()
  af["rect"] = Rectangle(width=1, height=1)
  with open("shapes.asdf", "wb") as fp:
      af.write_to(fp)


pkgId: 078497a25cc44ca232ab95e35ed1e8c29cfc440566ec8b39be3f74ab56f662ae
name: python-asdf-standard
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: The ASDF Standard schemas
url: https://pypi.org/project/asdf-standard/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-standard-1.1.1-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/asdf-format/asdf-standard/workflows/CI/badge.svg)
  ![Downstream](https://github.com/asdf-format/asdf-standard/workflows/Downstream/badge.svg)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![DOI](https://zenodo.org/badge/18113139.svg)](https://zenodo.org/badge/latestdoi/18113139)
  This document describes the Advanced Scientific Data Format (ASDF),
  pronounced *AZ*-diff.  You can read the full specification at [the online documentation](http://asdf-standard.readthedocs.io/).
  > This is the **A**dvanced **S**cientific **D**ata **F**ormat - if you are looking for the **A**daptable **S**eismic **D**ata **F**ormat, go here: http://seismic-data.org/

  Please open a new [issue](https://github.com/spacetelescope/asdf-standard/issue) or new [pull request](https://github.com/spacetelescope/asdf-standard/pulls) for bugs, feedback, or new features you would like to see. If there is an issue you would like to work on, please leave a comment and we will be happy to assist. New contributions and contributors are very welcome!
  There are two mailing lists for ASDF:
  * [asdf-users](https://groups.google.com/forum/#!forum/asdf-users)
  * [asdf-developers](https://groups.google.com/forum/#!forum/asdf-developers)

  * [FAQ page](https://github.com/spacetelescope/asdf-standard/wiki/FAQ) on the wiki.
  * [ASDF: A new data format for astronomy](https://doi.org/10.1016/j.ascom.2015.06.004), published in *Astronomy and Computing*:
  > Greenfield, P., Droettboom, M., & Bray, E. (2015). ASDF: A new data format for astronomy. *Astronomy and Computing*, 12: 240-251.
  > doi:[10.1016/j.ascom.2015.06.004](https://doi.org/10.1016/j.ascom.2015.06.004)

rpm_license:
  Copyright (c) 2022 Association of Universities for Research in Astronomy. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 6a928436ccdafd87a7c0f39bbec4611ab45481b39de360cd38b3ce5f6325bf26
name: python-asdf-transform-schemas
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: ASDF schemas for transforms
url: https://pypi.org/project/asdf-transform-schemas/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-transform-schemas-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/asdf-format/asdf-transform-schemas/workflows/CI/badge.svg)
  ![Downstream](https://github.com/asdf-format/asdf-transform-schemas/workflows/Downstream/badge.svg)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

  This package provides ASDF schemas for validating transform tags.  Users should not
  need to install this directly; instead, install an implementation package such
  as asdf-astropy, which includes asdf-transform-schemas as a dependency.

rpm_license:
  Copyright (c) 2021 Association of Universities for Research in Astronomy. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: cbb809f303bae86482526eb2456051b13031774064630fa055b6575bd741d5c8
name: python-asdf-unit-schemas
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: DEPRECATED: ASDF schemas for units
url: https://pypi.org/project/asdf-unit-schemas/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-unit-schemas-0.2.0-1.src.rpm
checksum_type: sha256
description:
  This package is decommissioned and no longer provides any ASDF schemas.
  The schemas provided by the package were duplicates of the schemas provided
  by [asdf-standard](https://github.com/asdf-format/asdf-standard).

  This repository will be archived after a final release of this package
  (which will contain no schemas).

rpm_license:
  Copyright (c) 2021 Association of Universities for Research in Astronomy. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: d678d261c2e5cba255a982cb869764bb81e3d869798041886847c075b6e057ba
name: python-asdf-wcs-schemas
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: ASDF WCS schemas
url: https://pypi.org/project/asdf-wcs-schemas/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdf-wcs-schemas-0.4.0-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/asdf-format/asdf-wcs-schemas/workflows/CI/badge.svg)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

  This package provides ASDF schemas for validating WCS tags. Users should not need to install this directly; instead, install an implementation package such as gwcs, which includes asdf-wcs-schemas as a dependency.

rpm_license:
  Copyright (C) 2021 Association of Universities for Research in Astronomy (AURA)  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. The name of AURA and its representatives may not be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY AURA ``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 AURA 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: 920da9b33f0af880f511ce0dff5199338aac9b11832afc2ffea9e238ce7101e6
name: python-asdm
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A Python package for System Dynamics Modeling
url: https://github.com/wzh1895/ASDM
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asdm-0.2.1-1.src.rpm
checksum_type: sha256
description:
  ASDM is a python library that enables its users to create and simulate System Dynamics (SD) models. It can also simulate SD models saved in the XMILE format, including advanced features such as arrays and conveyors. The support is being continuously improved.

  In the library:

  - `asdm/asdm.py` consists of the main functionalities, including the lexer, parser, and interpreter.

  - `asdm/utilities.py` provies a data visualisation tool.

  - `asdm/Inference` consists of tools for model calibration.




  ```
  pip install asdm
  ```
  ASDM and its required dependencies will be automatically installed.



  At any path, execute the following code in the interactive Python environment or as a part of a script:

  ```
  from asdm import sdmodel
  ```

  'sdmodel' is the class for System Dynamics models.



  Please refer to [Documentation](Documentation.md) for the commonly used functions.




  We also use Jupyter Notebooks to provide demoes of ASDM's functionalities.


  [SD Modelling](demo/Demo_SD_modelling.ipynb)

  - Creating an SD model from scratch
    - Adding stocks, flows, auxiliaries
    - Support for nonlinear functions (MIN, MAX, etc.)
    - Support for stochastic functions (random binomial trial, etc.)
  - Running simulations
  - Exporting and examing simulation outcomes
  - Displaying simulation outcomes as graph

  We will add more tutorial notebooks.

  You are welcomed to share your own tutorial notebooks through a `pull request`. When sharing notebooks, please make sure it does not contain sensitive data.



  ASDM is made public under the MIT licence.


  **Wang Zhao** `main author`

  PhD candidate & research assistant at University of Strathclyde, UK

  Wang has given multiple talks on ASDM at different gatherings and conferences of modellers, operational researchers, and healthcare experts. This is the YouTube link to [one of the talks](https://www.youtube.com/watch?v=I_0YpIKc3yI&t=2321s).

  Wang can be reached at <wang.zhao@strath.ac.uk>.

  **Matt Stammers** `contributor`

  Consultant Gastroenterologist & open-source software developer at University Hospital Southampton, UK

  Matt created a webapp using streamlit to allow users to interact with a simulation dashboard in their web browsers or on smartphones, such as in this [demo](https://github.com/ReallyUsefulModels/Donanumab_Model). The simulation of the SD model in the backend is powered by ASDM. This is a part of an initiative [Really Useful Models](https://opendatasaveslives.org/news/2022-01-05-really-useful-models).

  Matt's [GitHub Homepage](https://github.com/MattStammers)


pkgId: 313b86860abfa668acbbf4f64994a9a3d63a1cfd17da76d22f2078b3644c367f
name: python-ase
arch: src
version: 3.23.0
epoch: 0
release: 1
summary: Atomic Simulation Environment
url: https://pypi.org/project/ase/
rpm_license: LGPLv2.1+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ase-3.23.0-1.src.rpm
checksum_type: sha256
description:
  ASE is a set of tools and Python modules for setting up, manipulating,
  running, visualizing and analyzing atomistic simulations.
  Webpage: http://wiki.fysik.dtu.dk/ase


pkgId: de4fa26f62b410f4b6250de91529d3cc37a7ae40e4c41fa9c14cf854df30005f
name: python-ase2sprkkr
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: ASE (atomic simulation environment) interface to SPRKKR
url: https://ase2sprkkr.github.io/ase2sprkkr/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ase2sprkkr-2.2.1-1.src.rpm
checksum_type: sha256
description:
  ASE2SPRKKR package provide an interface that allow use of the [SPR-KKR
  package](https://www.ebert.cup.uni-muenchen.de/index.php/en/software-en/13-sprkkr)
  to electronic structure calculation within [Atomic Simulation
  Environment](https://wiki.fysik.dtu.dk/ase/) (abbreviated as ASE)
  \-\--Python tool that integrates the various tools for electronic
  structure calculation.



  -   [SPR-KKR](https://ebert.cup.uni-muenchen.de/index.php/en/software-en/13-sprkkr)
  -   [ASE - Atomic Simulation
      Environment](https://wiki.fysik.dtu.dk/ase/)
  -   [Online version of this
      documentation](https://ase2sprkkr.github.io/ase2sprkkr/)
  -   [GitHub repository of the ASE2SPRKKR
      package](https://github.com/ase2sprkkr/ase2sprkkr/)
  -   [SPR-KKR
      manual](https://www.ebert.cup.uni-muenchen.de/index.php/en/repository/func-startdown/251/lang,en-gb/)



  The simplest way how to install and use the package is to install them
  using package managers: either pip

  ``` bash
  pip install ase2sprkkr
  ```

  or conda

  ``` bash
  conda install -c ase2sprkkr ase2sprkkr
  ```



  In some systems, the `pip` utility for `python3` is called `pip3`. If it
  is not installed, you can install it using the linux distribution
  package manager, e.g. in Debian/Ubuntu

  ``` bash
  apt install pip3
  ```

  or

  ``` bash
  zypper install pip
  ```

  in OpenSUSE

  For the conda installation instructions, see the Anaconda documentation
  <https://docs.anaconda.com/anaconda/install/linux/> however, for the
  users unexperienced with conda, the (simpler) pip way is recommended.



  If you do not want to use public package managers as pip or conda, or
  you want to contribute to development, you can use GIT to obtain the
  package sources.



  -   Python \>= 3.7
  -   SPR-KKR (not checked by the installer)
  -   Python packages: see the the setup.cfg
  -   Git (to obtain the sources)



  ``` bash
  git clone https://github.com/ase2sprkkr/ase2sprkkr.git
  git checkout release
  ```

  The first line fetches the code of the package. The second one checks
  out the recommended production version of the code.

  If you want to obtain the current version of the (earlier-downloaded)
  code, run

  ``` bash
  git fetch
  git checkout release
  ```

  Alternatively, you can checkout `master` or `develop` branch

  ``` bash
  git checkout master
  ```

  to obtain a newer (not thorougly tested yet) version or

  ``` bash
  git checkout develop
  ```

  to obtain the bleeding edge version (feel free to try it, test it and
  report the bugs).



  You can either just add the src directory to your PYTHONPATH, or you can
  build and install the package, as it is described below.



  To install the package, the simplest way is to use pip

  ``` bash
  python3 -m pip install .
  ```

  Maybe, you will have to replace `python3` with `python`. For an editable
  install, please run

  ``` bash
  python3 setup.py develop --user
  ```

  and ignore some deprecation warning. Editable install is aimed for
  developers: in this type of install, only link to the current directory
  will be added to your local `site-packages`, which allows you to use the
  changesyou make to the source code.



  The documentation is published online at
  <https://ase2sprkkr.github.io/ase2sprkkr/>

  If you are using Git cloned sources, you can run

      open docs/index.html

  to see the (offline version of the) documentation. The documentation
  contains parts, that are generated from the docstrings in the source
  code. You can regenerate these by

  ``` bash
  make docs
  ```

  Sphinx and sphinx-toolbox python packages (installable e.g. using pip)
  and pandoc (for generating README.md) are needed for the build.

  However, the official build of Sphinx miss some attributes when it is
  used to build the documentation. So, till the pullrequest that corrects
  the Sphinx behavior will be merged into Sphinx, please use the following
  fork for building the documentation.
  <https://github.com/lokik/sphinx.git>



  Please feel free to make a pull-request or post an issue at:
  <https://github.com/ase2sprkkr/ase2sprkkr>


pkgId: 3a821d3b995b29d3f30398b7c65127204b33af5a57feb1439cb68f960ecce8a5
name: python-asedftk
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: DFTK-based calculator for ASE
url: https://github.com/mfherbst/asedftk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asedftk-0.2.7-1.src.rpm
checksum_type: sha256
description:
  | **Documentation**                                       | **Build Status**      |  **Installation**         |
  |:------------------------------------------------------- |:--------------------- |:------------------------- |
  | [![][docs-img]][docs-url] [![][gitter-img]][gitter-url] | [![][ci-img]][ci-url] | [![][pypi-img]][pypi-url] |

  [docs-img]: https://img.shields.io/badge/docs-latest-blue.svg
  [docs-url]: https://github.com/mfherbst/asedftk/blob/master/docs/asedftk.md

  [gitter-img]: https://badges.gitter.im/DFTK-jl/community.svg
  [gitter-url]: https://gitter.im/DFTK-jl/community

  [ci-img]: https://github.com/mfherbst/asedftk/workflows/CI/badge.svg?branch=master&event=push
  [ci-url]: https://github.com/mfherbst/asedftk/actions

  [pypi-img]: https://img.shields.io/pypi/v/asedftk
  [pypi-url]: https://pypi.org/project/asedftk

  Small wrapper around the
  [**density-functional toolkit (DFTK)**](https://dftk.org)
  to provide a
  [calculator interface](https://wiki.fysik.dtu.dk/ase/ase/calculators/calculators.html)
  compatible with [ASE](https://wiki.fysik.dtu.dk/ase/index.html),
  the atomistic simulation environment.

  [DFTK](https://dftk.org) is a small library of Julia algorithms
  for developing plane-wave-based density-functional theory methods.
  Albeit only a good year of development it already has a [sizeable feature set](https://docs.dftk.org/dev/#package-features)
  and a performance on the same order as established packages in the field.
  See [dftk.org](https://dftk.org) and the [DFTK documentation](https://juliamolsim.github.io/DFTK.jl/dev/) for more details.


  See the [asedftk instructions](https://github.com/mfherbst/asedftk/blob/master/docs/asedftk.md).


  `asedftk.DFTK` is basically a class wrapping around DFTK and making it an
  [ASE calculator](https://wiki.fysik.dtu.dk/ase/ase/calculators/calculators.html).
  Just use it like any other calculator class. For example:
  ```python
  from asedftk import DFTK
  from ase.build import bulk

  atoms = bulk("Si")
  atoms.calc = DFTK()
  print(atoms.get_potential_energy())
  ```

  More details can be found in the [asedftk documentation](https://github.com/mfherbst/asedftk/blob/master/docs/asedftk.md).


pkgId: 02cb670da8f16440f99e6a23cd5d338428dd7045b3366568d6c3bb7f2e78f46f
name: python-aseg-gdf2
arch: src
version: 0.7
epoch: 0
release: 1
summary: Python package to help read ASEG GDF2 packages
url: https://github.com/kinverarity1/aseg_gdf2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aseg-gdf2-0.7-1.src.rpm
checksum_type: sha256
description:
  [![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/kinverarity1/aseg_gdf2/blob/master/LICENSE)

  Python code to help read ASEG GDF2 data packages.

  GDF2 files are a plain text format for storing geophysical data. The file format is [defined](https://www.aseg.org.au/technical/aseg-technical-standards) by the Australian Society of Exploration Geophysicists (ASEG). This module provides Python functions for reading the definition file (.dfn) and extracting data from the data table file (.dat). It's designed to work on machines with low-ish memory, and to do so it has a dependency on [pandas](https://pandas.pydata.org/) and [dask](https://docs.dask.org/en/latest/dataframe.html).

  It is still in very early stages of development. Help would be very welcome!



  Take a look at the [example notebooks](notebooks)!



  ```python
  >>> import aseg_gdf2
  >>> gdf = aseg_gdf2.read(r'tests/example_datasets/3bcfc711/GA1286_Waveforms')
  >>> gdf.nrecords
  23039
  >>> gdf.field_names()
  ['FLTNUM', 'Rx_Voltage', 'Flight', 'Time', 'Tx_Current']
  >>> for row in gdf.iterrows():
  ...     print(row)
  ...     break
  {'Index': 0, 'FLTNUM': 1.0, 'Rx_Voltage': -0.0, 'Flight': 1, 'Time': 0.0052, 'Tx_Current': 0.00176}
  {'Index': 1, 'FLTNUM': 1.0, 'Rx_Voltage': -0.0, 'Flight': 1, 'Time': 0.0104, 'Tx_Current': 0.00176}
  {'Index': 2, 'FLTNUM': 1.0, 'Rx_Voltage': -0.0, 'Flight': 1, 'Time': 0.0156, 'Tx_Current': 0.00176}
  {'Index': 3, 'FLTNUM': 1.0, 'Rx_Voltage': -0.0, 'Flight': 1, 'Time': 0.0208, 'Tx_Current': 0.00176}
  {'Index': 4, 'FLTNUM': 1.0, 'Rx_Voltage': -0.0, 'Flight': 1, 'Time': 0.026, 'Tx_Current': 0.00176}
  {'Index': 5, 'FLTNUM': 1.0, 'Rx_Voltage': -0.0, 'Flight': 1, 'Time': 0.0312, 'Tx_Current': 0.00176}
  ```

  You can also get the data table as a pandas.DataFrame:

  ```python
  >>> print(gdf.df())
  ```

  ```
     FLTNUM  Rx_Voltage  Flight    Time  Tx_Current
  0     1.0        -0.0       1  0.0052     0.00176
  1     1.0        -0.0       1  0.0104     0.00176
  2     1.0        -0.0       1  0.0156     0.00176
  3     1.0        -0.0       1  0.0208     0.00176
  4     1.0        -0.0       1  0.0260     0.00176
  ```

  Get the data just for one field/column:

  ```python
  >>> gdf.get_field_data('Time')
  array([  5.20000000e-03,   1.04000000e-02,   1.56000000e-02, ...,
           5.99844000e+01,   5.99896000e+01,   5.99948000e+01])
  ```

  What about fields which are 2D arrays? Some GDF2 data files have fields with more than one value per row/record. e.g. in this one the last four fields each take up 30 columns:

  ```python
  >>> gdf = aseg_gdf2.read(r'tests/example_datasets/9a13704a/Mugrave_WB_MGA52.dfn')
  >>> print(gdf.record_types.df()[["name", "unit", "format", "cols"]])
  ```

  ```
            name  unit   format  cols
  0           RT             A4     1
  1     COMMENTS            A76     1
  0   GA_Project            I10     1
  1       Job_No            I10     1
  2     Fiducial          F15.2     1
  3     DATETIME  days   F18.10     1
  4         LINE            I10     1
  5      Easting     m    F12.2     1
  6        NORTH     m    F15.2     1
  7      DTM_AHD          F10.2     1
  8        RESI1          F10.3     1
  9       HEIGHT     m    F10.2     1
  10      INVHEI     m    F10.2     1
  11         DOI     m    F10.2     1
  12        Elev     m  30F12.2    30
  13         Con  mS/m  30F15.5    30
  14     Con_doi  mS/m  30F15.5    30
  15        RUnc        30F12.3    30
  ```

  You can see the field names in the normal manner:

  ```python
  >>> gdf.field_names()
  ['GA_Project',
   'Job_No',
   'Fiducial',
   'DATETIME',
   'LINE',
   'Easting',
   'NORTH',
   'DTM_AHD',
   'RESI1',
   'HEIGHT',
   'INVHEI',
   'DOI',
   'Elev',
   'Con',
   'Con_doi',
   'RUnc']
  ```

   Or you can see the column names:

  ```python
  >>> gdf.column_names()
  ['GA_Project', 'Job_No', 'Fiducial', 'DATETIME', 'LINE', 'Easting', 'NORTH', 'DTM_AHD', 'RESI1',
   'HEIGHT', 'INVHEI', 'DOI', 'Elev[0]', 'Elev[1]', 'Elev[2]', 'Elev[3]', 'Elev[4]', 'Elev[5]',
   'Elev[6]', 'Elev[7]', 'Elev[8]', 'Elev[9]', 'Elev[10]', 'Elev[11]', 'Elev[12]', 'Elev[13]',
   'Elev[14]', 'Elev[15]', 'Elev[16]', 'Elev[17]', 'Elev[18]', 'Elev[19]', 'Elev[20]', 'Elev[21]',
   'Elev[22]', 'Elev[23]', 'Elev[24]', 'Elev[25]', 'Elev[26]', 'Elev[27]', 'Elev[28]', 'Elev[29]',
   'Con[0]', 'Con[1]', 'Con[2]', 'Con[3]', 'Con[4]', 'Con[5]', 'Con[6]', 'Con[7]', 'Con[8]', 'Con[9]',
   'Con[10]', 'Con[11]', 'Con[12]', 'Con[13]', 'Con[14]', 'Con[15]', 'Con[16]', 'Con[17]', 'Con[18]',
   'Con[19]', 'Con[20]', 'Con[21]', 'Con[22]', 'Con[23]', 'Con[24]', 'Con[25]', 'Con[26]', 'Con[27]',
   'Con[28]', 'Con[29]', 'Con_doi[0]', 'Con_doi[1]', 'Con_doi[2]', 'Con_doi[3]', 'Con_doi[4]',
   'Con_doi[5]', 'Con_doi[6]', 'Con_doi[7]', 'Con_doi[8]', 'Con_doi[9]', 'Con_doi[10]', 'Con_doi[11]',
   'Con_doi[12]', 'Con_doi[13]', 'Con_doi[14]', 'Con_doi[15]', 'Con_doi[16]', 'Con_doi[17]',
   'Con_doi[18]', 'Con_doi[19]', 'Con_doi[20]', 'Con_doi[21]', 'Con_doi[22]', 'Con_doi[23]',
   'Con_doi[24]', 'Con_doi[25]', 'Con_doi[26]', 'Con_doi[27]', 'Con_doi[28]', 'Con_doi[29]', 'RUnc[0]',
   'RUnc[1]', 'RUnc[2]', 'RUnc[3]', 'RUnc[4]', 'RUnc[5]', 'RUnc[6]', 'RUnc[7]', 'RUnc[8]', 'RUnc[9]',
   'RUnc[10]', 'RUnc[11]', 'RUnc[12]', 'RUnc[13]', 'RUnc[14]', 'RUnc[15]', 'RUnc[16]', 'RUnc[17]',
   'RUnc[18]', 'RUnc[19]', 'RUnc[20]', 'RUnc[21]', 'RUnc[22]', 'RUnc[23]', 'RUnc[24]', 'RUnc[25]',
   'RUnc[26]', 'RUnc[27]', 'RUnc[28]', 'RUnc[29]']
  ```

  We can get the data in exactly the same way as a normal "column" field.

  ```python
  >>> gdf.get_field_data("Elev")
  array([[ 354.1,  352.1,  349.8, ..., -105.8, -171.2, -245.7],
         [ 353.8,  351.8,  349.5, ..., -106.1, -171.5, -246. ],
         [ 353.7,  351.7,  349.4, ..., -106.2, -171.6, -246.1],
         ...,
         [ 510.5,  508.5,  506.2, ...,   50.6,  -14.8,  -89.3],
         [ 510.5,  508.5,  506.2, ...,   50.6,  -14.8,  -89.3],
         [ 510.6,  508.6,  506.3, ...,   50.7,  -14.7,  -89.2]])
  ```

  We can also get a combination of ordinary column fields and 2D fields:

  ```python
  >>> gdf.get_fields_data(["Easting", "NORTH", "Elev"])
  (array([948001.6, 948001.9, 948001.5, 948000.6, 947999.1, 947997.2,
          947995.1, 947993.4, 947992.5, 947992.5, 947993.3, 947994.7,
          947996. , 947997.1, 947997.8, 947997.9, 800001.6, 800002.4,
          800003. , 800003.5, 800003.5, 800003.3, 800002.9, 800002.8,
          800002.8, 800003.1, 800003.7, 800004.1, 800004.3, 800004.5,
          800004.4, 800004.2, 800004.1, 800004.1, 800003.9, 800003.7,
          800003.3, 800002.6]),
   array([7035223.1, 7035196.8, 7035169.5, 7035141.6, 7035113.6, 7035085.9,
          7035058.5, 7035031.3, 7035004.2, 7034976.6, 7034948.3, 7034919.2,
          7034889.4, 7034859. , 7034828.4, 7034797.9, 7029884.1, 7029855.3,
          7029826.9, 7029798.6, 7029770.1, 7029741.5, 7029712.8, 7029684.3,
          7029656.1, 7029628.1, 7029600.1, 7029572. , 7029543.8, 7029515.5,
          7029487.4, 7029459.7, 7029432.1, 7029404.5, 7029376.8, 7029348.7,
          7029320.2, 7029291.4]),
   array([[ 354.1,  352.1,  349.8, ..., -105.8, -171.2, -245.7],
          [ 353.8,  351.8,  349.5, ..., -106.1, -171.5, -246. ],
          [ 353.7,  351.7,  349.4, ..., -106.2, -171.6, -246.1],
          ...,
          [ 510.5,  508.5,  506.2, ...,   50.6,  -14.8,  -89.3],
          [ 510.5,  508.5,  506.2, ...,   50.6,  -14.8,  -89.3],
          [ 510.6,  508.6,  506.3, ...,   50.7,  -14.7,  -89.2]]))
  ```

  Under the hood this works using pandas' [``usecols`` keyword argument](https://pandas.pydata.org/pandas-docs/version/0.22/generated/pandas.read_fwf.html).



  ```python
  pip install -U aseg_gdf2
  ```




  - Fix #19 (`GDF2(..., method='fixed-widths')` was broken)


  - Add transparent support for using either pandas or dask to read the data table file
  - Simplify field data API: `gdf.get_field_data()` and `gdf.get_fields_data()`


  - Fix #16 - expanded column names not working in gdf2.df_chunked()


  - Initial development



  MIT.


pkgId: 3d1a196f346de7f42fb63723490ceb25728a13c8fd663f1a4653d3af069ba741
name: python-asekuro
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: CLI util to deal with Jupyter Notebooks
url: https://github.com/godatadriven/asekuro
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asekuro-0.1.2-1.src.rpm
checksum_type: sha256
description:
  platform darwin -- Python 3.6.5, pytest-3.6.4, py-1.5.4, pluggy-0.7.1 --
  /Users/coder/path/asekuro/venv/bin/python
  cachedir: ../../../../../tmp/.pytest_cache
  rootdir: /tmp, inifile:
  plugins: nbval-0.9.1
  collected 6 items
  tmp/testnb-test::ipynb::Cell 0 PASSED                                        [ 16%]
  tmp/testnb-test::ipynb::Cell 1 PASSED                                        [ 33%]
  tmp/testnb-test::ipynb::Cell 2 PASSED                                        [ 50%]
  tmp/testnb-test::ipynb::Cell 3 PASSED                                        [ 66%]
  tmp/testnb-test::ipynb::Cell 4 PASSED                                        [ 83%]


pkgId: 18b0a2a2bab455903a88360d3f524ffcc42e425cba331ca2ac96e5a3a56924f4
name: python-asent
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: A python package for flexible and transparent sentiment analysis.
url: https://github.com/KennethEnevoldsen/asent
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asent-0.8.3-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/kennethenevoldsen/asent"><img src="https://github.com/KennethEnevoldsen/asent/blob/main/docs/img/logo_black_font.png?raw=true" width="300" align="right" /></a>



  [![PyPI version](https://badge.fury.io/py/asent.svg)](https://pypi.org/project/asent/)
  [![python version](https://img.shields.io/badge/Python-%3E=3.9-blue)](https://github.com/kennethenevoldsen/asent)
  [![Code style: black](https://img.shields.io/badge/Code%20Style-Black-black)](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html)
  [![github actions pytest](https://github.com/kennethenevoldsen/asent/actions/workflows/tests.yml/badge.svg)](https://github.com/kennethenevoldsen/asent/actions)
  [![github actions docs](https://github.com/kennethenevoldsen/asent/actions/workflows/documentation.yml/badge.svg)](https://kennethenevoldsen.github.io/asent/)
  [![pip downloads](https://img.shields.io/pypi/dm/asent.svg)](https://pypi.org/project/asent/)


  Asent is a rule-based sentiment analysis library for Python made using [SpaCy](https://spacy.io).
  It is inspired by [Vader](https://github.com/cjhutto/vaderSentiment), but uses a more modular ruleset, that allows the user to change e.g. the method for finding negations. Furthermore, it includes visualizers to visualize model predictions, making the model easily interpretable.




  Installing Asent is simple using pip:

  ```
  pip install asent
  ```

  There is no reason to update from GitHub as the version on pypi should always be the same of on GitHub.


  The following shows a simple example of how you can quickly apply sentiment analysis using asent. For more on using asent see the [usage guides].

  ```python
  import spacy
  import asent


  nlp = spacy.blank('en')
  nlp.add_pipe('sentencizer')


  nlp.add_pipe("asent_en_v1")


  text = "I am not very happy, but I am also not especially sad"
  doc = nlp(text)


  print(doc._.polarity)

  ```

  Naturally, a simple score can be quite unsatisfying, thus Asent implements a series of visualizer to interpret the results:
  ```python

  asent.visualize(doc, style="prediction")
  ```

  <img src="https://raw.githubusercontent.com/KennethEnevoldsen/asent/main/docs/img/model_pred.png" width="500" />

  If we want to know why the model comes the result it does we can use the `analysis` style:
  ```python

  asent.visualize(doc[:5], style="analysis")
  ```
  <img src="https://raw.githubusercontent.com/KennethEnevoldsen/asent/main/docs/img/model_analysis.png" width="700" />

  Where the value in the parenthesis (2.7) indicates the human-rating of the word, while
  the value outside the parenthesis indicates the value accounting for the negation.
  Asent also accounts for contrastive conjugations (e.g. but), casing, emoji's and
  punctuations. For more on how the model works check out the [usage guide].



  | Documentation              |                                                                                                                         |
  | -------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
  | 🔧 **[Installation]**       | Installation instructions for Asent                                                                                     |
  | 📚 **[Usage Guides]**       | Guides and instructions on how to use asent and its features. It also gives short introduction to how the models works. |
  | 📰 **[News and changelog]** | New additions, changes and version history.                                                                             |
  | 🎛 **[Documentation]**      | The detailed reference for Asents's API. Including function documentation                                               |

  [Documentation]: https://kennethenevoldsen.github.io/asent/index.html
  [Installation]: https://kennethenevoldsen.github.io/asent/installation.html
  [usage guides]: https://kennethenevoldsen.github.io/asent/introduction.html
  [News and changelog]: https://kennethenevoldsen.github.io/asent/news.html



  | Type                           |                        |
  | ------------------------------ | ---------------------- |
  | 🚨 **FAQ**                      | [FAQ]                  |
  | 🚨 **Bug Reports**              | [GitHub Issue Tracker] |
  | 🎁 **Feature Requests & Ideas** | [GitHub Issue Tracker] |
  | 👩‍💻 **Usage Questions**          | [GitHub Discussions]   |
  | 🗯 **General Discussion**       | [GitHub Discussions]   |


  [FAQ]: https://kennethenevoldsen.github.io/asent/faq.html
  [github issue tracker]: https://github.com/kennethenevoldsen/asent/issues
  [github discussions]: https://github.com/kennethenevoldsen/asent/discussions

rpm_license:
  MIT License  Copyright (c) 2021 Kenneth Enevoldsen  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 69201dcfb6734165fc7b6659e2bce8653dbb5863d45d6ea7f6e1ba5fbced2138
name: python-aserto
arch: src
version: 0.31.2
epoch: 0
release: 1
summary: Aserto API client
url: https://github.com/aserto-dev/aserto-python/tree/HEAD
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aserto-0.31.2-1.src.rpm
checksum_type: sha256
description:
  High-level client interface to Aserto's APIs.


  The client can be used for interacting with Aserto's [Authorizer service](https://docs.aserto.com/docs/authorizer-guide/overview).





  ```sh
  pip install aserto
  ```



  ```sh
  poetry add aserto
  ```



  ```py
  from aserto.client import AuthorizerOptions, Identity
  from aserto.client.authorizer import AuthorizerClient


  client = AuthorizerClient(
      identity=Identity(type="NONE"),
      options=AuthorizerOptions(
          api_key=ASERTO_API_KEY,
          tenant_id=ASERTO_TENANT_ID,
      ),
  )

  result = await client.decision_tree(
      decisions=["visible", "enabled", "allowed"],
      policy_instance_name=ASERTO_POLICY_INSTANCE_NAME,
      policy_instance_label=ASERTO_POLICY_INSTANCE_LABEL,
      policy_path_root=ASERTO_POLICY_PATH_ROOT,
      policy_path_separator="DOT",
  )

  assert result == {
      "GET.your.policy.path": {
          "visible": True,
          "enabled": True,
          "allowed": False,
      },
  }
  ```



  The Directory APIs can be used to interact with the aserto directory services.
  It provides CRUD operations on objects and relations, including bulk import and export.
  The client can also be used to check whether a user has a permission or relation on an object instance.



  You can initialize a directory client as follows:

  ```py
  from aserto.client.directory.v3 import Directory

  ds = Directory(api_key="my_api_key", tenant_id="1234", address="localhost:9292")
  ```

  - `address`: hostname:port of directory service (_required_)
  - `api_key`: API key for directory service (_required_ if using hosted directory)
  - `tenant_id`: Aserto tenant ID (_required_ if using hosted directory)
  - `cert`: Path to the grpc service certificate when connecting to local topaz instance.



  Get a directory object instance with the type and the id, optionally with the object's relations.

  ```py

  user = ds.get_object(object_type="user", object_id="euang@acmecorp.com")


  page = PaginationRequest(size=10)
  while True:
      resp = ds.get_object(object_type="user", object_id="euang@acmecorp.com", with_relations=True, page=page)
      user = resp.result               # The returned object.
      relations_page = resp.relations  # A page of relations.

      if not resp.page.next_token:
          
          break

      
      page.token = resp.page.next_token

  ```



  Similar to `get_object` but can retrieve multiple object instances in a single request.
  ```py
  objects = ds.get_object_many(
      [
          ObjectIdentifier(type="user", id="euan@acmecorp.com"),
          ObjectIdentifier(type="group", id="marketing"),
      ]
  )
  ```



  Get object instances with an object type type pagination info (page size and pagination token).

  ```py
  from aserto.client.directory.v3 import PaginationRequest

  users = ds.get_objects(object_type="user", page=PaginationRequest(size=10))
  ```




  Create an object instance with the specified properties. If an `etag` is specified and is different from the current
  object's etag, the call raises an `ETagMismatchError`.

  ```py

  user = ds.set_object(
      object_type="user",
      object_id="new-user@acmecorp.com",
      display_name="John Doe",
      "properties": {"active": True, "department": "Engineering"},
  }


  user.display_name = "Jane Doe"
  user.properties["title"] = "Senior Engineer"
  updated_user = ds.set_object(object=user)
  ```



  Delete an object instance and optionally its relations, using its type and id:

  ```py

  ds.delete_object(object_type="user", object_id="test-object")


  ds.delete_object(object_type="user", object_id="test-object", with_relations=True)
  ```



  Retrieve a single relation from the directory or raise a `NotFoundError` if no matching relation exists.

  ```py

  relation = ds.get_relation(
      object_type="user",
      relation="manager",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )

  assert relation.object_id


  response = ds.get_relation(
      object_type="user",
      relation="manager",
      subject_type="user",
      subject_id="euang@acmecorp.com",
      with_relations=True,
  )

  assert response.relation.object_id
  assert response.subject.display_name == "Euan Garden"
  assert response.object.properties["department"] == "Sales"

  ```



  Searches the directory for relations matching the specified criteria, optionally including the object and subject
  of each returned relation.

  ```py

  page = PaginationRequest(size=10)

  while True:
      response = ds.get_relations(
          object_type="group",
          "relation"="member",
          "subject_type": "user",
          "subject_id": "euang@acmecorp.com",
          with_objects=True,
          page=page,
      )

      if not response.page.next_token:
          break

      page.token = response.page.next_token
  ```



  Create a new relation.

  ```py
  ds.set_relation(
      object_type="group",
      object_id="admin",
      relation="member",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )
  ```



  Delete a relation.

  ```py
  ds.delete_relation(
      object_type="group",
      object_id="admin",
      relation="member",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )
  ```



  Check if a subject has a given relation or permission on an object.

  ```py
  allowed = ds.check(
      object_type="folder",
      object_id="/path/to/folder",
      relation="can_delete",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )
  ```



  Find subjects that have a given relation to or permission on a specified object.

  ```py
  reponse = ds.find_subjects(
      object_type="folder",
      object_id="/path/to/folder",
      relation="can_delete",
      subject_type="user"
  )

  assert ObjectIdentifier("user", "euang@acmecorp.com") in response.results
  ```



  Find objects that a given subject has a specified relation to or permission on.

  ```py
  reponse = ds.find_objects(
      object_type="folder",
      relation="can_delete",
      subject_type="user"
      subjecct_id="euang@acmecorp.com"
  )

  assert ObjectIdentifier("folder", "/path/to/folder") in response.results
  ```



  Download the directory manifest.

  ```py
  manifest = ds.get_manifest()

  print(manifest.body)    # yaml manifest


  new_manifest = ds.get_manifest(etag=manifest.etag)

  assert new_manifest is None   # the manifest hasn't changed
  ```



  Upload a new directory manifest.

  ```py
  with open("manifest.yaml", "rb") as f:
      manifest = f.read()

  ds.set_manifest(manifest)
  ```



  Bulk-insert objects and/or relations to the directory. Returns a summary of the number of objects/relations affected.

  ```py

  data = [
      Object(type="user", id="test@acmecorp.com"),
      Relation(
          object_type="user",
          object_id="euang@acmecorp.com",
          relation="manager",
          subject_type="user",
          subject_id="test@acmecorp.com",
      ),
  ]

  response = ds.import_data(data)

  assert response.objects.set == 1
  assert response.object.error == 0
  assert response.relations.set == 1
  assert response.relations.error == 0
  ```



  Bulk-retrieve objects and/or relations from the directory.


  ```py
  from aserto.client.directory.v3 import ExportOption, Object, Relation


  for item in ds.export(ExportOption.OPTION_DATA):
      if isinstance(item, Object):
          print("object:", item)
      elif isinstance(item, Relation):
          print("relation:", item)
  ```



  You can initialize an asynchronous directory client as follows:

  ```py
  from aserto.client.directory.v3.aio import Directory

  ds = Directory(api_key="my_api_key", tenant_id="1234", address="localhost:9292")
  ```

  The methods on the async directory have the same signatures as their synchronous counterparts.



  To interact with older instances of the directory service, a v2 client is available with limited functionality.
  The v2 client doesn't support `get_manifest`/`set_manifest`, and `import_data`/`export_data`.

  ```py
  from aserto.client.directory.v2 import Directory
  ds = Directory(api_key="my_api_key", tenant_id="1234", address="localhost:9292")
  ```



  This project is licensed under the MIT license. See the [LICENSE](https://github.com/aserto-dev/aserto-python/blob/main/LICENSE) file for more info.


pkgId: 651c0c816544d2ccb95147120abdd9769c7cb6eb75463baef25e50f870a8db1e
name: python-aserto
arch: src
version: 0.32.0
epoch: 0
release: 1
summary: Aserto API client
url: https://github.com/aserto-dev/aserto-python/tree/HEAD
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aserto-0.32.0-1.src.rpm
checksum_type: sha256
description:
  High-level client interface to Aserto's APIs.


  The client can be used for interacting with Aserto's [Authorizer service](https://docs.aserto.com/docs/authorizer-guide/overview).





  ```sh
  pip install aserto
  ```



  ```sh
  poetry add aserto
  ```



  ```py
  from aserto.client import AuthorizerOptions, Identity
  from aserto.client.authorizer import AuthorizerClient


  client = AuthorizerClient(
      identity=Identity(type="NONE"),
      options=AuthorizerOptions(
          api_key=ASERTO_API_KEY,
          tenant_id=ASERTO_TENANT_ID,
      ),
  )

  result = await client.decision_tree(
      decisions=["visible", "enabled", "allowed"],
      policy_instance_name=ASERTO_POLICY_INSTANCE_NAME,
      policy_instance_label=ASERTO_POLICY_INSTANCE_LABEL,
      policy_path_root=ASERTO_POLICY_PATH_ROOT,
      policy_path_separator="DOT",
  )

  assert result == {
      "GET.your.policy.path": {
          "visible": True,
          "enabled": True,
          "allowed": False,
      },
  }
  ```



  The Directory APIs can be used to interact with the aserto directory services.
  It provides CRUD operations on objects and relations, including bulk import and export.
  The client can also be used to check whether a user has a permission or relation on an object instance.



  You can initialize a directory client as follows:

  ```py
  from aserto.client.directory.v3 import Directory

  ds = Directory(api_key="my_api_key", tenant_id="1234", address="localhost:9292")
  ```

  - `address`: hostname:port of directory service (_required_)
  - `api_key`: API key for directory service (_required_ if using hosted directory)
  - `tenant_id`: Aserto tenant ID (_required_ if using hosted directory)
  - `cert`: Path to the grpc service certificate when connecting to local topaz instance.



  Get a directory object instance with the type and the id, optionally with the object's relations.

  ```py

  user = ds.get_object(object_type="user", object_id="euang@acmecorp.com")


  page = PaginationRequest(size=10)
  while True:
      resp = ds.get_object(object_type="user", object_id="euang@acmecorp.com", with_relations=True, page=page)
      user = resp.result               # The returned object.
      relations_page = resp.relations  # A page of relations.

      if not resp.page.next_token:
          
          break

      
      page.token = resp.page.next_token

  ```



  Similar to `get_object` but can retrieve multiple object instances in a single request.
  ```py
  objects = ds.get_object_many(
      [
          ObjectIdentifier(type="user", id="euan@acmecorp.com"),
          ObjectIdentifier(type="group", id="marketing"),
      ]
  )
  ```



  Get object instances with an object type type pagination info (page size and pagination token).

  ```py
  from aserto.client.directory.v3 import PaginationRequest

  users = ds.get_objects(object_type="user", page=PaginationRequest(size=10))
  ```




  Create an object instance with the specified properties. If an `etag` is specified and is different from the current
  object's etag, the call raises an `ETagMismatchError`.

  ```py

  user = ds.set_object(
      object_type="user",
      object_id="new-user@acmecorp.com",
      display_name="John Doe",
      "properties": {"active": True, "department": "Engineering"},
  }


  user.display_name = "Jane Doe"
  user.properties["title"] = "Senior Engineer"
  updated_user = ds.set_object(object=user)
  ```



  Delete an object instance and optionally its relations, using its type and id:

  ```py

  ds.delete_object(object_type="user", object_id="test-object")


  ds.delete_object(object_type="user", object_id="test-object", with_relations=True)
  ```



  Retrieve a single relation from the directory or raise a `NotFoundError` if no matching relation exists.

  ```py

  relation = ds.get_relation(
      object_type="user",
      relation="manager",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )

  assert relation.object_id


  response = ds.get_relation(
      object_type="user",
      relation="manager",
      subject_type="user",
      subject_id="euang@acmecorp.com",
      with_relations=True,
  )

  assert response.relation.object_id
  assert response.subject.display_name == "Euan Garden"
  assert response.object.properties["department"] == "Sales"

  ```



  Searches the directory for relations matching the specified criteria, optionally including the object and subject
  of each returned relation.

  ```py

  page = PaginationRequest(size=10)

  while True:
      response = ds.get_relations(
          object_type="group",
          "relation"="member",
          "subject_type": "user",
          "subject_id": "euang@acmecorp.com",
          with_objects=True,
          page=page,
      )

      if not response.page.next_token:
          break

      page.token = response.page.next_token
  ```



  Create a new relation.

  ```py
  ds.set_relation(
      object_type="group",
      object_id="admin",
      relation="member",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )
  ```



  Delete a relation.

  ```py
  ds.delete_relation(
      object_type="group",
      object_id="admin",
      relation="member",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )
  ```



  Check if a subject has a given relation or permission on an object.

  ```py
  allowed = ds.check(
      object_type="folder",
      object_id="/path/to/folder",
      relation="can_delete",
      subject_type="user",
      subject_id="euang@acmecorp.com",
  )
  ```



  Find subjects that have a given relation to or permission on a specified object.

  ```py
  reponse = ds.find_subjects(
      object_type="folder",
      object_id="/path/to/folder",
      relation="can_delete",
      subject_type="user"
  )

  assert ObjectIdentifier("user", "euang@acmecorp.com") in response.results
  ```



  Find objects that a given subject has a specified relation to or permission on.

  ```py
  reponse = ds.find_objects(
      object_type="folder",
      relation="can_delete",
      subject_type="user"
      subjecct_id="euang@acmecorp.com"
  )

  assert ObjectIdentifier("folder", "/path/to/folder") in response.results
  ```



  Download the directory manifest.

  ```py
  manifest = ds.get_manifest()

  print(manifest.body)    # yaml manifest


  new_manifest = ds.get_manifest(etag=manifest.etag)

  assert new_manifest is None   # the manifest hasn't changed
  ```



  Upload a new directory manifest.

  ```py
  with open("manifest.yaml", "rb") as f:
      manifest = f.read()

  ds.set_manifest(manifest)
  ```



  Bulk-insert objects and/or relations to the directory. Returns a summary of the number of objects/relations affected.

  ```py

  data = [
      Object(type="user", id="test@acmecorp.com"),
      Relation(
          object_type="user",
          object_id="euang@acmecorp.com",
          relation="manager",
          subject_type="user",
          subject_id="test@acmecorp.com",
      ),
  ]

  response = ds.import_data(data)

  assert response.objects.set == 1
  assert response.object.error == 0
  assert response.relations.set == 1
  assert response.relations.error == 0
  ```



  Bulk-retrieve objects and/or relations from the directory.


  ```py
  from aserto.client.directory.v3 import ExportOption, Object, Relation


  for item in ds.export(ExportOption.OPTION_DATA):
      if isinstance(item, Object):
          print("object:", item)
      elif isinstance(item, Relation):
          print("relation:", item)
  ```



  You can initialize an asynchronous directory client as follows:

  ```py
  from aserto.client.directory.v3.aio import Directory

  ds = Directory(api_key="my_api_key", tenant_id="1234", address="localhost:9292")
  ```

  The methods on the async directory have the same signatures as their synchronous counterparts.



  This project is licensed under the MIT license. See the [LICENSE](https://github.com/aserto-dev/aserto-python/blob/main/LICENSE) file for more info.


pkgId: 9f07d206664419f4559fd04804fe639931c5df5d60d0177486c60ffb60ec935e
name: python-asesurfacefinder
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Machine learned location of chemical adsorbates on high-symmetry surface sites.
url: https://github.com/joegilkes/ASESurfaceFinder
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asesurfacefinder-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Au_fcc111_bridge (5, 5, 1) (h = 2.48, d = 0.44) | Au_fcc111_hcp
  Au_fcc111_bridge (5, 5, 1) (h = 1.42, d = 0.67) | Au_fcc111_ontop
  Au_fcc111_bridge (5, 5, 1) (h = 1.60, d = 0.42) | Au_fcc111_hcp
  Au_fcc111_fcc (5, 5, 1) (h = 2.43, d = 0.52)    | Au_fcc111_bridge
  Au_fcc111_fcc (5, 5, 1) (h = 2.40, d = 0.63)    | Au_fcc111_bridge
  Au_fcc111_fcc (5, 5, 1) (h = 1.98, d = 0.54)    | Au_fcc111_bridge
  ```
  This indicates that either
  1. the training samples were not varied enough to account for the sample space covered by the validation samples,
  2. the validation samples covered too wide an area and overlapped between neighbouring sites, causing samples to be mislabelled,
  3. the training samples accounted for too wide a sample space, causing overlap between neighbouring sites and misclassification.
  In this case, we showed above that it is likely that all of these problems are arising - `SamplePlotter` showed that there was overlap in the training samples between some sites of `Au_fcc111`, and `ads_xy_noise` in the validation samples was even greater, creating mislabelled samples. In a production use case, these parameters should be tweaked such that validation returns no errors while sampling as broad a volume above each adsorption site as possible.

  To predict the high-symmetry adsorption sites and surface facets of real surface/adsorbate systems, these can simply be fed into a trained `SurfaceFinder`.
  Taking an example system of 3 methanol molecules adsorbed to 'fcc' sites of gold FCC{111}, with a free methanol molecule above the surface:
  ![Four methanol molecules on gold FCC{111}](/examples/4MeO_Au_fcc111.svg)
  The adsorbates and gas phase molecule can be separated from the surface and classified by their adsorption sites (or lack thereof) with the `SurfaceFinder.predict()` method:
  ```python
  from ase.io import read
  real_surface_1 = read('examples/4MeO_Au_fcc111.xyz')
  slab, molecules, labels = sf.predict(real_surface_1)
  ```
  This returns three outputs:
  1. `slab`: The clean surface geometry as an `ase.Atoms`, without any adsorbates.
  2. `molecules`: A list of `ase.Atoms` representing the adsorbates and gas phase molecules found on and above the surface respectively.
  3. `labels`: A list of dictionaries corresponding to the entries in `molecules` containing the atoms of the respective adsorbate that are adsorbed onto the surface and their predicted sites.
  For example, given the above system:
  ```python
  for molecule, label in zip(molecules, labels):
      print(molecule, label)
  ```
  ```
  Atoms(symbols='OCH3', pbc=False, tags=...) {0: {'site': 'Au_fcc111_fcc', 'bonded_elem': 'O', 'coordination': 3}}
  Atoms(symbols='OCH3', pbc=False, tags=...) {0: {'site': 'Au_fcc111_fcc', 'bonded_elem': 'O', 'coordination': 3}}
  Atoms(symbols='OCH3', pbc=False, tags=...) {0: {'site': 'Au_fcc111_fcc', 'bonded_elem': 'O', 'coordination': 3}}
  Atoms(symbols='CHOH3', pbc=False, tags=...) {}
  ```
  The first three entries are the adsorbed methanol molecules, correctly classified as being bound to the 'fcc' high-symmetry site on a gold FCC{111} surface. Each molecule's `label` dictionary is keyed by the index of the atom in the corresponding `molecule` which is bound; in the event that a molecule is bound to the surface by multiple atoms, it will contain en entry for each. In this case, all adsorbates are bound by their respective 0th atoms - their oxygens, indicated by the `'bonded_elem'` key.
  Additionally, each `label` also provides the coordination of the adsorption site as detected by ASE's connectivity tools. Since the 'fcc' site sits in between three atoms, this is reflected in the `'coordination'` key.
  The fourth molecule returned is the gas phase methanol, which is not adsorbed onto the surface. This is reflected in its `label` dictionary, which is empty to indicate no atoms are bound.
  A more complex example with different adsorbates bound on a range of sites follows:
  ![A selection of molecules on a range of gold FCC{111} adsorption sites](/examples/CO+H2O+NHCH3_Au_fcc111.svg)
  Running the same prediction workflow reveals carbon monoxide on an 'ontop' site, hydroxide on a 'fcc' site, and methylamine on a 'bridge' site:
  ```python
  real_surface_2 = read('examples/CO+H2O+NHCH3_Au_fcc111.xyz')
  slab, molecules, labels = sf.predict(real_surface_2)
  for molecule, label in zip(molecules, labels):
      print(molecule, label)
  ```
  ```
  Atoms(symbols='CO', pbc=False) {0: {'site': 'Au_fcc111_ontop', 'bonded_elem': 'C', 'coordination': 1}}
  Atoms(symbols='OH', pbc=False) {0: {'site': 'Au_fcc111_fcc', 'bonded_elem': 'O', 'coordination': 3}}
  Atoms(symbols='NHCH3', pbc=False) {0: {'site': 'Au_fcc111_bridge', 'bonded_elem': 'N', 'coordination': 2}}
  ```

  ASESurfaceFinder does not currently contain a nice, clean way of separating *all* adsorbates from surfaces. In the first instance, it searches for a set of per-atom 'tags' in the underlying `ase.Atoms` object (accessed by `atoms.get_tags()`). These are generated by ASE when using its adsorbate-adding functionality, and represent the layer of the surface that each atom is part of - adsorbates are tagged at layer 0, with increasing layer tags indicating increasing depth.
  However, it is unlikely that input surface/adsorbate systems will be tagged like this since if they were generated with ASE, you would already know the sites on which the adsorbates sit. Instead, ASESurfaceFinder currently relies on separation by element. Since it knows which elements the surfaces are made of, it will simply mask these elements off to separate the adsorbates from the surface. A warning will be displayed when this is performed.
  Since the majority of surface/adsorbate systems are organic molecules on metal surfaces, this approach will work most of the time. However, when dealing with surfaces that contain the same elements as adsorbates (e.g. diamond, silica, etc.), this approach will fail. A more concrete approach for adsorbate separation is being developed, but will likely require analysis of the training surfaces as a whole.

rpm_license:
  MIT License  Copyright (c) 2024 Joe Gilkes  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: ed2977d2b836c9ed9e9648e710a2ed1132b5dbe403bcb27b9ab09de0ff17be50
name: python-asf-search
arch: src
version: 8.0.1
epoch: 0
release: 1
summary: Python wrapper for ASF's SearchAPI
url: https://github.com/asfadmin/Discovery-asf_search.git
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asf-search-8.0.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/asf_search.svg)](https://pypi.python.org/pypi/asf_search/)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/asf_search)](https://anaconda.org/conda-forge/asf_search)

  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/asf_search.svg)](https://pypi.python.org/pypi/asf_search/)
  [![PyPI license](https://img.shields.io/pypi/l/asf_search.svg)](https://pypi.python.org/pypi/asf_search/)

  [![CodeFactor](https://www.codefactor.io/repository/github/asfadmin/discovery-asf_search/badge)](https://www.codefactor.io/repository/github/asfadmin/discovery-asf_search)
  [![Github workflow](https://github.com/asfadmin/asf_search/actions/workflows/run-pytest.yml/badge.svg)](https://github.com/asfadmin/Discovery-asf_search/actions/workflows/run-pytest.yml)

  ![CodeCov](https://img.shields.io/codecov/c/github/asfadmin/Discovery-asf_search/master)

  [![Documentation](https://img.shields.io/badge/docs-at_ASF-green)](https://docs.asf.alaska.edu/asf_search/basics/)
  [![Join the chat at https://gitter.im/ASFDiscovery/asf_search](https://badges.gitter.im/ASFDiscovery/asf_search.svg)](https://gitter.im/ASFDiscovery/asf_search?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)


  Python wrapper for the ASF SearchAPI

  ```python
  import asf_search as asf

  results = asf.granule_search(['ALPSRS279162400', 'ALPSRS279162200'])
  print(results)

  wkt = 'POLYGON((-135.7 58.2,-136.6 58.1,-135.8 56.9,-134.6 56.1,-134.9 58.0,-135.7 58.2))'
  results = asf.geo_search(platform=[asf.PLATFORM.SENTINEL1], intersectsWith=wkt, maxResults=10)
  print(results)
  ```



  In order to easily manage dependencies, we recommend using dedicated project environments
  via [Anaconda/Miniconda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html)
  or [Python virtual environments](https://docs.python.org/3/tutorial/venv.html).

  asf_search can be installed into a conda environment with

  ```bash
  conda install -c conda-forge asf_search
  ```

  or into a virtual environment with

  ```bash
  python3 -m pip install asf_search
  ```

  To install pytest/cov packages for testing, along with the minimal packages:

  ```bash
  python3 -m pip install asf_search[test]
  ```



  _Full documentation is available at https://docs.asf.alaska.edu/asf_search/basics/_

  Programmatically searching for ASF data is made simple with asf_search. Several search functions are provided:
  - `geo_search()` Find product info over an area of interest using a WKT string
  - `granule_search()` Find product info using a list of scenes
  - `product_search()` Find product info using a list of products
  - `search()` Find product info using any combination combination of search parameters
  - `stack()` Find a baseline stack of products using a reference scene
  - Additionally, numerous constants are provided to ease the search process

  Additionally, asf_search support downloading data, both from search results as provided by the above search functions, and directly on product URLs. An authenticated session is generally required. This is provided by the `ASFSession` class, and use of one of its three authentication methods:
  - `auth_with_creds('user', 'pass)`
  - `auth_with_token('EDL token')`
  - `auth_with_cookiejar(http.cookiejar)`

  That session should be passed to whichever download method is being called, can be re-used, and is thread safe. Examples:
  ```python
  results = asf_search.granule_search([...])
  session = asf_search.ASFSession()
  session.auth_with_creds('user', 'pass')
  results.download(path='/Users/SARGuru/data', session=session)
  ```
  Alternately, downloading a list of URLs contained in `urls` and creating the session inline:
  ```python
  urls = [...]
  asf_search.download_urls(urls=urls, path='/Users/SARGuru/data', session=ASFSession().auth_with_token('EDL token'))
  ```

  Also note that `ASFSearchResults.download()` and the generic `download_urls()` function both accept a `processes` parameter which allows for parallel downloads.

  Further examples of all of the above can be found in `examples/`






  <table>
    <thead>
      <tr>
        <th>Instance</th>
        <th>Branch</th>
        <th>Description, Instructions, Notes</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>Stable</td>
        <td>stable</td>
        <td>Accepts merges from Working and Hotfixes</td>
      </tr>
      <tr>
        <td>Working</td>
        <td>master</td>
        <td>Accepts merges from Features/Issues and Hotfixes</td>
      </tr>
      <tr>
        <td>Features/Issues</td>
        <td>topic-*</td>
        <td>Always branch off HEAD of Working</td>
      </tr>
      <tr>
        <td>Hotfix</td>
        <td>hotfix-*</td>
        <td>Always branch off Stable</td>
      </tr>
    </tbody>
  </table>

  For an extended description of our workflow, see https://gist.github.com/digitaljhelms/4287848



  We use standard the standard `logging` in our package for output.

  Heres a basic example for hooking into it with your application:

  ```python
  import asf_search as asf
  import logging
  ASF_LOGGER = logging.getLogger("asf_search")
  formatter = logging.Formatter('[ s (s) s:d ] s - s')


  stream_handle = logging.StreamHandler()
  stream_handle.setFormatter(formatter)
  ASF_LOGGER.addHandler(stream_handle)

  file_handle = logging.FileHandler('MyCustomApp.log')
  file_handle.setFormatter(formatter)
  ASF_LOGGER.addHandler(file_handle)

  ASF_LOGGER.setLevel(logging.WARNING)

  ASF_LOGGER.error("This is only a drill. Please do not panic.")


  ```

  For more configure options on `logging`, please visit [their howto page](https://docs.python.org/3/howto/logging.html).


pkgId: de6946f191d8f509529be6f8c161059ba29b08f219da50f22cd84e771740ace1
name: python-asf-tools
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Tools developed by ASF for working with SAR data
url: https://github.com/ASFHyP3/asf-tools
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asf-tools-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI license](https://img.shields.io/pypi/l/asf_tools.svg)](https://pypi.python.org/pypi/asf_tools/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/asf_tools.svg)](https://pypi.python.org/pypi/asf_tools/)
  [![PyPI version](https://img.shields.io/pypi/v/asf_tools.svg)](https://pypi.python.org/pypi/asf_tools/)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/asf_tools)](https://anaconda.org/conda-forge/asf_tools)
  [![Conda platforms](https://img.shields.io/conda/pn/conda-forge/asf_tools)](https://anaconda.org/conda-forge/asf_tools)

  [![DOI](https://zenodo.org/badge/295506894.svg)](https://zenodo.org/badge/latestdoi/295506894)

  `asf_tools` is a Python package for working with Synthetic Aperture Radar (SAR) data.
  It was designed for working with datasets generated by
  [HyP3](https://hyp3-docs.asf.alaska.edu/), but several of the tools have the
  potential to be used with a variety of rasters, including non-SAR datasets.




  In order to easily manage dependencies, we recommend using dedicated project
  environments via [Anaconda/Miniconda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html).
  It is also possible to use [Python virtual environments](https://docs.python.org/3/tutorial/venv.html),
  but installation of non-python dependencies (e.g., `gdal`) can be challenging.

  `asf_tools` can be installed into a conda environment with:

  ```
  conda install -c conda-forge asf_tools
  ```

  or into a virtual environment with:

  ```
  python -m pip install asf_tools
  ```



  We also publish a [Docker](https://docs.docker.com/get-started/) image for `asf_tools`, with all the dependencies
  pre-installed, to the GitHub Container Registry:
  <https://github.com/ASFHyP3/asf-tools/pkgs/container/asf-tools>.

  You can pull an image with the latest released version of `asf_tools`  with the command:
  ```
  docker pull ghcr.io/asfhyp3/asf-tools:latest
  ```

  Or, the development version with:
  ```
  docker pull ghcr.io/asfhyp3/asf-tools:test
  ```

  And then run the container with:
  ```
  docker run --rm -it ghcr.io/asfhyp3/asf-tools:latest
  ```
  which will drop you into a `bash` shell inside the container with an active `asf-tools` conda environment.

  To move data between your local (host) machine and the container, you can mount a
  [volume](https://docs.docker.com/storage/volumes/) with:
  ```
  docker run --rm -it -v /path/to/data:/home/conda/data ghcr.io/asfhyp3/asf-tools:latest
  ```





  The `make_composite` tool allows you to create a local-resolution-weighted composite
  from a set of Sentinel-1 RTC products ([D. Small, 2012](https://doi.org/10.1109/IGARSS.2012.6350465)).
  It is intended to be used with RTC products generated by [ASF HyP3](https://hyp3-docs.asf.alaska.edu/using/vertex).

  You will need to request RTC products using the `Include Scattering Area` option,
  then download and unzip them into an empty directory.

  To generate a composite of the co-polarization images, navigate to the directory
  containing the unzipped RTC products and run:
  ```
  make_composite VV-composite */*VV.tif
  ```

  To generate a composite of the cross-polarization images, navigate to the directory
  containing the unzipped RTC products and run:
  ```
  make_composite VH-composite */*VH.tif
  ```


  Because the imagery has been radiometrically terrain corrected (RTC), geometric and
  radiometric distortions have been removed from the files to be composited. One the
  strong points of LRW composites is that you combine both ascending and descending
  datatakes into a single product. In this manner no layover or shadow masks are
  required - what is shadowed on an ascending pass is visible in a descending pass
  and vice-versa. Thus, not only is it possible to combine ascending and descending,
  but it is highly encouraged. Using many datatakes from both the ascending and
  descending satellite passes will make the best composites possible.


  In an LRW composite, each satellite pass contributes to creating the output pixels.
  The amount of this contribution is scaled by the inverse of the scattering area used
  during terrain correction (thus the need for requesting the area map option of HyP3 RTC).
  The inverse of the surface scattering area, also referred to as local resolution,
  is multiplied by each pixel's backscatter value. The results of all of the images
  covering any single pixel are then summed. This total is then divided by the sum
  of the weights used to get the output average backscatter.



  >[!WARNING]
  > The HydroSAR codes (`flood_map`, `water_map` and `hand` modules) are being
  > moved to the [HydroSAR project repository](https://github.com/fjmeyer/hydrosar)
  > and will be provided in a new pip/conda installable package `hydrosar`.
  >
  > The `asf_tools.hydrosar` subpackage will be removed in a future release.

  The `water_map` tool allows you to create a surface water extent map from a Sentinel-1
  dual-pol (VV+VH) RTC product. It is intended to be used with RTC products generated by
  [ASF HyP3](https://hyp3-docs.asf.alaska.edu/using/vertex).

  Additionally, a HAND (height above nearest drainage) GeoTIFF that is pixel aligned to
  the RTC images is required, and preferably derived from the same DEM used to correct
  the RTC images -- the quality of the HAND used is directly tied to the quality of the
  output water extent map.

  To make a water extent map, run:
  ```
  water_map [OUT_RASTER] [VV_RASTER] [VH_RASTER] [HAND_RASTER]
  ```

  For more information and to see the options available, see:
  ```
  water_map --help
  ```

  For details on the algorithm see the `asf_tools.water_map.make_water_map` docstring.
  <!-- FIXME: Link to API reference on our docs page! -->



  >[!WARNING]
  > The HydroSAR codes (`flood_map`, `water_map` and `hand` modules) are being
  > moved to the [HydroSAR project repository](https://github.com/fjmeyer/hydrosar)
  > and will be provided in a new pip/conda installable package `hydrosar`.
  >
  > The `asf_tools.hydrosar` subpackage will be removed in a future release.

  The `flood_map` tool allows you to create an estimated flood depth map from the surface
  water extent map created by the `water_map` tool.

  Additionally, a HAND (height above nearest drainage) GeoTIFF that is pixel aligned to
  the surface water extent map is required. An ideal candidate is the HAND image created
  by the `water_map` tool.

  To make a flood depth map, run:
  ```
  flood_map [OUT_RASTER] [SURFACE_WATER_MAP] [HAND_RASTER]
  ```

  For more information and to see the options available, see:
  ```
  flood_map --help
  ```

  For details on the algorithm see the `asf_tools.flood_map.make_flood_map` docstring.



  The `asf_tools.watermasking` sub-package allows you to create a watermasking dataset
  over an arbitrary ROI using OpenStreetMap and ESA WorldCover data.
  Note, this program requires `osmium-tool`. See the [watermasking subpackage readme](https://github.com/ASFHyP3/asf-tools/blob/main/src/asf_tools/watermasking/README.md)
  for more information on setup and usage.


pkgId: d21e6a330f8b9518b7c7f5e7349e93d90c30c033d2d9ba9b6cad1b9f0a968fec
name: python-asfpy
arch: src
version: 0.52
epoch: 0
release: 1
summary: ASF Common Python Methods
url: https://github.com/apache/infrastructure-asfpy/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asfpy-0.52-1.src.rpm
checksum_type: sha256
description:
  This is a common set of functions used by the ASF Infrastructure team such as libraries for sending email, ldap management and generic process daemonization.


pkgId: 0da1255c817e6dcdc07fa56685050f3119952e0b6b57f52422579fdf376af5ba
name: python-asfpy-phd
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A collection of Python scripts for the Application Statement Feedback Program's logistics needs
url: https://github.com/asfpteam/asfpy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asfpy-phd-0.6.1-1.src.rpm
checksum_type: sha256
description:
  A collection of Python scripts for the Application Statement Feedback Program's
  logistic needs.

  <!-- toc -->

  - [Installation](#installation)
  - [Usage](#usage)
  - [Contributing](#contributing)
    * [Packaging](#packaging)
    * [Authors](#authors)

  <!-- tocstop -->



  This package requires Python 3.6+ and pip 20+, and recommends using the Python
  3.8 runtime. To install, run

  ```
  pip install asfpy-phd
  ```

  You can find further installation instructions and versioned distributions at https://pypi.org/project/asfpy-phd/.



  Current usage requires importing the namespace directly:

  ```
  from asfpy import asfpy
  ```

  This can then be used to work with internal methods. For instance:

  ```
  asfpy.allocate(applicants, editors)
  ```

  will run the allocation algorithm, which returns a list of matchings between
  applicants and two editors each. If two editors cannot be matched, the
  applicant remains in an unmatched list.





  Install via pip: `setuptools`, `wheel` and `twine`. Update version number in
  `setup.py` before creating a new distribution.

  From root of project, run `python setup.py sdist bdist_wheel` to create
  distribution in `dist/*`. Then run `twine upload dist/*`.



  Ari Dyckovsky


pkgId: 84ac610cddc34a9d97ad37f5680a381b3c1fd925782ca097b1558dadc164c6de
name: python-asfquart
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: ASF Quart Framework
url: https://pypi.org/project/asfquart/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asfquart-0.1.8-1.src.rpm
checksum_type: sha256
description:
    
    ![Unit Tests](https://github.com/apache/infrastructure-asfquart/actions/workflows/unit-tests.yml/badge.svg)

    This repository will house the future [Quart](https://github.com/pallets/quart/) framework for use
    within ASF web applications. Nothing much to see here yet...

    For more detailed documentation, see the [documentation page](docs/readme.md).



  ~~~python
  import asfquart
  from asfquart.auth import Requirements as R

  def my_app():
      
      app = asfquart.construct("my_app_service")

      @app.route("/")
      async def homepage():
          return "Hello!"

      @app.route("/secret")
      @asfquart.auth.require(R.committer)
      async def secret_page():
        return "Secret stuff!"

      asfquart.APP.run(port=8000)


  if __name__ == "__main__":
      my_app()

  ~~~


pkgId: 315c1ee7ceb7d0913e063266dfcfbe8302708a5588afb77f2866ddef467d3602
name: python-asgarde
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Allows simplifying error handling with Apache Beam
url: https://github.com/tosun-si/pasgarde
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgarde-0.16.0-1.src.rpm
checksum_type: sha256
description:
  ![Logo](asgarde_logo_small.gif)



  This module allows simplifying error handling with Apache Beam Python.



  | Asgarde      | Beam |
  | -----------  | ----------- |
  | 0.16.0       | \>= 2.37.0   |



  The project is hosted on PyPi repository.\
  You can install it with all the build tools compatibles with PyPi and pip.





  ```bash
  pip install asgarde==0.16.0
  ```



  requirements.txt file

  ```text
  asgarde==0.16.0
  ```

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



  PipFile

  ```text
  [[source]]
  url = "https://pypi.org/simple"
  verify_ssl = true
  name = "pypi"

  [packages]
  asgarde = "==0.16.0"

  [requires]
  python_version = "3.8"
  ```

  ```bash
  pipenv shell

  pipenv install
  ```

  - pipenv shell creates a virtual env
  - `pipenv install` installs all the packages specified in the Pipfile
  - A PipFile.lock is generated with a hash on installed packages

  https://pipenv.pypa.io/en/latest/




  The following example shows error handling in each step with usual Beam code.

  ```python
  @dataclass
  class TeamInfo:
      name: str
      country: str
      city: str

  @dataclass
  class Failure:
      pipeline_step: str
      input_element: str
      exception: Exception

  team_names = [
      'PSG',
      'OL',
      'Real',
      'ManU'
  ]

  team_countries = {
      'PSG': 'France',
      'OL': 'France',
      'Real': 'Spain',
      'ManU': 'England'
  }

  team_cities = {
      'PSG': 'Paris',
      'OL': 'France',
      'Real': 'Madrid',
      'ManU': 'Manchester'
  }

  class MapToTeamWithCountry(DoFn):

      def process(self, element, *args, **kwargs):
          try:
              team_name: str = element

              yield TeamInfo(
                  name=team_name,
                  country=team_countries[team_name],
                  city=''
              )
          except Exception as err:
              failure = Failure(
                  pipeline_step="Map 1",
                  input_element=element,
                  exception=err
              )

              yield pvalue.TaggedOutput(FAILURES, failure)


  class MapToTeamWithCity(DoFn):

      def process(self, element, *args, **kwargs):
          try:
              team_info: TeamInfo = element
              city: str = team_cities[team_info.name]

              yield TeamInfo(
                  name=team_info.name,
                  country=team_info.country,
                  city=city
              )
          except Exception as err:
              failure = Failure(
                  pipeline_step="Map 2",
                  input_element=element,
                  exception=err
              )

              yield pvalue.TaggedOutput(FAILURES, failure)


  class FilterFranceTeams(DoFn):

      def process(self, element, *args, **kwargs):
          try:
              team_info: TeamInfo = element

              if team_info.country == 'France':
                  yield element
          except Exception as err:
              failure = Failure(
                  pipeline_step="Filter France teams",
                  input_element=element,
                  exception=err
              )

              yield pvalue.TaggedOutput(FAILURES, failure)


  input_teams: PCollection[str] = p | 'Read' >> beam.Create(team_names)

  outputs_map1, failures_map1 = (input_teams | 'Map to team with country' >> ParDo(MapToTeamWithCountry())
                                 .with_outputs(FAILURES, main='outputs'))

  outputs_map2, failures_map2 = (outputs_map1 | 'Map to team with city' >> ParDo(MapToTeamWithCity())
                                 .with_outputs(FAILURES, main='outputs'))

  outputs_filter, failures_filter = (outputs_map2 | 'Filter France teams' >> ParDo(FilterFranceTeams())
                                     .with_outputs(FAILURES, main='outputs'))

  all_failures = (failures_map1, failures_map2, failures_filter) | 'All Failures PCollections' >> beam.Flatten()
  ```

  This example starts with an input `PCollection` containing team names.\
  Then 3 operations and steps are applied : 2 maps and 1 filter.

  For each operation a custom `DoFn` class is proposed and must override `process` function containing the
  transformation logic.\
  A `try except bloc` is added to catch all the possible errors.\
  In the `Except` bloc a `Failure` object is built with input element and current exception. This object is then added on
  a `tuple tag` dedicated to errors.\
  This `tag` mechanism allows having multi sink in the pipeline and a dead letter queue for failures.

  There are some inconveniences :
  - We have to repeat many technical codes and same logic like `try except bloc`, `tuple tags`,
  `failure logic` and all this logic can be centralized.
  - If we want to intercept all the possible errors in the pipeline, we have to repeat the recovery of output and failure in each step.
  - All the failures `PCollection` must be concatenated at end.
  - The code is verbose.

  The repetition of technical codes is error-prone and less maintainable.




  ```python

  input_teams: PCollection[str] = p | 'Read' >> beam.Create(team_names)

  result = (CollectionComposer.of(input_teams)
              .map('Map with country', lambda tname: TeamInfo(name=tname, country=team_countries[tname], city=''))
              .map('Map with city', lambda tinfo: TeamInfo(name=tinfo.name, country=tinfo.country, city=team_cities[tinfo.name]))
              .filter('Filter french team', lambda tinfo: tinfo.country == 'France'))

  result_outputs: PCollection[TeamInfo] = result.outputs
  result_failures: PCollection[Failure] = result.failures
  ```



  Asgarde proposes a `CollectionComposer` wrapper class instantiated from a `PCollection`.



  The `CollectionComposer` class exposes the following operators : `map`, `flatMap` and `filter`.

  These classical operators takes a function, the implementation can be :
  - A `lambda expression`
  - A `method` having the same signature of the expected `function`



  Behind the scene, for each step the `CollectionComposer` class adds `try except` bloc and `tuple tag logic` with output
  and failure `sinks`.

  The bad sink is based on a `Failure` object proposed by the library :

  ```python
  @dataclass
  class Failure:
      pipeline_step: str
      input_element: str
      exception: Exception
  ```

  This object contains the current pipeline step name, input element with string form and current exception.

  Input element on Failure object are built following these rules :
  - If the current element in the `PCollection` is a `dict`, the Json string form of this `dict` is retrieved
  - For all others types, the `string` form of object is retrieved. If developers want to bring their own serialization
  logic, they have to override `__str__` method in the object, example for a `dataclass` :

  ```python
  import dataclasses
  import json
  from dataclasses import dataclass

  @dataclass
  class Team:
      name: str

      def __str__(self) -> str:
          return json.dumps(dataclasses.asdict(self))
  ```



  The `CollectionComposer` class after applying and chaining different operations, returns a `tuple` with :
  - Output `PCollection`
  - Failures `PCollection`

  ```python
  result = (CollectionComposer.of(input_teams)
              .map('Map with country', lambda tname: TeamInfo(name=tname, country=team_countries[tname], city=''))
              .map('Map with city', lambda tinfo: TeamInfo(name=tinfo.name, country=tinfo.country, city=team_cities[tinfo.name]))
              .filter('Filter french team', lambda tinfo: tinfo.country == 'France'))

  result_outputs: PCollection[TeamInfo] = result.outputs
  result_failures: PCollection[Failure] = result.failures
  ```



  `Asgarde` allows applying transformations with error handling and passing `side inputs`.\
  The syntax is the same as usual Beam pipeline with `AsDict` or `AsList` passed as function parameters.

  ```python
  def to_team_with_city(self, team_name: str, team_countries: Dict[str, str]) -> TeamInfo:
      return TeamInfo(name=team_name, country=team_countries[team_name], city='')

  team_countries = {
      'PSG': 'France',
      'OL': 'France',
      'Real': 'Spain',
      'ManU': 'England'
  }


  countries_side_inputs = p | 'Countries' >> beam.Create(team_countries)


  result = (CollectionComposer.of(input_teams)
              .map('Map with country', self.to_team_with_city, team_countries=AsDict(countries_side_inputs))
              .map('Map with city', lambda ti: TeamInfo(name=ti.name, country=ti.country, city=team_cities[ti.name]))
              .filter('Filter french team', lambda ti: ti.country == 'France'))

  result_outputs: PCollection[str] = result.outputs
  result_failures: PCollection[Failure] = result.failures
  ```



  `Asgarde` allows interacting with `DoFn` lifecycle while chaining transformation with error handling, example :

  ```python
  (CollectionComposer.of(input_teams)
       .map('Map to Team info',
            input_element_mapper=lambda team_name: TeamInfo(name=team_name, country='test', city='test'),
            setup_action=lambda: print('Setup action'),
            start_bundle_action=lambda: print('Start bundle action'),
            finish_bundle_action=lambda: print('Finish bundle action'),
            teardown_action=lambda: print('Teardown action'))
       )
  ```

  The `map` and `flat_map` methods of `CollectionComposer` class propose the following functions to interact with
  `DoFn` lifecycle :
  - setup_action
  - start_bundle_action
  - finish_bundle_action
  - teardown_action

  These functions take a `function` without input parameter and return `None`, it corresponds to an action executed
  in the dedicated lifecycle method :

  https://beam.apache.org/documentation/transforms/python/elementwise/pardo/



  `Asgarde` presents the following advantages :
  - Simplifies error handling with less code and more expressive and concise code
  - No need to repeat same technical code for error handling like `try except` bloc, `tuple tags` and concatenation of all the pipeline failures
  - Allows interacting with Beam lifecycle while chaining the transformation and error handling


pkgId: 3702562f97d7c6627e50535e147146927009af4fc235d739d5dd42e76bf9d0ad
name: python-asgardpy
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Gammapy-based pipeline for easy joint analysis of different gamma-ray datasets
url: https://github.com/chaimain/asgardpy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgardpy-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/chaimain/asgardpy/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/chaimain/asgardpy/actions?query=branch%3Amain) [![codecov](https://codecov.io/gh/chaimain/asgardpy/branch/main/graph/badge.svg?token=0XEI9W8AKJ)](https://codecov.io/gh/chaimain/asgardpy) [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/chaimain/asgardpy/badges/quality-score.png?b=main)](https://scrutinizer-ci.com/g/chaimain/asgardpy/?branch=main) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8106369.svg)](https://doi.org/10.5281/zenodo.8106369) ![PyPI](https://img.shields.io/pypi/v/asgardpy?label=pypi%20asgardpy) [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7699/badge)](https://bestpractices.coreinfrastructure.org/projects/7699) [![gammapy](https://img.shields.io/badge/powered%20by-gammapy-orange.svg?style=flat)](https://www.gammapy.org/) [![astropy](http://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat)](https://www.astropy.org/)
  'User-friendly' configuration-centred pipeline built over [Gammapy](https://github.com/gammapy/gammapy) to allow for easy simultaneous analysis of various datasets of different formats.
  Example: 3D Fermi-LAT (with various source models in the Region of Interest stored in XML file) + 1D energy-dependent directional cuts MAGIC/LST [``PointSkyRegion`` geometry for ``ON`` region] + 1D global directional cut VERITAS [``CircleSkyRegion`` geometry for ``ON`` region].
  Follow the documentation at https://asgardpy.readthedocs.io/en/latest/ for the main functionality of this pipeline.
  Follow the [Gammapy v1.2](https://docs.gammapy.org/1.2/) documentation for understanding the core Gammapy objects.
  The various Data Levels	used here follow the descriptions suggested by [GADF v0.3](https://gamma-astro-data-formats.readthedocs.io/en/latest/) and [CTAO](https://www.ctao.org/) Data Model.

  For requiring support only for [Gammapy v1.1](https://docs.gammapy.org/1.1/), one may follow the latest Hotfix release [v0.4.4](https://github.com/chaimain/asgardpy/tree/v0.4.4) which benefits from the correct usage of getting EBL-deabsorbed data products as included in [v0.5.0](https://github.com/chaimain/asgardpy/tree/v0.5.0). This can be done by using
  ```bash
  git fetch --tags
  git switch -c tags/v0.4.4
  ```
  For creating a conda environment, for this Hotfix release, one can use
  ```bash
  conda env create -f environment_0.4.4.yml
  ```
  and in general, for the latest release,
  ```bash
  conda env create -f environment.yml
  ```
  This method was included after v0.5.0, and for earlier (<v0.4.4) releases, one can simply use the gammapy conda environment and install asgardpy on top of it.

  The pipeline was developed with first testing with Fermi-LAT ([enrico](https://enrico.readthedocs.io/en/latest/) and [fermipy](https://fermipy.readthedocs.io/en/latest/)) files and LST-1 ([cta-lstchain](https://cta-observatory.github.io/cta-lstchain/)) DL3 files (with energy-dependent and global directional cuts) for point-like sources.
  The pipeline can be further expanded to support more types of DL3 files of gamma-ray instruments.

  An example of configuration file that can be used with asgardpy can be found at ``asgardpy/config/template.yaml``
  For working with some public data to check the pipeline functionality, one should first download the public dataset available with Gammapy as indicated in [Gammapy v1.2 Introduction](https://docs.gammapy.org/1.2/getting-started/index.html) and then run the ``scripts/download_asgardpy_data.sh`` script to add datasets for the full usage of the pipeline.
  Examples of usage of Asgardpy is shown in jupyter [notebooks](https://github.com/chaimain/asgardpy/tree/main/notebooks).

  If you use Asgardpy in a publication, please cite the exact version you used from Zenodo _Cite_ as https://doi.org/10.5281/zenodo.8106369

  Pipeline generated based on the template by [python-package-template](https://github.com/allenai/python-package-template) with additional standards being followed -
  - [PEP 517](https://peps.python.org/pep-0517)
  - [PEP 518](https://peps.python.org/pep-0518/)
  - [PyPA specs following PEP 621](https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#declaring-project-metadata)
  - [PEP 660](https://peps.python.org/pep-0660/)


pkgId: f347e1eed010218c925b92918bbe93694444b2f4804ef6182d083cf0683aff35
name: python-asgi-csrf
arch: src
version: 0.10
epoch: 0
release: 1
summary: ASGI middleware for protecting against CSRF attacks
url: https://github.com/simonw/asgi-csrf
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi-csrf-0.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/asgi-csrf.svg)](https://pypi.org/project/asgi-csrf/)
  [![Changelog](https://img.shields.io/github/v/release/simonw/asgi-csrf?include_prereleases&label=changelog)](https://github.com/simonw/asgi-csrf/releases)
  [![codecov](https://codecov.io/gh/simonw/asgi-csrf/branch/main/graph/badge.svg)](https://codecov.io/gh/simonw/asgi-csrf)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/simonw/asgi-csrf/blob/main/LICENSE)

  ASGI middleware for protecting against CSRF attacks



      pip install asgi-csrf



  See the [OWASP guide to Cross Site Request Forgery (CSRF)](https://owasp.org/www-community/attacks/csrf) and their [Cross-Site Request Forgery (CSRF) Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html).

  This middleware implements the [Double Submit Cookie pattern](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#double-submit-cookie), where a cookie is set that is then compared to a `csrftoken` hidden form field or a `x-csrftoken` HTTP header.



  Decorate your ASGI application like this:

  ```python
  from asgi_csrf import asgi_csrf
  from .my_asgi_app import app


  app = asgi_csrf(app, signing_secret="secret-goes-here")
  ```

  The middleware will set a `csrftoken` cookie, if one is missing. The value of that token will be made available to your ASGI application through the `scope["csrftoken"]` function.

  Your application code should include that value as a hidden form field in any POST forms:

  ```html
  <form action="/login" method="POST">
      ...
      <input type="hidden" name="csrftoken" value="{{ request.scope.csrftoken() }}">
  </form>
  ```

  Note that `request.scope["csrftoken"]()` is a function that returns a string. Calling that function also lets the middleware know that the cookie should be set by that page, if the user does not already have that cookie.

  If the cookie needs to be set, the middleware will add a `Vary: Cookie` header to the response to ensure it is not incorrectly cached by any CDNs or intermediary proxies.

  The middleware will return a 403 forbidden error for any POST requests that do not include the matching `csrftoken` - either in the POST data or in a `x-csrftoken` HTTP header (useful for JavaScript `fetch()` calls).

  The `signing_secret` is used to sign the tokens, to protect against subdomain vulnerabilities.

  If you do not pass in an explicit `signing_secret` parameter, the middleware will look for a `ASGI_CSRF_SECRET` environment variable.

  If it cannot find that environment variable, it will generate a random secret which will persist for the lifetime of the server.

  This means that if you do not configure a specific secret your user's `csrftoken` cookies will become invalid every time the server restarts! You should configure a secret.



  By default this middleware only sets the `csrftoken` cookie if the user encounters a page that needs it - due to that page calling the `request.scope["csrftoken"]()` function, for example to populate a hidden field in a form.

  If you would like the middleware to set that cookie for any incoming request that does not already provide the cookie, you can use the `always_set_cookie=True` argument:

  ```python
  app = asgi_csrf(app, signing_secret="secret-goes-here", always_set_cookie=True)
  ```



  The middleware can be configured with several options to control how the CSRF cookie is set:

  ```python
  app = asgi_csrf(
      app,
      signing_secret="secret-goes-here",
      cookie_name="csrftoken",
      cookie_path="/",
      cookie_domain=None,
      cookie_secure=False,
      cookie_samesite="Lax"
  )
  ```

  - `cookie_name`: The name of the cookie to set. Defaults to `"csrftoken"`.
  - `cookie_path`: The path for which the cookie is valid. Defaults to `"/"`, meaning the cookie is valid for the entire domain.
  - `cookie_domain`: The domain for which the cookie is valid. Defaults to `None`, which means the cookie will only be valid for the current domain.
  - `cookie_secure`: If set to `True`, the cookie will only be sent over HTTPS connections. Defaults to `False`.
  - `cookie_samesite`: Controls how the cookie is sent with cross-site requests. Can be set to `"Strict"`, `"Lax"`, or `"None"`. Defaults to `"Lax"`.



  If the request includes an `Authorization: Bearer ...` header, commonly used by OAuth and JWT authentication, the request will not be required to include a CSRF token. This is because browsers cannot send those headers in a context that can be abused.

  If the request has no cookies at all it will be allowed through, since CSRF protection is only necessary for requests from authenticated users.



  If you have paths that should always be protected even without cookies - your login form for example (to avoid [login CSRF](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#login-csrf) attacks) you can protect those paths by passing them as the ``always_protect`` parameter:

  ```python
  app = asgi_csrf(
      app,
      signing_secret="secret-goes-here",
      always_protect={"/login"}
  )
  ```



  There may be situations in which you want to opt-out of CSRF protection even for authenticated POST requests - this is often the case for web APIs for example.

  The `skip_if_scope=` parameter can be used to provide a callback function which is passed an ASGI scope and returns `True` if CSRF protection should be skipped for that request.

  This example skips CSRF protection for any incoming request where the request path starts with `/api/`:

  ```python
  def skip_api_paths(scope)
      return scope["path"].startswith("/api/")

  app = asgi_csrf(
      app,
      signing_secret="secret-goes-here",
      skip_if_scope=skip_api_paths
  )
  ```



  By default, when a CSRF token is missing or invalid, the middleware will return a 403 Forbidden response page with a short error message.

  You can customize this behavior by passing a `send_csrf_failed` function to the middleware. This function should accept the ASGI `scope` and `send` functions, and the `message_id` of the error that occurred.

  The `message_id` will be an integer representing an item from the `asgi_csrf.Errors` enum.

  This example shows how you could customize the error message based on that `message_id`:

  ```python
  async def custom_csrf_failed(scope, send, message_id):
      assert scope["type"] == "http"
      await send(
          {
              "type": "http.response.start",
              "status": 403,
              "headers": [[b"content-type", b"text/html; charset=utf-8"]],
          }
      )
      await send(
          {
              "type": "http.response.body",
              "body": {
                  Errors.FORM_URLENCODED_MISMATCH: "custom form-urlencoded error",
                  Errors.MULTIPART_MISMATCH: "custom multipart error",
                  Errors.FILE_BEFORE_TOKEN: "custom file before token error",
                  Errors.UNKNOWN_CONTENT_TYPE: "custom unknown content type error",
              }
              .get(message_id, "")
              .encode("utf-8"),
          }
      )


  app = asgi_csrf(
      app,
      signing_secret="secret-goes-here",
      send_csrf_failed=custom_csrf_failed
  )
  ```


pkgId: 2157f5b873172c4068e533088924cecf39a24f6a16940f642fd682c950dc1b1c
name: python-asgi-idempotency-header
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Enable idempotent operations for your endpoints.
url: https://github.com/snok/asgi-idempotency-header
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi-idempotency-header-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/sondrelg/asgi-idempotency-header/actions/workflows/test.yml/badge.svg)](https://github.com/sondrelg/asgi-idempotency-header/actions/workflows/test.yml)
  [![pypi](https://img.shields.io/pypi/v/asgi-idempotency-header.svg)](https://pypi.org/project/drf-openapi-tester/)
  [![python-versions](https://img.shields.io/badge/python-3.8%2B-blue)](https://pypi.org/project/asgi-idempotency-header)
  [![codecov](https://codecov.io/gh/sondrelg/asgi-idempotency-header/branch/main/graph/badge.svg?token=UOJTCSY8H7)](https://codecov.io/gh/sondrelg/asgi-idempotency-header)



  A middleware for making endpoints idempotent.

  The purpose of the middleware is to guarantee that execution of mutating endpoints happens exactly once,
  regardless of the number of requests.
  We achieve this by caching responses, and returning already-saved responses to the user on repeated requests.
  Responses are only cached when an idempotency-key HTTP header is present, so clients must opt-into this behaviour.
  Additionally, only configured HTTP methods (by default, `POST` and `PATCH`) that return JSON payloads are cached and replayed.

  This is largely modelled after [stripe' implementation](https://stripe.com/docs/api/idempotent_requests).

  The middleware is compatible with both [Starlette](https://github.com/encode/starlette)
  and [FastAPI](https://github.com/tiangolo/fastapi) apps.



  ```
  pip install asgi-idempotency-header
  ```



  Add the middleware to your app like this:

  ```python
  from fastapi import FastAPI

  from idempotency_header_middleware import IdempotencyHeaderMiddleware
  from idempotency_header_middleware.backends import RedisBackend


  backend = RedisBackend(redis=redis)

  app = FastAPI()
  app.add_middleware(IdempotencyHeaderMiddleware(backend=backend))
  ```

  or like this:

  ```python
  from fastapi import FastAPI
  from fastapi.middleware import Middleware

  from idempotency_header_middleware import IdempotencyHeaderMiddleware
  from idempotency_header_middleware.backends import RedisBackend


  backend = RedisBackend(redis=redis)

  app = FastAPI(
      middleware=[
          Middleware(
              IdempotencyHeaderMiddleware,
              backend=backend,
          )
      ]
  )
  ```

  If you're using `Starlette`, just substitute `FastAPI` for `Starlette` and it should work the same.



  The middleware takes a few arguments. A full example looks like this:

  ```python
  from aioredis import from_url

  from idempotency_header_middleware import IdempotencyHeaderMiddleware
  from idempotency_header_middleware.backends import RedisBackend


  redis = from_url(redis_url)
  backend = RedisBackend(redis=redis)

  IdempotencyHeaderMiddleware(
      backend,
      idempotency_header_key='Idempotency-Key',
      replay_header_key='Idempotent-Replayed',
      enforce_uuid4_formatting=False,
      expiry=60 * 60 * 24,
      applicable_methods=['POST', 'PATCH']
  )
  ```

  The following section describes each argument:



  ```python
  from idempotency_header_middleware.backends import RedisBackend, MemoryBackend

  backend: Union[RedisBackend, MemoryBackend]
  ```

  The backend is the only required argument, as it defines **how** and **where** to store a response.

  The package comes with an [aioredis](https://github.com/aio-libs/aioredis-py) backend implementation, and a
  memory-backend for testing.

  Contributions for more backends are welcomed, and configuring a custom backend is pretty simple - just take a look at
  the existing ones.



  ```python
  idempotency_header_key: str = 'Idempotency-Key'
  ```

  The idempotency header key is the header value to check for. When present, the middleware will be used if the HTTP
  method is in the [applicable methods](#applicable-methods).

  The default value is `"Idempotency-Key"`, but it can be defined as any string.



  ```python
  replay_header_key: str = 'Idempotent-Replayed'
  ```

  The replay header is added to replayed responses. It provides a way for the client to tell whether the action was
  performed for the first time or not.



  ```python
  enforce_uuid4_formatting: bool = False
  ```

  Convenience option for stricter header value validation.

  Clients can technically set any value they want in their header,
  but the shorter the key value is, the higher the risk of value-collisions is from other users.
  If two users accidentally send in the same header value for what's meant to be two separate requests,
  the middleware will interpret them as the same.

  By enabling this option, you can force users to use UUIDs as header values, and pretty much eliminate this risk.

  When validation fails, a 422 response is returned from the middleware, informing the user that the header value is malformed.



  ```python
  expiry: int = 60 * 60 * 24
  ```

  How long to cache responses for, measured in seconds. Set to 24 hours by default.



  ```python
  applicable_methods=['POST', 'PATCH']
  ```

  What HTTP methods to consider for idempotency. If the request method is one of the methods in this list, and the
  [idempotency header](#idempotency-header-key) is sent, the middleware will be used. By default, only `POST`
  and `PATCH` methods are cached and replayed.



  Briefly summarized, this is how the middleware functions:

  - The first request is processed, and consequent requests are replayed, until the response expires.
    `expiry` *can* be set to `None` to skip expiry, but most likely you will want to expire responses
    after a while.
  - If two requests comes in at the same time - i.e., if a second request hits the middlware *before*
    the first request has finished, the middleware will return a 409, informing the user that a request
    is being processed, and that we cannot handle the second request.
  - The middleware only handles HTTP requests.
  - By default, the middleware only handles requests with `POST` and `PATCH` methods. Other HTTP methods skip this middleware.
  - Only valid JSON responses with `content-type` == `application/json` are cached.


pkgId: d9753fa91e9daffb8d8b22c8346f7b58a5fb64dca0f618ec619736079ed35dd0
name: python-asgi-logger
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Middleware based uvicorn access logger! :tada:
url: https://github.com/Kludex/asgi-logger
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi-logger-0.1.0-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <strong>asgi-logger</strong>
  </h1>
  <p align="center">
      <a href="https://github.com/Kludex/asgi-logger" target="_blank">
          <img src="https://img.shields.io/github/last-commit/Kludex/asgi-logger" alt="Latest Commit">
      </a>
          <img src="https://img.shields.io/github/workflow/status/Kludex/asgi-logger/Test">
          <img src="https://img.shields.io/codecov/c/github/Kludex/asgi-logger">
      <br />
      <a href="https://pypi.org/project/asgi-logger" target="_blank">
          <img src="https://img.shields.io/pypi/v/asgi-logger" alt="Package version">
      </a>
      <img src="https://img.shields.io/pypi/pyversions/asgi-logger">
      <img src="https://img.shields.io/github/license/Kludex/asgi-logger">
  </p>




  ``` bash
  pip install asgi-logger
  ```



  This project is licensed under the terms of the MIT license.


pkgId: 1ad6cb6e743457c28908380fff73e29323c767f52a3d53b6c770972e2a85caf1
name: python-asgi-matomo
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Middleware for tracking ASGI requests with Matomo
url: https://pypi.org/project/asgi-matomo/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi-matomo-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Packaging status](https://img.shields.io/pypi/v/asgi-matomo?color=%2334D058&label=pypi%20package)](https://pypi.org/project/asgi-matomo)
  [![CI](https://github.com/spraakbanken/asgi-matomo/workflows/CI/badge.svg)](https://github.com/spraakbanken/asgi-matomo/actions?query=workflow%3ACI)
  [![codecov](https://codecov.io/gh/spraakbanken/asgi-matomo/branch/main/graph/badge.svg?token=MRJZVCJQF5)](https://codecov.io/gh/spraakbanken/asgi-matomo)

  Tracking requests with Matomo from ASGI apps.

  `MatomoMiddleware` adds tracking of all requests to Matomo to ASGI applications (Starlette, FastAPI, Quart, etc.). The intended usage is for api tracking (backends).

  **Note** If you serve HTML (directly or by templates), it is suggested to track those parts through Matomo's javascript tracking.



  ```bash
  pip install asgi-matomo
  ```



  Currently this middleware tracks:

  - `url`
  - `ua`: user_agent
  - `gt_ms`: mesaured as the time before and after this middleware call next in the asgi stack.
  - `send_image=0` for performance issues
  - `cvar` with at least `http_status_code` and `http_method` set.
  - `lang` if `accept-lang` is set
  - `cip` client ip, **requires** `access_token` to be given.
  - `action_name` that defaults to path, but can be specified.

  You can also pass variable to track by adding an `asgi_matomo`  dict in the `state` dict of the ASGI `scope`:

  ```python
  scope = {
    "state": {
      "asgi_matomo": {
        "e_a": "Playing",
        "cvar": {
          "your": "custom",
          "data": "here",
        }
      }
    }
  }
  ```

  The keys of the `asgi_matomo` dict is expected to be valid parameter for the [Matomo HTTP Tracking API](https://developer.matomo.org/api-reference/tracking-api). `cvar` is serialized with the standard `json` lib.

  You can also track time spent on different tasks with `trackers.PerfMsTracker`.

  ```python
  import asyncio
  from starlette.applications import Starlette
  from starlette.responses import JSONResponse
  from starlette.routing import Route
  from starlette.middleware import Middleware

  from asgi_matomo import MatomoMiddleware
  from asgi_matomo.trackers import PerfMsTracker

  async def homepage(request):
      async with PerfMsTracker(scope=request.scope, key="pf_srv"):
          
          await asyncio.sleep(1)
          data = {"data": "a"*4000}
      return JSONResponse(data)

  app = Starlette(
    routes=[Route("/", homepage)],
    middleware=[
      Middleware(
        MatomoMiddleware,
        matomo_url="YOUR MATOMO TRACKING URL",
        idsite=12345, # your service tracking id
    )],
  )
  ```





  ```python
  from starlette.applications import Starlette
  from starlette.responses import JSONResponse
  from starlette.routing import Route
  from starlette.middleware import Middleware

  from asgi_matomo import MatomoMiddleware

  async def homepage(request):
      return JSONResponse({"data": "a" * 4000})

  app = Starlette(
    routes=[Route("/", homepage)],
    middleware=[
      Middleware(
        MatomoMiddleware,
        matomo_url="YOUR MATOMO TRACKING URL",
        idsite=12345, # your service tracking id
    )],
  )
  ```



  ```python
  from fastapi import FastAPI
  from asgi_matomo import MatomoMiddleware

  app = FastAPI()
  app.add_middleware(
    MatomoMiddleware,
    matomo_url="YOUR MATOMO TRACKING URL",
    idsite=12345, # your service tracking id
  )

  @app.get("/")
  def home() -> dict:
      return {"data": "a" * 4000}
  ```





  ```python
  app.add_middleware(
    MatomoMiddleware,
    matomo_url="YOUR MATOMO TRACKING URL",
    idsite=12345, # your service tracking id
    access_token="SECRETTOKEN",
    assume_https=True,
    exclude_paths=["/health"],
    exclude_patterns=[".*/old.*"],
    route_details={
      "route": {
        "action_name": "Name",
      }
    }
  )
  ```

  **Parameters**:

  - **(Required)** `matomo_url`: The URL to make your tracking calls to.
  - **(Required)** `idsite`: The tracking id for your service.
  - _(Optional)_ `access_token`: Access token for Matomo. If this is set `cip` is also tracked. Required for tracking some data.
  - _(Optional)_ `assume_https`: If `True`, set tracked url scheme to `https`, useful when running behind a proxy. Defaults to `True`.
  - _(Optional)_ `exclude_paths`: A list of paths to exclude, only excludes path that is equal to a path in this list. These are tried before `exclude_patterns`. Defaults to `None`.
  - _(Optional)_ `exclude_patterns`: A list of regex patterns that are compiled, and then exclude a path from tracking if any pattern match. Defaults to `None`.
  These are tried after `exclude_paths`.
  - _(Optional)_ `route_details`: A dict with custom route-specific tracking data. Defaults to `None`.

  **Notes**:

  - Currently only some parts [Matomo Tracking HTTP API](https://developer.matomo.org/api-reference/tracking-api) is supported.



  - [x] _filtering tracked of urls_
  - [x] _custom extraction of tracked data_

  This project keeps a [changelog](https://github.com/spraakbanken/asgi-matomo/CHANGELOG.md).



  This project uses `pdm` and `pre-commit`.


pkgId: 2652cf76f59a4e30440905abd6077b1ebfd27739d7fc7b1a0e2de3a6d194f929
name: python-asgi-monitor
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Quick and easy monitoring setup for ASGI application
url: https://github.com/draincoder/asgi-monitor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi-monitor-0.6.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://github.com/draincoder/asgi-monitor/blob/develop/docs/logo/asgi-monitor-dark.png?raw=true">
      <source media="(prefers-color-scheme: light)" srcset="https://github.com/draincoder/asgi-monitor/blob/develop/docs/logo/asgi-monitor-light.png?raw=true">
      <img alt="asgi-monitor logo" src="docs/logo/asgi-monitor-dark.png" height="300">
    </picture>

    <hr>

    [![PyPI version](https://badge.fury.io/py/asgi-monitor.svg)](https://pypi.python.org/pypi/asgi-monitor)
    [![Documentation Status](https://readthedocs.org/projects/asgi-monitor/badge/?version=latest)](https://asgi-monitor.readthedocs.io/en/latest/?badge=latest)
    [![Test](https://github.com/draincoder/asgi-monitor/actions/workflows/ci.yaml/badge.svg)](https://github.com/draincoder/asgi-monitor/actions/workflows/ci.yaml)
    [![Supported versions](https://img.shields.io/pypi/pyversions/asgi-monitor.svg)](https://pypi.python.org/pypi/asgi-monitor)
    [![Downloads](https://img.shields.io/pypi/dm/asgi-monitor.svg)](https://pypistats.org/packages/asgi-monitor)
    [![License](https://img.shields.io/github/license/draincoder/asgi-monitor)](https://github.com/draincoder/asgi-monitor/blob/master/LICENSE)

  </div>




   - [Prometheus](https://prometheus.io) metrics
   - [OpenTelemetry](https://opentelemetry.io) traces
   - [Structlog](https://www.structlog.org/) logging with native **logging** module support
   - Integrations with [Litestar](https://litestar.dev), [FastAPI](https://fastapi.tiangolo.com), [Starlette](https://www.starlette.io) and [Aiohttp](https://docs.aiohttp.org/en/stable/web.html)
   - Logging support for [Uvicorn](https://www.uvicorn.org) and [Gunicorn](https://gunicorn.org) with custom **UvicornWorker**

  > [!IMPORTANT]
  > At this stage, the library is being tested and be careful in using it,
  > your participation in the development will be appreciated!

  📚 [Documentation](https://asgi-monitor.readthedocs.io)




  ```shell
  pip install asgi-monitor
  ```



  ```python
  from asgi_monitor.integrations.fastapi import setup_metrics, MetricsConfig
  from fastapi import FastAPI
  from uvicorn import run


  def run_app() -> None:
     app = FastAPI()
     setup_metrics(app, MetricsConfig(app_name="fastapi"))
     run(app, host="127.0.0.1", port=8000)


  if __name__ == "__main__":
     run_app()
  ```

  After setting up, you can see visualization of default metrics in Grafana

  ![Dashboard](docs/images/metrics.png)

  The library originates from [structlog-asgi](https://github.com/nkhitrov/structlog-asgi)


pkgId: a9b04b6b5e8ba325a1807e370a6ac998a0afa8d3778b22252d9ec97019470c09
name: python-asgi-ratelimit
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/abersheeran/asgi-ratelimit
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi-ratelimit-0.10.0-1.src.rpm
checksum_type: sha256
description:
  Limit user access frequency. Base on ASGI.

  100% coverage. High performance. Support regular matching. Customizable.



  ```

  pip install asgi-ratelimit


  pip install asgi-ratelimit[redis]


  pip install asgi-ratelimit[jwt]


  pip install asgi-ratelimit[full]
  ```



  The following example will limit users under the `"default"` group to access `/towns` at most once per second and `/forests` at most once per minute. And the users in the `"admin"` group have no restrictions.

  ```python
  from typing import Tuple

  from ratelimit import RateLimitMiddleware, Rule


  from ratelimit.backends.simple import MemoryBackend

  rate_limit = RateLimitMiddleware(
      ASGI_APP,
      AUTH_FUNCTION,
      MemoryBackend(),
      {
          r"^/towns": [Rule(second=1, group="default"), Rule(group="admin")],
          r"^/forests": [Rule(minute=1, group="default"), Rule(group="admin")],
      },
  )


  from redis.asyncio import StrictRedis
  from ratelimit.backends.redis import RedisBackend

  rate_limit = RateLimitMiddleware(
      ASGI_APP,
      AUTH_FUNCTION,
      RedisBackend(StrictRedis()),
      {
          r"^/towns": [Rule(second=1, group="default"), Rule(group="admin")],
          r"^/forests": [Rule(minute=1, group="default"), Rule(group="admin")],
      },
  )
  ```

  :warning: **The pattern's order is important, rules are set on the first match**: Be careful here !

  Next, provide a custom authenticate function, or use one of the [existing auth methods](#built-in-auth-functions).

  ```python
  from ratelimit.auths import EmptyInformation


  async def AUTH_FUNCTION(scope: Scope) -> Tuple[str, str]:
      """
      Resolve the user's unique identifier and the user's group from ASGI SCOPE.

      If there is no user information, it should raise `EmptyInformation`.
      If there is no group information, it should return "default".
      """
      
      
      
      return USER_UNIQUE_ID, GROUP_NAME


  rate_limit = RateLimitMiddleware(ASGI_APP, AUTH_FUNCTION, ...)
  ```

  The `Rule` type takes a time unit (e.g. `"second"`), a `"group"`, and a `"method"` as a param. If the `"group"` param is not specified then the `"authenticate"` method needs to return the "default group". The `"method"` param corresponds to the http method, if it is not specified, the rule will be applied to all http requests.

  Example:
  ```python
      ...
      config={
          r"^/towns": [Rule(second=1, method="get"), Rule(second=10, group="admin")],
      }
      ...


  async def AUTH_FUNCTION(scope: Scope) -> Tuple[str, str]:
      ...
      
      if user not in admins_group:
          return user_unique_id, 'default'

      return user_unique_id, user_group
  ```



  It is possible to mix the rules to obtain higher level of control.

  The below example will allow up to 10 requests per second and no more than 200 requests per minute, for everyone, for the same API endpoint.

  ```python
      ...
      config={
          r"^/towns": [Rule(minute=200, second=10)],
      }
      ...
  ```

  Example for a "admin" group with higher limits.

  ```python
      ...
      config={
          r"^/towns": [
              Rule(day=400, minute=200, second=10),
              Rule(minute=500, second=25, group="admin"),
          ],
      }
      ...
  ```

  Sometimes you may want to specify that some APIs share the same flow control pool. In other words, flow control is performed on the entire set of APIs instead of a single specific API. Only the `zone` parameter needs to be used. **Note**: You can give different rules the same `zone` value, and all rules with the same `zone` value share the same flow control pool.

  ```python
      ...
      config={
          r"/user/\d+": [
              Rule(minute=200, zone="user-api"),
              Rule(second=100, zone="user-api", group="admin"),
          ],
      }
      ...
  ```



  When the user's request frequency triggers the upper limit, all requests in the following period of time will be returned with a `429` status code.

  Example: `Rule(second=5, block_time=60)`, this rule will limit the user to a maximum of 5 visits per second. Once this limit is exceeded, all requests within the next 60 seconds will return `429`.




  If you want a rate limit a specifc HTTP method on an endpoint, the `Rule` object has a `method` param. If no method is specified, the default value is `"*"` for all HTTP methods.

  ```python
  r"^/towns": [
      Rule(group="admin", method="get", second=10),
      Rule(group="admin", method="post", second=2)
  ]
  ```




  Just specify `on_blocked` and you can customize the asgi application that is called when blocked.

  ```python
  def yourself_429(retry_after: int):
      async def inside_yourself_429(scope: Scope, receive: Receive, send: Send) -> None:
          await send({"type": "http.response.start", "status": 429})
          await send(
              {
                  "type": "http.response.body",
                  "body": b"custom 429 page",
                  "more_body": False,
              }
          )

      return inside_yourself_429

  RateLimitMiddleware(..., on_blocked=yourself_429)
  ```





  ```python
  from ratelimit.auths.ip import client_ip
  ```

  Obtain user IP through `scope["client"]` or `X-Real-IP`.

  Note: this auth method will not work if your IP address (such as 127.0.0.1 etc) is not allocated for public networks.



  ```python
  from ratelimit.auths.session import from_session
  ```

  Get `user` and `group` from `scope["session"]`.

  If key `group` not in session, will return `default`. If key `user` not in session, will raise a `EmptyInformation`.



  ```python
  from ratelimit.auths.jwt import create_jwt_auth

  jwt_auth = create_jwt_auth("KEY", "HS256")
  ```

  Get `user` and `group` from JWT that in `Authorization` header.



  Normally exceptions raised in the authentication function result in an Internal Server Error, but you can pass a function to handle the errors and send the appropriate response back to the user. For example, if you're using FastAPI or Starlette:

  ```python
  from fastapi.responses import JSONResponse
  from ratelimit.types import ASGIApp

  async def handle_auth_error(exc: Exception) -> ASGIApp:
      return JSONResponse({"message": "Unauthorized access."}, status_code=401)

  RateLimitMiddleware(..., on_auth_error=handle_auth_error)
  ```

  For advanced usage you can handle the response completely by yourself:

  ```python
  from fastapi.responses import JSONResponse
  from ratelimit.types import ASGIApp, Scope, Receive, Send

  async def handle_auth_error(exc: Exception) -> ASGIApp:
      async def response(scope: Scope, receive: Receive, send: Send):
          
          
      return response
  ```


pkgId: ee00dd887a85105893469db7fec4f8f8199808d64fe97185572d5c6a821dab4f
name: python-asgi_aiogram
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: fast ASGI wraper for aiogram
url: https://pypi.org/project/asgi_aiogram/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi_aiogram-0.2.1-1.src.rpm
checksum_type: sha256
description:
  __base usage__
  ```python
  from aiogram import Dispatcher, Bot
  from asgi_aiogram import ASGIAiogram
  from asgi_aiogram.strategy import SingleStrategy

  dp = Dispatcher()

  @dp.startup()
  async def startup(dispatcher: Dispatcher, bot: Bot):
      await bot.close()
      await bot.set_webhook(
          url='https://example.com/bot',
          allowed_updates=dispatcher.resolve_used_update_types()
      )

  bot = Bot(token="<token>")
  app = ASGIAiogram(
      dispatcher=dp,
      strategy=SingleStrategy(bot=bot, path="/bot")
  )
  ```

  ```commandline
  uvicorn main:app
  ```


pkgId: 0ca89863df583d506aad762ee9ea2e04e5cac7bf8b6c1536378769bc8d0a8f33
name: python-asgi_ipc
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Posix IPC-backed ASGI channel layer implementation
url: http://github.com/django/asgi_ipc/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi_ipc-1.4.2-1.src.rpm
checksum_type: sha256
description:
  An ASGI channel layer that uses POSIX shared memory IPC as its backing store
  (only works between processes on the same machine).
  IPC is still a bit of a wild west of UNIX compatability, so if you find weird
  errors, please file an issue with details and exact system specifications. In
  partcular, this module is tested and works well on Linux kernels and the Windows
  Subsystem for Linux; it also works on Mac OS but will not be able to detect
  deadlock situations due to limitations in the kernel.


pkgId: 71ff4f3eb6f586e723c6f2df6d59d24d04de0015a063706ead8236e7885d09fc
name: python-asgi_redis
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: Redis-backed ASGI channel layer implementation
url: http://github.com/django/asgi_redis/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgi_redis-1.4.3-1.src.rpm
checksum_type: sha256
description:
  An ASGI channel layer that uses Redis as its backing store, and supports
  both a single-server and sharded configurations, as well as group support.


pkgId: d5c98159053107d9daf4cdac3e50f9a9dc7c34e2587f8f7fc14fdc9a570282dc
name: python-asgihandler
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: ASGIHandler
url: https://github.com/GreaterWMS/GreaterWMS
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgihandler-0.5.9-1.src.rpm
checksum_type: sha256
description:
  pip install --upgrade setuptools wheel twine


  python setup.py sdist bdist_wheel


  twine check dist/*


  twine upload dist/*


pkgId: cb1be6ead22d105ecc80d2c3c656f4b5f2cbc63de8610c2e5e95fc21d6ac76bc
name: python-asgimod
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Package to make Django *usable* in async Python
url: https://github.com/paaksing/asgimod
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgimod-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This mixin adds async capabilities to the model class and instances:
  - `aobjects` full featured async manager.
  - `asave`, `adelete` async equivalents of `save` and `delete`.
  - `a(.*)` async foreign relations access.
   Import:
  ```python
  from asgimod.mixins import AsyncMixin
  ```
  Usage:
  ```python
  class SampleModel(AsyncMixin, models.Model):
      sample_field = models.CharField(max_length=50)
  ```

  Extends from `models.Model`, uses metaclass `AsyncMixinMeta` (extended from `models.ModelBase`).
  <br>

  Returns an instance of `AsyncManager`. Async equivalent of `Model.objects`.
  <br>

  Async equivalent of `Model.save`
  <br>

  Async equivalent of `Model.delete`
  <br>

  There are 3 possible returns from an async foreign relation access.
  - `AsyncManyToOneRelatedManager`: Result of a reverse many to one relation access.
  - `AsyncManyToManyRelatedManager`: Result of a many to many relation access (both forward and reverse access).
  - `Awaitable[T]`: Result of a one to one relation access or a forward many to one relation access. Returns an awaitable with `T` return (`T` being the type of the foreign object).
  To access a foreign relation in async mode, add the `a` prefix to your sync access attribute. Using the models defined for this documentation, examples:
  ```python
  price = await Price.aobjects.get(id=1)
  pizza = await Pizza.aobjects.get(id=1)
  weird_pizza = await Pizza.aobjects.get(id=2)
  bacon = await Topping.aobjects.get(id=1)
  mushroom = await Topping.aobjects.get(id=2)
  medium_box = await Box.aobjects.get(id=1)

  await pizza.aprice
  await price.apizza
  await price.abox

  await medium_box.apizza_set.all().get(id=1)
  await medium_box.apizza_set.filter(id__gt=1).order_by("name").count()
  await medium_box.apizza_set.add(weird_pizza)
  await medium_box.apizza_set.clear()

  await pizza.atoppings.all().exists()
  await pizza.atoppings.add(bacon, mushroom)
  await bacon.atoppings.filter(name__startswith="b").exists()
  await pizza.atoppings.remove(bacon)
  await pizza.atoppings.clear()

  await mushroom.apizza_set.all().exists()
  await mushroom.apizza_set.add(pizza)
  await mushroom.apizza_set.set([pizza, weird_pizza])
  ```
  As you have guessed, these attributes are not defined in code, and thus they are not typed, well, here's the fix:
  ```python
  class Topping(AsyncMixin, models.Model):
      name = models.CharField(max_length=30)
      apizza_set: AsyncManyToManyRelatedManager["Pizza"]
  class Box(AsyncMixin, models.Model):
      name = models.CharField(max_length=50)
      apizza_set: AsyncManyToOneRelatedManager["Pizza"]
  class Price(AsyncMixin, models.Model):
      amount = models.DecimalField(decimal_places=2, max_digits=10)
      currency = models.CharField(max_length=16, default="usd")
      apizza: "Pizza"
  ```


pkgId: 10e3d9153cee0c73e58bc1d3ce98f869ea9fcb8cd0a7e5b5322672dcaca4f5f3
name: python-asgiref
arch: src
version: 3.8.1
epoch: 0
release: 1
summary: ASGI specs, helper code, and adapters
url: https://github.com/django/asgiref/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgiref-3.8.1-1.src.rpm
checksum_type: sha256
description:
  ASGI is a standard for Python asynchronous web apps and servers to communicate
  with each other, and positioned as an asynchronous successor to WSGI. You can
  read more at https://asgi.readthedocs.io/en/latest/
  This package includes ASGI base libraries, such as:
  * Sync-to-async and async-to-sync function wrappers, ``asgiref.sync``
  * Server base classes, ``asgiref.server``
  * A WSGI-to-ASGI adapter, in ``asgiref.wsgi``


pkgId: 9ad6d3f9d63f22c82a6b1acb9c6310dda9378141af5ce062ae711102b3cef684
name: python-asgl
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: A regression solver for high dimensional penalized linear, quantile and logistic regression models
url: https://github.com/alvaromc317/asgl
rpm_license: GNU General Public License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asgl-2.1.2-1.src.rpm
checksum_type: sha256
description:
  If you use `asgl` in a scientific publication, we would appreciate you
  [cite our
  paper](https://link.springer.com/article/10.1007/s11634-020-00413-8).
  Thank you for your support and we hope you find this package useful!

  This project is licensed under the GPL-3.0 license. This means that the
  package is open source and that any copy or modification of the original
  code must also be released under the GPL-3.0 license. In other words,
  you can take the code, add to it or make major changes, and then openly
  distribute your version, but not profit from it.


pkgId: 616a061711812b5aa8b88f7163b99d5087db8051a08569fce4c425c508f24fde
name: python-ash-dal
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: The library provides a standardized way to connect to DB, and Base DAO class implementation
url: https://pypi.org/project/ash-dal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ash-dal-0.2.2-1.src.rpm
checksum_type: sha256
description:
  The library provides a standardized way to connect to DB, and Base DAO class implementation





  ```shell
  pip install ash-dal



  poetry add ash-dal
  ```


  In order to install Ash DAL directly from GitHub repository, run:
  ```shell
  pip install git+https://github.com/meetash/ash-dal.git@main



  poetry add git+https://github.com/meetash/ash-dal.git@main
  ```


  There are two options: sync or async database connection.

  ```python
  from ash_dal import Database, URL
  from ash_dal.utils import prepare_ssl_context
  from models import User


  ssl_context = prepare_ssl_context(
      ssl_root_dir='/tmp/certs',
      client_cert_path='client-cert.pem',
      client_key_path='client-key.pem',
      server_ca_path='server-ca.pem'
  )

  db_url = URL.create(
      drivername="mysql+pymysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3306,
      database="my_db",
  )

  read_replica_db_url = URL.create(
      drivername="mysql+pymysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3307,
      database="my_db",
  )


  DATABASE = Database(
  	db_url=db_url,
  	read_replica_url=read_replica_db_url,
  	ssl_context=ssl_context,
      read_replica_ssl_context=ssl_context
  )


  def get_users(db: Database):
  	with db.session as session:
  		users = session.scalars(User)
  	return users

  ```

  ```python
  from ash_dal import AsyncDatabase, URL
  from ash_dal.utils import prepare_ssl_context
  from models import User


  ssl_context = prepare_ssl_context(
      ssl_root_dir='/tmp/certs',
      client_cert_path='client-cert.pem',
      client_key_path='client-key.pem',
      server_ca_path='server-ca.pem'
  )

  db_url = URL.create(
      drivername="mysql+aiomysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3306,
      database="my_db",
  )

  read_replica_db_url = URL.create(
      drivername="mysql+aiomysql",
      username="my_db_user",
      password="S3cret",
      host="127.0.0.1",
      port=3307,
      database="my_db",
  )


  DATABASE = AsyncDatabase(
  	db_url=db_url,
  	read_replica_url=read_replica_db_url,
  	ssl_context=ssl_context,
      read_replica_ssl_context=ssl_context
  )

  async def async_get_users(db: AsyncDatabase):
  	async with db.session as session:
  		users = await session.scalars(User)
  	return users

  ```


  Like you can use sync/async Database classes, there are also two variations of DAO Base class



  ```python

  from dataclasses import dataclass

  from sqlalchemy import String
  from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
  from ash_dal import BaseDAO, Database, URL


  class Base(DeclarativeBase):
      pass


  class ExampleORMModel(Base):
      __tablename__ = "example_table"

      id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
      first_name: Mapped[str] = mapped_column(String(64))
      last_name: Mapped[str] = mapped_column(String(64))
      age: Mapped[int]


  @dataclass()
  class ExampleEntity:
      id: int
      first_name: str
      last_name: str
      age: int


  class ExampleDAO(BaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel


  if __name__ == '__main__':
      db = Database(
          db_url=URL.create(
              drivername="mysql+pymysql",
              username="my_db_user",
              password="S3cret",
              host="127.0.0.1",
              port=3306,
              database="my_db",
          )
      )
      dao = ExampleDAO(database=db)

      entity = dao.get_by_pk(pk='some-primary-key')
  ```



  ```python

  from dataclasses import dataclass

  from sqlalchemy import String
  from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
  from ash_dal import AsyncBaseDAO, AsyncDatabase, URL
  import asyncio


  class Base(DeclarativeBase):
      pass


  class ExampleORMModel(Base):
      __tablename__ = "example_table"

      id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
      first_name: Mapped[str] = mapped_column(String(64))
      last_name: Mapped[str] = mapped_column(String(64))
      age: Mapped[int]


  @dataclass()
  class ExampleEntity:
      id: int
      first_name: str
      last_name: str
      age: int


  class ExampleDAO(AsyncBaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel


  if __name__ == '__main__':
      db = AsyncDatabase(
          db_url=URL.create(
              drivername="mysql+aiomysql",
              username="my_db_user",
              password="S3cret",
              host="127.0.0.1",
              port=3306,
              database="my_db",
          )
      )
      dao = ExampleDAO(database=db)
      entity = asyncio.run(dao.get_by_pk(pk='some-primary-key'))
  ```


  The main goal of BaseDAO class is to provide CRUD methods that could be useful while building a basic CRUD API.
  `BaseDAO` class provides the following default methods:

  - `BaseDAO.get_by_pk(pk)` - Using this method you can fetch an entity by its primary key.
      ```python
      entity = dao.get_by_pk(pk='AWABCD1234')
      ```
  - `BaseDAO.all` - Using this method you can fetch all entities from the database. It's might be useful for fetching
      data from small tables where you don't actually need pagination (configs etc)
      ```python
      entities = dao.get_all()
      ```
  - `BaseDAO.get_page(page_index, [page_size])` - Fetch a page with entities by page index. If the index is out of range,
      an empty page will be returned. If `page_size` is not passed - the default page size (20) will be applied.
      ```python
      page = dao.get_page(page_index=2, page_size=10)
      for entity in page:
          
          ...
      ```
  - `BaseDAO.paginate([specification, page_size])` - An iterator that returns pages with entities. A specification
      can be applied to fetch filtered data.
      ```python
      for page in dao.paginate(specification={'status': 'notified'}, page_size=15):
          
          ...
      ```
  - `BaseDAO.filter(specification)` - Fetch entities from database by specification. It's might be useful for fetching
      filtered data from small tables where you don't actually need pagination (configs etc)
      ```python
      entities = dao.filter(specification={'labId': 2})
      ```

  - `BaseDAO.create(data)` - Create an entity in database based on passed data. Returns back an entity
      ```python
      data = {'foo': 'bar'}
      entity = dao.create(data=data)
      ```
  - `BaseDAO.bulk_create(data)` - Create multiple entities within one query. Unlike the previous method
      this one doesn't return anything.
      ```python
      data = [{'foo': 'bar'}, {'foo': 'beer'}]
      dao.bulk_create(data=data)
      ```
  - `BaseDAO.update(specification, update_data)` - Patch entity(ies) by specification.
      ```python
      update_data = {'foo': 'bar'}
      is_updated = dao.update(specification={'foo': 'beer'}, update_data=update_data)
      ```
  - `BaseDAO.delete(specification)` - Remove entity(ies) by specification.
      ```python
      is_removed = dao.delete(specification={'id': 'some-id'},)
      ```



  By default the BaseDAO class uses the simplest pagination strategy that is based on SQL offset & limit mechanisms.
  The library provides one more strategy out of the box that is called deferred join pagination.
  You can learn more about it [here](https://planetscale.com/learn/courses/mysql-for-developers/examples/deferred-joins).

  If you want to change the pagination strategy for you DAO class, you can do it by re-defining
  the `__paginator_factory__` field inside your DAO class:
  ```python
  from ash_dal import BaseDAO, DeferredJoinPaginator
  from ash_dal.utils import DeferredJoinPaginatorFactory, AsyncDeferredJoinPaginator

  class ExampleEntity:
      ...

  class ExampleORMModel:
      id: int
      ...

  class ExampleDAO(BaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel
      __paginator_factory__ = DeferredJoinPaginatorFactory(
          paginator_class=DeferredJoinPaginator,
          pk_field=ExampleORMModel.id,
      )



  class ExampleAsyncDAO(BaseDAO[ExampleEntity]):
      __entity__ = ExampleEntity
      __model__ = ExampleORMModel
      __paginator_factory__ = DeferredJoinPaginatorFactory(
          paginator_class=AsyncDeferredJoinPaginator,
          pk_field=ExampleORMModel.id,
      )
  ```

  You can also define your own pagination strategy. Be aware that your paginator class should implement IPaginator or
  IAsyncPaginator interfaces:

  ```python
  from ash_dal.utils.paginator.interface import IPaginator, IAsyncPaginator
  from ash_dal import PaginatorPage
  import typing as t

  class ExampleORM:
      ...

  class MyPaginator(IPaginator[ExampleORM]):
      def get_page(self, page_index: int) -> PaginatorPage[ExampleORM]:
          
          ...

      def paginate(self) -> t.Iterator[PaginatorPage[ExampleORM]]:
          
          ...
      @property
      def size(self) -> int:
          
          return 10



  class MyAsyncPaginator(IAsyncPaginator[ExampleORM]):
      async def get_page(self, page_index: int) -> PaginatorPage[ExampleORM]:
          
          ...

      async def paginate(self) -> t.AsyncIterator[PaginatorPage[ExampleORM]]:
          
          ...
      @property
      async def size(self) -> int:
          
          return 10
  ```


pkgId: 0e5b0b25e3cae33f3a649a2990efc78d60abe055f5b2b94a2272a54cbd0ea992
name: python-ashes
arch: src
version: 24.0.0
epoch: 0
release: 1
summary: Lightweight templating for Python (a la dust.js)
url: https://github.com/mahmoud/ashes
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ashes-24.0.0-1.src.rpm
checksum_type: sha256
description:
  Ashes provides a Python implementation of dust_, a lightweight
  templating language that makes it easy to create purely data-driven
  templates that work equally well on servers and clients.

  Ashes is pure Python and is tested on Python 2.7, 3.x, and PyPy.

  .. _dust: http://akdubya.github.com/dustjs/


pkgId: ac8177455fb2ad5b0438c6d2de2696455b1fef729046f5760bbed8bbb72994ff
name: python-ashlar
arch: src
version: 1.18.0
epoch: 0
release: 1
summary: Alignment by Simultaneous Harmonization of Layer/Adjacency Registration
url: https://github.com/sorgerlab/ashlar
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ashlar-1.18.0-1.src.rpm
checksum_type: sha256
description:
  ASHLAR: Alignment by Simultaneous Harmonization of Layer/Adjacency Registration

  Ashlar implements efficient combined stitching and registration of multi-channel
  image mosaics collected using the Tissue-CycIF microscopy protocol [1]_. Although
  originally developed for CycIF, it may also be applicable to other tiled and/or
  cyclic imaging approaches. The package offers both a command line script for the
  most common use cases as well as an API for building more specialized tools.

  .. [1] Tissue-CycIF is multi-round immunofluorescence microscopy on large fixed
     tissue samples. See https://doi.org/10.1101/151738 for details.


pkgId: 30b3b759ae2527872190e6bc03c8c844c862f20aed620307a5788dd9613c59c1
name: python-asi4py
arch: src
version: 1.3.12
epoch: 0
release: 1
summary: A Python wrapper for Atomic Simulation Interface API
url: https://gitlab.com/pvst/asi
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asi4py-1.3.12-1.src.rpm
checksum_type: sha256
description:
  Atomic Simulation Interface (ASI) is a native C-style API that includes functions for export and import of data structures that are used in electronic structure calculations and for classical molecular dynamics simulations. ASI aims to be a uniform, generic and efficient interface for connecting various computational chemistry and materials science codes in multiscale simulation workflows, such as QM/MM, QM/ML, QM/QM. ASI specifies functions, data types and calling conventions for export and import of density matrices, overlap and Hamiltonian matrices, electrostatic potential, atomic coordinates, charges, total energy and forces.



  ASI API is specified as a C header file [`asi.h`][1]. Codes implementing ASI API must provide linkable library with definitions of functions from [`asi.h`][1]. Depending on particular usage of the implementaions, some functions can be ommited or implemented as stubs, if they are not going to used. To use Python ASI wrapper it is necessary to have all functions from `asi.h` defined, but of course stub definitions can be used.

  [**ASI API specification**][1].

  [1]: https://pvst.gitlab.io/asi/asi_8h.html



  * [DFTB+](https://dftbplus.org/): [in separate branch](https://github.com/PavelStishenko/dftbplus/tree/ASI_v1.3).
  * [FHI-aims](https://fhi-aims.org/): in the main branch.






  FHI-aims has embedded support of ASI API. Just build latest version of FHI-aims as a shared library and use with your code.




  1. Download and build DFTB+ from [the branch with ASI API](https://github.com/PavelStishenko/dftbplus/tree/ASI_v1.3) with shared library support.

  2. Set environment variables `DFTBP_INCLUDE` and `DFTBP_LIB_DIR` to folders with DFTB+ C-headers and libraries.

  3. Optionally export environment variables `INSTALL_PREFIX` and `BUILD_PATH` to set installation and building locations.

  4. Run `make && make install` from the root of the working copy of this repository.

  5. The shared library implementing ASI API for DFTB+ will be in `${INSTALL_PREFIX}/lib`.



  Use `Makefile` in `tests` folder to build native tests. Set environment variables in the header of `tests/Makefile` to link with proper ASI API implementaions.

  To run tests go to `tests/testcases` and run `run_dftbp_tests.sh` or `run_aims_tests.sh` to run test.



  See `tests/src` for examples of usage in native code.

  See `tests/python` for examples of usage in Python scripts.

rpm_license:
  MIT License  Copyright (c) 2022 Pavel V Stishenko, Andrew Logsdail, Reinhard Maurer, Volker Blum, Mariana Rossi, Ben Hourahine, Scott Woodley, Thomas Keal  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 6a45bad75b3797908c2093a0a841ed23c769ea740ffb50081c1fa2b2f098cc0e
name: python-asifjamali
arch: src
version: 30.0.1
epoch: 0
release: 1
summary: Team Musibat Bots
url: https://bitbucket.org/shahzain83/musibat
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asifjamali-30.0.1-1.src.rpm
checksum_type: sha256
description:
  * Learning Perpose
  * Version 30.0
  * [Learn iSsues](https://bitbucket.org/shahzain83/musibat/issues)



  * Summary of set up
  * Configuration
  * Dependencies
  * Database configuration
  * How to run tests
  * Deployment instructions



  * musibat_bots
  * +923032939576


pkgId: efe86e21500ea1b855e0a44498c665404ec28cc89a56aad5e1411d5c5856bcd7
name: python-asilib
arch: src
version: 0.25.0
epoch: 0
release: 1
url: https://aurora-asi-lib.readthedocs.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asilib-0.25.0-1.src.rpm
checksum_type: sha256
summary:
  An open source package providing data access and analysis tools for the world's all-sky imager (ASI) data.

description:
  ![Test python package](https://github.com/mshumko/asilib/workflows/Test%20python%20package/badge.svg) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4746447.svg)](https://doi.org/10.5281/zenodo.4746446)


  asilib is an open source package providing data access and analysis tools for the world's all-sky imager (ASI) data.

  > [!NOTE]
  > The asilib code on PyPI moved from [aurora-asi-lib](https://pypi.org/project/aurora-asi-lib/) to [asilib](https://pypi.org/project/asilib/). To update to version >=0.22.0, run
  > 1. `python3 -m pip uninstall aurora-asi-lib` and
  > 2. `python3 -m pip install asilib`.

  The purpose of this project is to combine data from numerous observational ASI arrays into a single unified framework and is thus not associated with the development and operations of all sky cameras, or the curation of ASI datasets. All data is publicly available and is provided as-is. Please give appropriate credit and coordinate with instrument teams with regards to data issues and/or interpretation. See the [Acknowledgements](https://aurora-asi-lib.readthedocs.io/en/latest/index.html#acknowledgements) section for more information. Currently the supported camera systems (arrays) are:
  * [Red-line Emission Geospace Observatory (REGO)](https://aurora-asi-lib.readthedocs.io/en/latest/imager_api.html#rego-asi)
  * [Time History of Events and Macroscale Interactions during Substorms (THEMIS)](https://aurora-asi-lib.readthedocs.io/en/latest/imager_api.html#module-asilib.asi.themis)
  * [Transition Region Explorer (TREx)](https://aurora-asi-lib.readthedocs.io/en/latest/imager_api.html#module-asilib.asi.trex)

  [Documentation](https://aurora-asi-lib.readthedocs.io/) | [Code on GitHub](https://github.com/mshumko/asilib) | [PyPI archive](https://pypi.org/project/asilib/) | [Zenodo archive](https://doi.org/10.5281/zenodo.4746446)

  ![A geographic map showing the spatial coverage (field of view rings) of all imagers supported by asilib.](https://github.com/mshumko/asilib/blob/main/docs/_static/global_coverage.png?raw=true)

  ![An asilib collage showing fisheye images, mapped images, and a keogram from the THEMIS and REGO imagers at RANK.](https://github.com/mshumko/asilib/blob/main/docs/_static/collage.png?raw=true)

  [And you can animate images & conjunctions!](https://aurora-asi-lib.readthedocs.io/en/latest/basics_tutorial.html#Satellite-conjunction)

  See more examples in the [online documentation](https://aurora-asi-lib.readthedocs.io/en/latest/examples.html)

  Your contributions and ideas are always welcome. The easiest way is to submit [Issues](https://github.com/mshumko/asilib/issues) or [Pull Requests](https://github.com/mshumko/asilib/pulls).


  Are in the [Acknowledgements](https://aurora-asi-lib.readthedocs.io/en/latest/index.html#acknowledgements) section of the online documentation.


pkgId: 9e121469d439b7739bf3d69d7f06561051f4a0e2e31904771bc73edcaba4ddb6
name: python-asimov
arch: src
version: 0.5.8
epoch: 0
release: 1
summary: A Python package for managing and interacting with data analysis jobs.
url: https://git.ligo.org/asimov/asimov
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asimov-0.5.8-1.src.rpm
checksum_type: sha256
description:
  Asimov is a workflow management and automation platform for scientific analyses.

  [Documentation](https://asimov.docs.ligo.org/asimov) · [Releases](https://git.ligo.org/asimov/asimov/-/releases) · [Issue Tracker](https://git.ligo.org/asimov/asimov/-/issues)

  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/ligo-asimov/badges/version.svg)](https://anaconda.org/conda-forge/ligo-asimov)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/ligo-asimov/badges/installer/conda.svg)](https://conda.anaconda.org/conda-forge)

  [![coverage report](https://git.ligo.org/asimov/asimov/badges/infrastructure-updates/coverage.svg)](https://git.ligo.org/asimov/asimov/-/commits/infrastructure-updates)

  Asimov was developed to manage and automate the parameter estimation analyses used by the LIGO, Virgo, and KAGRA collaborations to analyse gravitational wave signals, but it aims to provide tools which can be used for other workflows.

  Asimov has been used to organise and run the major catalogue analyses from the third observing run, O3, but it's designed to be flexible enough to allow new pipelines and analyses to be added to the framework.



  These notes relate to in-development features on this branch, and what's described here is only expected to be relevant during development.
  More generally useful documentation will move to the main documentation before moving to production.



  Run in ``asimov`` directory:

  ```
  export FLASK_APP=server
  flask run
  ```





  Asimov is able to interact with high throughput job management tools, and can submit jobs to clusters, monitor them for problems, and initiate post-processing tasks.



  Asimov provides an API layer which allows a single configuration to be deployed to numerous different analysis pipelines.
  Current gravitational wave pipelines which are supported are ``lalinference``, ``bayeswave``, ``RIFT``, and ``bilby``.



  Asimov records all ongoing, completed, and scheduled analyses, allowing jobs, configurations, and results to be found easily.



  Asimov can provide both machine-readible and human-friendly reports of all jobs it is monitoring, while collating relevant log files and outputs.



  Your results are important, and Asimov provides special tools to help manage the outputs of analyses as well as ensuring their veracity.



  Asimov makes setting-up and running parameter estimation jobs easier.
  It can generate configuration files for several parameter estimation pipelines, and handle submitting these to a cluster.
  Whether you're setting-up a preliminary analysis for a single gravitational wave event, or analysing hundreds of events for a catalog, Asimov can help.



  Asimov is written in Python, and is available on ``pypi``.
  It can be installed by running
  ```
  $ pip install asimov
  ```
  It is also available on conda, and can be installed by running
  ```
  $ conda install -c conda-forge ligo-asimov
  ```

  Asimov also requires that you have `git` installed on your machine, and that you've set it up by running:
  ```
  $ git config --global user.email "you@example.com"
  $ git config --global user.name "Your Name"
  ```



  Asimov supports a variety of different ways of running, but the simplest way, running a workflow on a local machine, can be set up with a single command.

  We start by setting up a project, which is a directory which keeps all of the analyses and the required metadata together.
  A project can include just a single event or a whole selection of events, for example if you're producing a catalogue.
  First create a directory to store your project:
  ```
  $ mkdir my-new-project
  $ cd my-new-project
  ```
  and then get asimov to set things up
  ```
  $ asimov init "Test project"
  ```
  where you can replace `"Test project"` with the name you want to give your project.
  A project will be set-up in your current working directory.

  In order to start setting up analyses we next need to download some default settings.

  An analysis is a pipeline run, and asimov supports `bayeswave`, `bilby` in the default installation.

  We'll download the default configurations for jobs which are going to be run on the LIGO data grid.
  We do this using the `asimov apply` command, which pulls-in data from a file either locally or online.

  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/defaults/production-pe.yaml
  ```

  and the load default priors the same way:
  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/defaults/production-pe-priors.yaml
  ```

  Now you can add an existing event, by downloading the event data settings using the `asimov apply` function, for example, to add GW150914 to the project you can run

  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/events/gwtc-2-1/GW150914_095045.yaml
  ```

  This downloads the settings which were used for analysing GW150914 for the GWTC-2.1 catalogue paper, and stores them in the ledger file in the project (`.asimov/ledger.yml`).

  Many analyses can be run on a single event (these are called "productions" in asimov parlence).
  We can add some pre-configured analyses by downloading some analysis configuration settings.

  ```
  $ asimov apply -f https://git.ligo.org/asimov/data/-/raw/main/analyses/production-default.yaml -e GW150914_095045
  ```
  Note that if you omit the `-e` argument asimov will ask which event the analyses should be applied to.


  You can now build and submit your jobs to the cluster.
  First use `asimov manage build` to create the configuration files for each analysis:
  ```
  $ asimov manage build
  ```
  These will be added to the git repositories in the `checkouts` directory inside the project directory.
  You then submit the jobs to the cluster by running
  ```
  $ asimov manage submit
  ```

  It will normally take a long time for a parameter estimation job to finish, but you can get asimov to check up on it by running
  ```
  $ asimov monitor
  ```
  If the job is finished `asimov` will start post-processing using `PESummary`, and if it's fallen over it will attempt to fix the problem and resubmit it to the cluster.
  If the post-processing has finished it will move the results to a read-only directory.

  You can also set the asimov monitor to automatically check the status of the job every 15 minutes by running
  ```
  $ asimov start
  ```
  which will automatically start any post-processing, and start any jobs once their dependencies are met.
  You can stop this automatic monitoring process any time by running
  ```
  $ asimov stop
  ```

  For a full description of the workflow management process see the documentation.




  Great! We're always looking for help with developing asimov!
  Please take a look at our [contributors' guide](CONTRIBUTING.rst) to get started!






  While Asimov already supports a large number of pre-existing pipelines, and provides a straightforward interface for adding new pipelines, we also intend to support pipelines constructed using [gravitic](https://github.com/transientlunatic/gravitic), allowing experimental tools to be used without constructing an entire new pipeline, while also allowing asimov to manage the training of machine learning algorithms.




  Asimov will allow an existing workflow to be duplicated, in a similar way to a ``git clone``, and then extended, with new jobs gaining access to the completed jobs in the workflow.
  It will also allow entire workflows to be re-run, providing a straightforward way to replicate results, or make minor modifications.




  Asimov is made by the LIGO, Virgo, and KAGRA collaborations.
  The primary maintainer of the project is Daniel Williams.
  Its development is supported by the Science and Technology Facilities Council.


pkgId: 5c89bb75472d64dcfd8de04693d33aa1460ca6c6a0aff6e00a2be83e6057bf26
name: python-asimov-gwdata
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: An asimov plugin to make downloading gravitational wave data easier
url: https://pypi.org/project/asimov-gwdata/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asimov-gwdata-0.4.1-1.src.rpm
checksum_type: sha256
description:
  This package provides an asimov pipeline for collecting published gravitational wave data for use in parameter estimation studies.





  To download a posterior file from a known location you'll need to write a YAML configuration file, for example,

  ```yaml
  data:
    - posterior
  source:
    type: pesummary
    location: /home/daniel/GW150914/test.h5
    analysis: C01:IMRPhenomXPHM
  ```

  and then run

  `$ gwdata --settings test.yaml`
  where `test.yaml` is the configuration file above.



  The script can also be called as a pipeline in asimov.
  To do this you'll need to apply a blueprint to the project, for example:

  ```yaml
  kind: analysis
  name: get-data
  pipeline: gwdata
  download:
    - posterior
  event: GW150914
  source:
    type: pesummary
    location: /home/daniel/<event>/test.h5
    analysis: C01:IMRPhenomXPHM
  ```


pkgId: 0c8731babd014e41061272bcb26a144ee6a7c4026fa7b878516c5ea2ab602744
name: python-asimplevectors
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Python client library for interacting with asimplevectors API.
url: https://github.com/billionvectors/client_api.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asimplevectors-0.1.1-1.src.rpm
checksum_type: sha256
description:
  asimplevectors Client is a Python package providing an asynchronous API client to interact with the asimplevectors service, supporting vector management, search, space configuration, and RBAC-based security.



  - **Space Management**: Create, update, delete, and list spaces with flexible configurations.
  - **Versioning**: Manage versions for spaces, including creating and retrieving specific versions.
  - **Vector Operations**: Upsert, retrieve, and search vectors with support for numpy arrays and lists.
  - **RBAC Security**: Manage tokens for role-based access control (RBAC) and apply them to secure API calls.
  - **Snapshot Management**: Create and manage snapshots of vector spaces.
  - **Async Support**: Fully asynchronous API for high-performance applications.



  pip installation will be supported soon.


  - [asimplevectors](https://github.com/billionvectors/asimplevectors)
  - Python 3.8+
  - Dependencies listed in requirements.txt



  ```python
  from asimplevectors.client import ASimpleVectorsClient


  client = ASimpleVectorsClient(host="localhost", port=21001)


  async with client:
      ...
  ```

  ```python
  import asyncio

  async def main():
      client = ASimpleVectorsClient(host="localhost")

      
      create_space_data = {
          "name": "spacename",
          "dimension": 128,
          "metric": "L2"
      }
      await client.create_space(create_space_data)
      print("Space created successfully.")

      
      spaces = await client.list_spaces()
      print("Available spaces:", spaces)

      await client.close()

  asyncio.run(main())
  ```

  ```python
  import numpy as np
  import asyncio

  async def vector_operations():
      client = ASimpleVectorsClient(host="localhost")

      
      vector_data = {
          "vectors": [
              {"id": 1, "data": np.array([0.1, 0.2, 0.3, 0.4]), "metadata": {"label": "first"}}
          ]
      }
      await client.create_vector("spacename", vector_data)
      print("Vector upserted successfully.")

      
      vectors = await client.get_vectors_by_version("spacename", version_id=0)
      print("Retrieved vectors:", vectors)

      await client.close()

  asyncio.run(vector_operations())
  ```

  ```python
  async def manage_tokens():
      client = ASimpleVectorsClient(host="localhost")

      
      token_data = {
          "user_id": 1,
          "space": 2,
          "vector": 2
      }
      await client.create_rbac_token(token_data)
      print("Token created successfully.")

      
      tokens = await client.list_rbac_tokens()
      print("Available tokens:", tokens)

      await client.close()

  asyncio.run(manage_tokens())
  ```


  1. Setup [asimplevectors](https://github.com/billionvectors/asimplevectors) server from docker
  ```bash
  docker pull billionvectors/asimplevectors:0.2.0
  docker run -p 21001:21001 -p 21002:21002 asimplevectors:0.2.0
  ```

  2. Clone the repository:
  ```bash
  git clone https://github.com/billionvectors/client_api.git
  cd client_api
  ```

  3. Run test
  ```bash
  cd python
  ./run_example.sh search
  ```


pkgId: 4a369fbe03c0d6217e852cdfbcf76a4ef0d239c0ff7e69d7ecd80efd742590f6
name: python-asimtote
arch: src
version: 0.16.14
epoch: 0
release: 1
summary: Compare network device configuration files using contextual structures
url: https://gitlab.developers.cam.ac.uk/uis/netsys/udn/asimtote
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asimtote-0.16.14-1.src.rpm
checksum_type: sha256
description:
  This package contains two main elements used to compare text-based
  configuration files (or other files in simple text in a similar format) where
  they are structured using indented blocks of directives/commands, typically for
  network devices:
  * a parser to read in configuration files and stored them in a dictionary --
    the parser utilises the hierarchical nature of the configuration to
    understand that the same command name might mean different things in
    different contexts
  * a comparator that takes two configuration dictionaries (typically produced by
    the parser, above) - a source and a target configuration - and writes out
    a configuration file (or update command set) to transform the source
    configuration into the destination - this uses a series of 'converters' to
    handle the difference for each configuration element (e.g. changing the
    description assigned to an interface)
  Each of these are written as abstract base classes that can be inherited from
  to crete concrete classes for each platform, but the base processing of the
  parsing and comparing should be consistent, requiring only the specific
  commands to be handled.
  Currently, Cisco IOS is the only concrete platform and only a subset so far
  (the comparator is still being tweaked to handle this all relatively
  straightforwardly, before all the commands are implemented).  There are
  currently some odd commands and edge cases which are awkward to handle without
  some improvements to the core process.
  The scripts also support a system whereby 'excludes' can be specified, to
  exclude those elements of the configuration dictionary which should not be
  compared, if a known difference exists that cannot be resolved, either as an
  interim divergence, or a permanent exception.


pkgId: 9fdf7eed068f23d0ad2a3dc1f1fa98145be2b3348e92300268ad1d6b99785ae7
name: python-ask-orex
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: ASK-Orex: Ordinary human-friendly Regular Expressions
url: https://github.com/HCelion/orex
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ask-orex-1.1.2-1.src.rpm
checksum_type: sha256
description:
  ASK-Orex is a package designed to simplify regular expressions in Python. It provides a high-level interface for constructing and working with regular expressions, making it easier and more intuitive to use.

  The package is heavily inspired by Richy Cotton's `rebus` package for the `R` language.



  You can install Orex using pip:

  ```shell
  pip install ask-orex
  ```

  To use Orex, import the `ask-orex` package into your Python script:

  ```python
  import ask_orex as ox
  ```




  The easiest regular expression is just a literal string to be found.

  ```python
  s = 'Hello World'
  pattern = ox.literal('Hello')
  pattern.is_match(s)
  ```
  ```python
  True
  ```

  Orex regular expressions are extended by simply using a `+`.
  A slightly more useful example is to find a hex colour

  ```python
  pattern = ox.literal('#') + ox.HEXDIGIT + ox.HEXDIGIT +\
   ox.HEXDIGIT + ox.HEXDIGIT + ox.HEXDIGIT + ox.HEXDIGIT

  s_hex = 'This package is #a83232 hot'
  pattern.is_match(s_hex)
  ```
  ```python
  True
  ```
  ```python
  pattern.findall(s_hex)
  ```

  ```python
  ['#a83232']
  ```

  On the other hand
  ```python
  s_nonhex = 'Just a twitter handle: #Red123'
  pattern.is_match(s_nonhex)
  ```

  ```python
  False
  ```
  ```python
  pattern.findall(s_nonhex)
  ```

  ```python
  []
  ```

  Clearly, the pattern is somewhat burdensome. We can alternatively write it like this
  ```python
  pattern = ox.literal('#') + ox.repeat(ox.HEXDIGIT, 6)
  ```
  or
  ```python
  pattern = ox.literal('#') + ox.n_or_more(ox.HEXDIGIT, min=6, max=6)
  ```



  Most of `orex` functions accept other regular expressions as characters.

  Say we want to find a regex to parse emails. We can define first all email allowed characters
  ```python
  allowed_characters = ox.character_class(ox.ALNUM + ox.DASH + '_' + ox.DOT)
  ```
  where `ox.ALNUM` are just all letters and numbers. Note that the `_` is just used as a string.
  In Orex it is okay to use strings as part of the pattern, unless they are at the start, where we use `ox.literal` to show python that we mean pattern business. Whenever we want to use the `.` or `_` explicitly, it is best to use `ox.DOT` or `ox.DASH`, since `.` and `-` can have a special meaning in regular expression.

  Next we define

  ```python
  user_name = ox.one_or_more(allowed_characters)
  domain_name = ox.one_or_more(allowed_characters)
  extension = ox.n_or_more(ox.ALPHA,2,4)

  email_pattern =  user_name + '@' + domain_name + ox.DOT + extension
  ```
  ```python
  email = 'captainspamalot@funnyspammail.com'
  ```
  And indeed

  ```python
  email_pattern.is_match(email)
  ```
  ```
  True
  ```



  If we want to extract the individual components of a match, we have to capture them first.
  Using the email example above, we can just change the code to

  ```
  email_pattern =  ox.capture(user_name) + '@' + ox.capture(domain_name) \
                  + ox.DOT + ox.capture(extension)
  ```

  ```
  email_pattern.findall(email)
  ```
  returns
  ```
  [('captainspamalot', 'funnyspammail', 'com')]
  ```
  Handy indeed! We can also name the individual components for even easier extraction

  ```python
  email_pattern =  ox.capture(user_name,'user') \
                + '@' + ox.capture(domain_name,'domain') \
                + ox.DOT + ox.capture(extension,'ext')
  ```

  We can now use the `group_dict` method for even easier access
  ```python
  email_pattern.group_dict(email)
  ```
  ```
  {'user': 'captainspamalot', 'domain': 'funnyspammail', 'ext': 'com'}
  ```

  Capturing has another benefit, namely that we can use it to find repeated patterns with the `ox.backreference` function
  ```python
  tag_name = ox.one_or_more(allowed_characters)
  content = ox.one_or_more(ox.ANY_CHAR)
  tag_pattern = ox.literal('<') + ox.capture(tag_name, 'tag') + '>' \
            + ox.capture(content,'content') + '</' +ox.backreference(name='tag')+'>'

  message = '<name>Sir Snakington</name>'
  tag_pattern.group_dict(message)
  ```

  ```
  {'tag': 'name', 'content': 'Sir Snakington'}
  ```

  Back references can also be used to substitute patterns, though here the named backreference does not work. Instead, the backrefence uses the index of the reference in the pattern.

  ```python
  tag_pattern = ox.literal('<') + ox.capture(tag_name) + '>' + ox.capture(content) + '</' +ox.backreference(1)+'>'
  replace_pattern = ox.literal('<') + ox.backreference(2) + '>' + ox.backreference(1) + ox.literal('<') + ox.backreference(2) + '>'
  tag_pattern.sub(message, replace_pattern)
  ```

  ```python
  '<Sir Snakington>name<Sir Snakington>'
  ```


pkgId: 1521a69d76cb296a597d2c669964be1f52a6dfd6c74f90c268a38f4ebd4ab105
name: python-ask-schools
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: Ask Scholars Portal School Name Conversion
url: https://github.com/guinslym/ask_schools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ask-schools-0.3.6-1.src.rpm
checksum_type: sha256
description:
  [
  ![PyPI](https://img.shields.io/pypi/v/ask_schools.svg)
  ![PyPI](https://img.shields.io/pypi/pyversions/ask_schools.svg)
  ![PyPI](https://img.shields.io/github/license/guinslym/ask_schools.svg)
  ](https://pypi.org/project/ask_schools/)
  [![TravisCI](https://travis-ci.org/guinslym/ask_schools.svg?branch=master)](https://travis-ci.org/guinslym/ask_schools)


  This package helps convert Ask School suffixes to the school full name.




  **Ask Schools** can be installed from PyPI using `pip` or your package manager of choice:

  ```
  pip install ask_schools
  ```




  Example:

  ```python

  from ask_schools import find_school_by_operator_suffix

  def test_check_school_name_equal_toronto():
    result = find_school_by_operator_suffix('_tor')
    assert result == 'Tordonto'
  ```



  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/).


pkgId: 4814ba5b075cc7b7b74d7f606b44d290752e4003c03ca64117830d253c712bc0
name: python-ask-sdk
arch: src
version: 1.19.0
epoch: 0
release: 1
url: https://github.com/alexa/alexa-skills-kit-sdk-for-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ask-sdk-1.19.0-1.src.rpm
checksum_type: sha256
summary:
  The ASK SDK Standard package provides a full distribution of the SDK, all batteries included, for building Alexa Skills.


pkgId: 08179b85bea0b2ef7e19f155a1cee7a34014743806cddd88554a0ef28f235fa7
name: python-ask-sdk-dynamodb-persistence-adapter
arch: src
version: 1.19.0
epoch: 0
release: 1
url: https://github.com/alexa/alexa-skills-kit-sdk-for-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ask-sdk-dynamodb-persistence-adapter-1.19.0-1.src.rpm
checksum_type: sha256
summary:
  The ASK SDK DynamoDB Persistence Adapter package provides DynamoDB Adapter, that can be used with ASK SDK Core, for persistence management.


pkgId: bb77cd173ea01bd8da949181574de3544a78e71e3fa2852d4fc9d88a1ac22ae4
name: python-ask-sdk-runtime
arch: src
version: 1.19.0
epoch: 0
release: 1
url: https://github.com/alexa/alexa-skills-kit-sdk-for-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ask-sdk-runtime-1.19.0-1.src.rpm
checksum_type: sha256
summary:
  The ASK SDK Runtime package provides runtime componentsthat act as fundamental implementation layer for ASK SDKpackages


pkgId: ffc391af58095741940bc8a6df483d400a956ecb5f1269950edb83023c69b030
name: python-ask-sdk-webservice-support
arch: src
version: 1.3.3
epoch: 0
release: 1
url: https://github.com/alexa/alexa-skills-kit-sdk-for-python
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ask-sdk-webservice-support-1.3.3-1.src.rpm
checksum_type: sha256
summary:
  The ASK SDK Webservice package provides support for running skills, built using the Alexa Skills Kit SDK, as web applications.


pkgId: 73189ffcdb221ba5c72be811596d82bf0db5d5ae0cf0e310894a545db7e731b4
name: python-askanna
arch: src
version: 0.24.0
epoch: 0
release: 1
url: https://askanna.io
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askanna-0.24.0-1.src.rpm
checksum_type: sha256
summary:
  The AskAnna CLI & Python SDK is part of the AskAnna platform to kickstart your data science projects

description:
  The AskAnna CLI offers a command line interface to the AskAnna platform. With the Python SDK you can run AskAnna
  functions directly from your Python script. The CLI & Python SDK simplifies the communication with the AskAnna
  platform and provides facilities for supporting every part of a data science project.

  [![PyPI](https://img.shields.io/pypi/v/askanna.svg?color=%2334D058)](https://pypi.org/project/askanna/)
  [![Python](https://img.shields.io/pypi/pyversions/askanna.svg?color=%2334D058)](https://pypi.org/project/askanna/)
  [![License](https://img.shields.io/badge/License-BSD_3--Clause-brightgreen.svg?label=license)](https://gitlab.com/askanna/askanna-python/-/blob/master/LICENSE)
  [![Documentation](https://img.shields.io/badge/docs-available-success.svg)](https://docs.askanna.io/)



  For the latest information check the [AskAnna Documentation](https://docs.askanna.io/). Or open directly the
  documentation for:

  * [Command line (CLI)](https://docs.askanna.io/cli/)
  * [Python SDK](https://docs.askanna.io/python-sdk/)





  ```bash
  pip install askanna
  ```



  ```bash
  pip install -U askanna
  ```



  ```bash
  askanna login
  ```

  This will create a `.askanna.yml` in your home directory.



  When the AskAnna CLI & Python SDK is used in for example a CI/CD, one can configure authentication by setting an
  environment variable:

  ```bash
  export AA_REMOTE=https://beta-api.askanna.eu
  export AA_TOKEN={{ API TOKEN }}
  ```

  The API token can be found in the created `~/.askanna.yml` file after you logged in with `askanna login`.



  Run the innit-command on the main directory of your project. The command will create a new project on AskAnna and will
  add a `askanna.yml` file to your local project directory. In the `askanna.yml` file you can configure jobs. For more
  information, see the [askanna.yml documentation](https://docs.askanna.io/code/#askannayml).

  ```bash
  askanna init
  ```

  If you want to start a project from scratch (or a template), you can run the create-command.

  ```bash
  askanna create
  ```

  With the push-command your code will be uploaded to the project in AskAnna.

  ```bash
  askanna push
  ```



  To track metrics for your runs, you can use the function `track_metric`. For more information, see the
  [metrics documentation](https://docs.askanna.io/metrics/).

  ```python
  from askanna import track_metric

  track_metric("name", "value")
  ```



  To track variables for your runs, you can use the function `track_variable`. For more information, see the
  [variables documentation](https://docs.askanna.io/variable/tracking/).

  ```python
  from askanna import track_variable

  track_variable("name", "value")
  ```


pkgId: 54abf44629835b31ed980a2b5e5ba0107552511db7c248c742bf8be204078d2b
name: python-askbot
arch: src
version: 0.12.2
epoch: 0
release: 1
summary: Question and Answer forum, like StackOverflow, written in python and Django
url: http://askbot.org
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askbot-0.12.2-1.src.rpm
checksum_type: sha256
description:
  * standard Q&A functionalities including votes, reputation system, etc.
  * user levels: admin, moderator, regular, suspended, blocked
  * per-user inbox for responses & flagged items (for moderators)
  * email alerts - instant and delayed, optionally tag filtered
  * search by full text and a set of tags simultaneously
  * imports data from StackExchange, Jive, ZenDesk


pkgId: 2dbfbc33ae2f489d9542df207b54c7e1093566a0a3c3c59d270be4827a94b801
name: python-askedith
arch: src
version: 0.31.2
epoch: 0
release: 1
summary: Natural Language Query Engine for Pandas
url: https://askedith.ai
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askedith-0.31.2-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <br>
      <br>
      <br>
      <a href="https://askedith.ai">
          <img
              src="https://media-exp2.licdn.com/dms/image/C560BAQFxV92mCa43Eg/company-logo_200_200/0/1656093924337?e=1665619200&v=beta&t=yY1oHTgLHavsDDV9nALJjuGrVxG-GaiWvuyxgs4ohg4"
              alt="AskEdith logo: AskEdith is a Natural Language Query Engine"
              width="200px"
          >
      </a>
      <br>
      <br>
  </p>

  <p align="center">
      <b>Natural Language Query Engine for Pandas</b>
      <br>
      <br>
      <a href="https://discord.gg/dyPry7j2qs">
          <img
              src="https://img.shields.io/badge/Discord-Join-%237289DA?style=flat-square&logo=appveyor"
              alt="Badge"
          >
      </a>
      <a href="https://pypi.org/project/askedith/">
          <img
              src="https://img.shields.io/badge/Release-0.31.2-blue?style=flat-square&logo=appveyor"
              alt="Badge"
          >
      </a>
      <a href="https://pypi.org/project/askedith/">
          <img
              src="https://img.shields.io/badge/CI%2FCD-passing-green?style=flat-square&logo=appveyor"
              alt="Badge"
          >
      </a>
  </p>

  AskEdith is a data analytics question-answering system that can help you speed up your data analytics workflows. AskEdith converts your natural language questions into SQL queries that are used to return a computed DataFrame.



  1. ETL / Ingress - AskEdith ingresses data and parses schema and metadata.
  2. Semantic Search to relate relevant sections of data to the question.
  3. NLP Language Model to convert natural language to SQL.
  4. Execute on input DataFrame and return results.



  ```bash
  pip install askedith
  ```



  ```python
  import pandas as pd
  import askedith


  df = pd.read_csv("https://figshare.com/ndownloader/files/35259799")


  df = df.askedith.ask("What's the average price for organic avocados?")

  print(df)
  ```



  [![Example](https://i.imgur.com/JVnJiyM.png)](https://i.imgur.com/JVnJiyM.png)
  [![Example](https://i.imgur.com/qHqSBCh.png)](https://i.imgur.com/qHqSBCh.png)


pkgId: 7dd092be7d7b61aac1a28416ffcb2f6e9282d980dd0e818c4d00f054ff040192
name: python-asklora-portal
arch: src
version: 1.1.13
epoch: 0
release: 1
summary: portal to use various api data service
url: https://pypi.org/project/asklora-portal/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asklora-portal-1.1.13-1.src.rpm
checksum_type: sha256
description:
  Shared utilities and helper classes used in Asklora projects



  1. Clients for external services (MarketData, Broker, PriceData, DAMECAClient, DAMFBClient) and their supporting classes (DAM, pydantic models for xml serialising and de-serialising)
  2. Helper classes (SingletonMeta, ExtendedEnum, PGPHelper)
  3. Helper functions (deep_get, get_file_size, get_file_sha1)







  - `BROKER_API_URL=brokerurl`
  - `MARKET_API_URL=market url`
  - `BROKER_KEY=key`
  - `BROKER_SECRET=secret`



  ```python
  from asklora import Broker

  broker = Broker()
  broker.create_account(...)
  ```

  or you can use our Portal class to get the specific model

  ```python
  import asklora

  portal = asklora.Portal()

  rest = portal.get_broker_client() # get a REST client for trade, user, position , order
  marketrest = portal.get_market_client() # get a REST client for market data
  eventclient = portal.get_event_client() # get an event client for trade, user, position, order
  ```





  - `IEX_API_URL`
  - `IEX_TOKEN`



  ```python
  from asklora import PriceData

  price_data = PriceData()
  price_data.get_lastestPrice("MSFT")
  ```





  - `DAM_URL`
  - `DAM_CSID`



  For these clients, you can find the Pydantic models needed by some of the class methods in the `models` and `enums` module.

  for example, in the `DAMECAClient`, in the `generate_application_payload` method, the first argument accepts `DAMApplicationPayload` model that will automatically processed to xml the API endpoint needs.



  - DAMECAClient

    ```python
    from asklora import DAMECAClient, PGPHelper
    from asklora.models import DAMApplicationPayload

    client = DAMECAClient()

    
    payload = DAMApplicationPayload(
        user_id=56,
        first_name="Jane",
        last_name="Smith",
        ...
    )

    
    pgp_helper = PGPHelper(
        private_key_path=...,
        public_key_path=...,
        remote_public_key_path=...,
    )

    
    client.create_account(payload, pgp_helper=pgp_helper)
    ```

  - DAMFBClient

    ```python
    from asklora import DAMFBClient, PGPHelper
    from asklora.models import InstructionSet, InternalCashTransfer, CancelTransaction

    client = DAMFBClient()

    instruction_set = InstructionSet(
        instructions=[
            InternalCashTransfer(
               id=4,
               source="U199516",
               destination="U34516",
               amount=1000,
               currency="USD",
            ),
            CancelTransaction(
               id=5,
               ib_instr_id="3",
               reason="Wrong destination",
            ),
        ]
    )
    pgp_helper = PGPHelper(
        private_key_path=...,
        public_key_path=...,
        remote_public_key_path=...,
    )

    client.create_instruction(instruction_set, pgp_helper=pgp_helper)

    
    payload = """<?xml version="1.0" encoding="UTF-8"?>
    <instruction_set
      xmlns="http://www.interactivebrokers.com/fbfb_instruction_set"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.interactivebrokers.com/fbfb_instruction_set fbfb_instruction_set.xsd "
      creation_date="2019-01-11" id="2450" version="1">
      <close_account id="2450">
          <client_ib_acct_id>U1234567</client_ib_acct_id>
          <close_reason> No longer needed </close_reason>
      </close_account>
    </instruction_set>"""

    client.create_instruction(payload, pgp_helper=pgp_helper)
    ```

  - Both

    You can also initialise one or both of the classes above like this:

    ```python
    from asklora import IBClient

    eca_client = IBClient.get_ECA_client()
    fb_client = IBClient.get_FB_client()
    ```


pkgId: 4ff26bade8bab62e75b3129f761883049abd0fcdee785739e1d5479505eb551d
name: python-asksageclient
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: Ask Sage Python Client API
url: https://github.com/Ask-Sage/asksage-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asksageclient-1.2.4-1.src.rpm
checksum_type: sha256
description:
  This is the official Python client for the Ask Sage API. It allows you to interact with the Ask Sage service, providing a simple and pythonic way to make requests to the service.

  Check Ask Sage API documentation here:

  Ask Sage User API: https://app.swaggerhub.com/apis-docs/NICOLASCHAILLAN_1/user-api/1.0

  Ask Sage Server API: https://app.swaggerhub.com/apis-docs/NICOLASCHAILLAN_1/server_ask-sage_api/1.0



  You can install the Ask Sage Python client via pip:

  pip install asksageclient



  First, import the client:

  from asksageclient import AskSageClient

  Then, instantiate the client:

  client = AskSageClient('your_email_here', 'your_api_key_here')
  Warning: Do not store credentials in code, use environment variables/secrets instead

  Now, you can use the client to interact with the Ask Sage service. For example, to interact with the main endpoint:

  response = client.query(message='Who is Nic Chaillan?')

  print(response)



  The client provides methods for all the Ask Sage API endpoints:

  - `get_models`
  - `add_dataset`
  - `delete_dataset`
  - `assign_dataset`
  - `get_user_logs`
  - `get_user_logins`
  - `query`
  - `query_plugin`
  - `execute_plugin`
  - `follow_up_questions`
  - `tokenizer`
  - `get_personas`
  - `get_datasets`
  - `get_plugins`
  - `count_monthly_tokens`
  - `count_monthly_teach_tokens`
  - `train`
  - `train_with_file`
  - `file`

  Each method corresponds to an endpoint of the Ask Sage API. The `content` parameter should be a dictionary containing the data you want to send in the request body.



  The client includes basic error handling. If a request fails, it will print an error message and return `None`.



  Contributions are welcome! Please submit a pull request or create an issue to contribute to this project.



  See the LICENSE file for details.


pkgId: 6c16e8560afaa00e790925c3b7b93f6957148af8277faf97e94e48a72f3abbc0
name: python-asktable
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: The official Python library for the asktable API
url: https://github.com/DataMini/asktable-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asktable-3.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/asktable.svg)](https://pypi.org/project/asktable/)

  The Asktable Python library provides convenient access to the Asktable REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [docs.asktable.com](https://docs.asktable.com). The full API of this library can be found in [api.md](https://github.com/DataMini/asktable-python/tree/main/api.md).



  ```sh

  pip install asktable
  ```



  The full API of this library can be found in [api.md](https://github.com/DataMini/asktable-python/tree/main/api.md).

  ```python
  from asktable import Asktable

  client = Asktable()

  datasource = client.datasources.create(
      engine="mysql",
  )
  print(datasource.id)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `ASKTABLE_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncAsktable` instead of `Asktable` and use `await` with each API call:

  ```python
  import asyncio
  from asktable import AsyncAsktable

  client = AsyncAsktable()


  async def main() -> None:
      datasource = await client.datasources.create(
          engine="mysql",
      )
      print(datasource.id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  List methods in the Asktable API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from asktable import Asktable

  client = Asktable()

  all_datasources = []

  for datasource in client.datasources.list():
      
      all_datasources.append(datasource)
  print(all_datasources)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from asktable import AsyncAsktable

  client = AsyncAsktable()


  async def main() -> None:
      all_datasources = []
      
      async for datasource in client.datasources.list():
          all_datasources.append(datasource)
      print(all_datasources)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.datasources.list()
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.items)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.datasources.list()

  print(f"page number: {first_page.page}")  # => "page number: 1"
  for datasource in first_page.items:
      print(datasource.id)


  ```



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `asktable.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `asktable.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `asktable.APIError`.

  ```python
  import asktable
  from asktable import Asktable

  client = Asktable()

  try:
      client.datasources.create(
          engine="mysql",
      )
  except asktable.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except asktable.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except asktable.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from asktable import Asktable


  client = Asktable(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).datasources.create(
      engine="mysql",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from asktable import Asktable


  client = Asktable(
      
      timeout=20.0,
  )


  client = Asktable(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).datasources.create(
      engine="mysql",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/DataMini/asktable-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `ASKTABLE_LOG` to `debug`.

  ```shell
  $ export ASKTABLE_LOG=debug
  ```



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from asktable import Asktable

  client = Asktable()
  response = client.datasources.with_raw_response.create(
      engine="mysql",
  )
  print(response.headers.get('X-My-Header'))

  datasource = response.parse()  # get the object that `datasources.create()` would have returned
  print(datasource.id)
  ```

  These methods return an [`APIResponse`](https://github.com/DataMini/asktable-python/tree/main/src/asktable/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/DataMini/asktable-python/tree/main/src/asktable/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.datasources.with_streaming_response.create(
      engine="mysql",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from asktable import Asktable, DefaultHttpxClient

  client = Asktable(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/DataMini/asktable-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import asktable
  print(asktable.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/DataMini/asktable-python/tree/main/./CONTRIBUTING.md).


pkgId: 3e928049a68e0becf78eb0bcdc07940f017ec7e67ffc0c574af54ade902ca13f
name: python-asktanya
arch: src
version: 1.0.17
epoch: 0
release: 1
summary: Ask-tanya anything! Asktanya is a Python framework to search factual information on the internet.
url: https://pypi.org/project/asktanya/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asktanya-1.0.17-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Welcome to asktanya 👋</h1>
  <p>
    <img alt="Version" src="https://img.shields.io/badge/version-1.0.4-blue.svg?cacheSeconds=2592000" />
    <a href="github.com/liviaellen/asktanya" target="_blank">
      <img alt="Documentation" src="https://img.shields.io/badge/documentation-yes-brightgreen.svg" />
    </a>
    <a href="#" target="_blank">
      <img alt="License: MIT License" src="https://img.shields.io/badge/License-MIT License-yellow.svg" />
    </a>
  </p>

  > Ask-tanya anything! Asktanya is a framework to search factual information on the internet.





  ![alt text](https://github.com/liviaellen/asktanya/blob/master/image/example.png?raw=true)


  ```sh
  pip install asktanya
  ```


  ```sh
  ask-tanya
  ```


  ```python
  import asktanya
  from asktanya.main import ask_tanya
  ask_tanya("Why is the earth round")
  ```



  👤 **Livia Ellen**

  * Website: liviaellen.com
  * Github: [@liviaellen](https://github.com/liviaellen)
  * LinkedIn: [@liviaellen](https://linkedin.com/in/liviaellen)



  Contributions, issues and feature requests are welcome!<br />Feel free to check [issues page](https://github.com/liviaellen/asktanya/issues).



  Give a ⭐️ if this project helped you!

  ***
  _Generated with ❤️ and coffee_


pkgId: 15915fab59275f211df2bc0bf8d0c5211a68ca87a8e48fb0f70f9e0c349de37d
name: python-askui
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: Automate computer tasks in Python
url: https://pypi.org/project/askui/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askui-0.1.4-1.src.rpm
checksum_type: sha256
description:
  ⚡ Automate computer tasks in Python ⚡

  [![Release Notes](https://img.shields.io/github/release/askui/vision-agent?style=flat-square)](https://github.com/askui/vision-agent/releases)
  [![PyPI - License](https://img.shields.io/pypi/l/langchain-core?style=flat-square)](https://opensource.org/licenses/MIT)

  Join the [AskUI Community](https://community.askui.com).





  Agent OS is a device controller that allows agents to take screenshots, move the mouse, click, and type on the keyboard across any operating system.

  <details>
    <summary>Windows</summary>

    

  [AskUI Installer for AMD64](https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-Installer-Win-AMD64-Full.exe)



  [AskUI Installer for ARM64](https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-Installer-Win-ARM64-Full.exe)
  </details>


  <details>
    <summary>Linux</summary>

    **⚠️ Warning:** Agent OS currently does not work on Wayland. Switch to XOrg to use it.



  ```shell
  curl -o /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-x64-Full.run https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-User-Installer-Linux-x64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-x64-Full.run
  ```




  ```shell
  curl -o /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-ARM64-Full.run https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-User-Installer-Linux-ARM64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-ARM64-Full.run
  ```
  </details>


  <details>
    <summary>MacOS</summary>

  ```shell
  curl -o /tmp/AskUI-Suite-24.9.1-User-Installer-MacOS-ARM64-Full.run https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-User-Installer-MacOS-ARM64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-24.9.1-User-Installer-MacOS-ARM64-Full.run
  ```
  </details>




  ```shell
  pip install askui
  ```



  Set the `ANTHROPIC_API_KEY` environment variable to access the [Claude computer use model](https://docs.anthropic.com/en/docs/build-with-claude/computer-use). (Create a Anthropic key [here](https://console.anthropic.com/settings/keys))

  <details>
    <summary>Linux & MacOS</summary>

    Use export to set an evironment variable:

    ```shell
    export ANTHROPIC_API_KEY=<your-api-key-here>
    ```
  </details>

  <details>
    <summary>Windows PowerShell</summary>

    Set an environment variable with $env:

    ```shell
    $env:ANTHROPIC_API_KEY="<your-api-key-here>"
    ```
  </details>



  ```python
  from askui import VisionAgent


  with VisionAgent() as agent:
      
      agent.tools.webbrowser.open_new("http://www.google.com")

      
      agent.click("url bar")
      agent.type("http://www.google.com")
      agent.keyboard("enter")

      
      datetime = agent.get("What is the datetime at the top of the screen?")
      print(datetime)

      
      agent.act("search for a flight from Berlin to Paris in January")
  ```



  Under the hood agents are using a set of tools. You can also directly access these tools.



  The controller for the operating system.

  ```python
  agent.tools.os.click("left", 2) # clicking
  agent.tools.os.mouse(100, 100) # mouse movement

  ```



  The webbrowser tool powered by [webbrowser](https://docs.python.org/3/library/webbrowser.html) allows you to directly access webbrowsers in your environment.

  ```python
  agent.tools.webbrowser.open_new("http://www.google.com")

  ```



  The clipboard tool powered by [pyperclip](https://github.com/asweigart/pyperclip) allows you to interact with the clipboard.

  ```python
  agent.tools.clipboard.copy("...")
  result = agent.tools.clipboard.paste()
  ```



  You want a better understanding of what you agent is doing? Set the `log_level` to DEBUG.

  ```python
  import logging

  with VisionAgent(log_level=logging.DEBUG) as agent:
      agent...
  ```



  You have multiple monitors? Choose which one to automate by setting `display` to 1 or 2.

  ```python
  with VisionAgent(display=1) as agent:
      agent...
  ```




  **AskUI Vision Agent** is a versatile AI powered framework that enables you to automate computer tasks in Python.

  It connects Agent OS with powerful computer use models like Anthropic's Claude Sonnet 3.5 v2 and the AskUI Prompt-to-Action series. It is your entry point for building complex automation scenarios with detailed instructions or let the agent explore new challenges on its own.


  ![image](docs/assets/Architecture.svg)


  **Agent OS** is a custom-built OS controller designed to enhance your automation experience.

   It offers powerful features like
   - multi-screen support,
   - support for all major operating systems (incl. Windows, MacOS and Linux),
   - process visualizations,
   - real Unicode character typing

  and more exciting features like application selection, in background automation and video streaming are to be released soon.


pkgId: 3cdeab0bbdb04330f3bb978f1702774f6545f29709ef8d30f12829144d023007
name: python-askui
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Automate computer tasks in Python
url: https://pypi.org/project/askui/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askui-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ⚡ Automate computer tasks in Python ⚡

  [![Release Notes](https://img.shields.io/github/release/askui/vision-agent?style=flat-square)](https://github.com/askui/vision-agent/releases)
  [![PyPI - License](https://img.shields.io/pypi/l/langchain-core?style=flat-square)](https://opensource.org/licenses/MIT)

  Join the [AskUI Discord](https://discord.gg/Gu35zMGxbx).





  Agent OS is a device controller that allows agents to take screenshots, move the mouse, click, and type on the keyboard across any operating system.

  <details>
    <summary>Windows</summary>

    

  [AskUI Installer for AMD64](https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-Installer-Win-AMD64-Full.exe)



  [AskUI Installer for ARM64](https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-Installer-Win-ARM64-Full.exe)
  </details>


  <details>
    <summary>Linux</summary>

    **⚠️ Warning:** Agent OS currently does not work on Wayland. Switch to XOrg to use it.



  ```shell
  curl -o /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-x64-Full.run https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-User-Installer-Linux-x64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-x64-Full.run
  ```




  ```shell
  curl -o /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-ARM64-Full.run https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-User-Installer-Linux-ARM64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-24.9.1-User-Installer-Linux-ARM64-Full.run
  ```
  </details>


  <details>
    <summary>MacOS</summary>

  ```shell
  curl -o /tmp/AskUI-Suite-24.9.1-User-Installer-MacOS-ARM64-Full.run https://files.askui.com/releases/Installer/24.9.1/AskUI-Suite-24.9.1-User-Installer-MacOS-ARM64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-24.9.1-User-Installer-MacOS-ARM64-Full.run
  ```
  </details>




  ```shell
  pip install askui
  ```



  |  | AskUI [INFO](https://app.askui.com/) | Anthropic [INFO](https://console.anthropic.com/settings/keys) |
  |----------|----------|----------|
  | ENV Variables    | `ASKUI_WORKSPACE_ID`, `ASKUI_TOKEN`   | `ANTHROPIC_API_KEY`   |
  | Supported Commands    | `click()`   | `click()`, `get()`, `act()`   |
  | Description    | Faster Inference, European Server, Enterprise Ready   | Supports complex actions   |

  To get started, set the environment variables required to authenticate with your chosen model provider.


  <details>
    <summary>Linux & MacOS</summary>

    Use export to set an evironment variable:

    ```shell
    export ANTHROPIC_API_KEY=<your-api-key-here>
    ```
  </details>

  <details>
    <summary>Windows PowerShell</summary>

    Set an environment variable with $env:

    ```shell
    $env:ANTHROPIC_API_KEY="<your-api-key-here>"
    ```
  </details>



  ```python
  from askui import VisionAgent


  with VisionAgent() as agent:
      
      agent.tools.webbrowser.open_new("http://www.google.com")

      
      agent.click("url bar")
      agent.type("http://www.google.com")
      agent.keyboard("enter")

      
      datetime = agent.get("What is the datetime at the top of the screen?")
      print(datetime)

      
      agent.act("search for a flight from Berlin to Paris in January")
  ```



  Instead of relying on the default model for the entire automation script, you can specify a model for each `click` command using the `model_name` parameter.

  |  | AskUI | Anthropic |
  |----------|----------|----------|
  | `click()`    | `askui-combo`, `askui-pta`, `askui-ocr`   | `anthropic-claude-3-5-sonnet-20241022`   |

  **Example:** `agent.click("Preview", model_name="askui-combo")`



  Under the hood agents are using a set of tools. You can also directly access these tools.



  The controller for the operating system.

  ```python
  agent.tools.os.click("left", 2) # clicking
  agent.tools.os.mouse(100, 100) # mouse movement

  ```



  The webbrowser tool powered by [webbrowser](https://docs.python.org/3/library/webbrowser.html) allows you to directly access webbrowsers in your environment.

  ```python
  agent.tools.webbrowser.open_new("http://www.google.com")

  ```



  The clipboard tool powered by [pyperclip](https://github.com/asweigart/pyperclip) allows you to interact with the clipboard.

  ```python
  agent.tools.clipboard.copy("...")
  result = agent.tools.clipboard.paste()
  ```



  You want a better understanding of what you agent is doing? Set the `log_level` to DEBUG.

  ```python
  import logging

  with VisionAgent(log_level=logging.DEBUG) as agent:
      agent...
  ```



  You have multiple monitors? Choose which one to automate by setting `display` to 1 or 2.

  ```python
  with VisionAgent(display=1) as agent:
      agent...
  ```




  **AskUI Vision Agent** is a versatile AI powered framework that enables you to automate computer tasks in Python.

  It connects Agent OS with powerful computer use models like Anthropic's Claude Sonnet 3.5 v2 and the AskUI Prompt-to-Action series. It is your entry point for building complex automation scenarios with detailed instructions or let the agent explore new challenges on its own.


  ![image](docs/assets/Architecture.svg)


  **Agent OS** is a custom-built OS controller designed to enhance your automation experience.

   It offers powerful features like
   - multi-screen support,
   - support for all major operating systems (incl. Windows, MacOS and Linux),
   - process visualizations,
   - real Unicode character typing

  and more exciting features like application selection, in background automation and video streaming are to be released soon.


pkgId: 76776663b0017f8b81313340e469404ab4e739ffe19304169f236357ecc09f41
name: python-askui
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Automate computer tasks in Python
url: https://pypi.org/project/askui/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askui-0.1.9-1.src.rpm
checksum_type: sha256
description:
  ⚡ Automate computer tasks in Python ⚡

  [![Release Notes](https://img.shields.io/github/release/askui/vision-agent?style=flat-square)](https://github.com/askui/vision-agent/releases)
  [![PyPI - License](https://img.shields.io/pypi/l/langchain-core?style=flat-square)](https://opensource.org/licenses/MIT)

  Join the [AskUI Discord](https://discord.gg/Gu35zMGxbx).





  Agent OS is a device controller that allows agents to take screenshots, move the mouse, click, and type on the keyboard across any operating system.

  <details>
    <summary>Windows</summary>

    

  [AskUI Installer for AMD64](https://files.askui.com/releases/Installer/Latest/AskUI-Suite-Latest-Installer-Win-AMD64-Full.exe)



  [AskUI Installer for ARM64](https://files.askui.com/releases/Installer/Latest/AskUI-Suite-Latest-Installer-Win-ARM64-Full.exe)
  </details>


  <details>
    <summary>Linux</summary>

    **⚠️ Warning:** Agent OS currently does not work on Wayland. Switch to XOrg to use it.



  ```shell
  curl -o /tmp/AskUI-Suite-Latest-User-Installer-Linux-x64-Full.run https://files.askui.com/releases/Installer/Latest/AskUI-Suite-Latest-User-Installer-Linux-x64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-Latest-User-Installer-Linux-x64-Full.run
  ```




  ```shell
  curl -o /tmp/AskUI-Suite-Latest-User-Installer-Linux-ARM64-Full.run https://files.askui.com/releases/Installer/Latest/AskUI-Suite-Latest-User-Installer-Linux-ARM64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-Latest-User-Installer-Linux-ARM64-Full.run
  ```
  </details>


  <details>
    <summary>MacOS</summary>

  ```shell
  curl -o /tmp/AskUI-Suite-Latest-User-Installer-MacOS-ARM64-Full.run https://files.askui.com/releases/Installer/Latest/AskUI-Suite-Latest-User-Installer-MacOS-ARM64-Full.run
  ```
  ```shell
  bash /tmp/AskUI-Suite-Latest-User-Installer-MacOS-ARM64-Full.run
  ```
  </details>




  ```shell
  pip install askui
  ```

  **Note:** Requires Python version >=3.10.



  |  | AskUI [INFO](https://app.askui.com/) | Anthropic [INFO](https://console.anthropic.com/settings/keys) |
  |----------|----------|----------|
  | ENV Variables    | `ASKUI_WORKSPACE_ID`, `ASKUI_TOKEN`   | `ANTHROPIC_API_KEY`   |
  | Supported Commands    | `click()`   | `click()`, `get()`, `act()`   |
  | Description    | Faster Inference, European Server, Enterprise Ready   | Supports complex actions   |

  To get started, set the environment variables required to authenticate with your chosen model provider.


  <details>
    <summary>Linux & MacOS</summary>

    Use export to set an evironment variable:

    ```shell
    export ANTHROPIC_API_KEY=<your-api-key-here>
    ```
  </details>

  <details>
    <summary>Windows PowerShell</summary>

    Set an environment variable with $env:

    ```shell
    $env:ANTHROPIC_API_KEY="<your-api-key-here>"
    ```
  </details>




  You can test the Vision Agent with Hugging Face models via their Spaces API. Please note that the API is rate-limited so for production use cases, it is recommended to choose step 3a.

  **Note:** Hugging Face Spaces host model demos provided by individuals not associated with Hugging Face or AskUI. Don't use these models on screens with sensible information.

  **Supported Models:**
  - `AskUI/PTA-1`
  - `OS-Copilot/OS-Atlas-Base-7B`
  - `showlab/ShowUI-2B`
  - `Qwen/Qwen2-VL-2B-Instruct`
  - `Qwen/Qwen2-VL-7B-Instruct`

  **Example Code:**
  ```python
  agent.click("search field", model_name="OS-Copilot/OS-Atlas-Base-7B")
  ```




  ```python
  from askui import VisionAgent


  with VisionAgent() as agent:
      
      agent.tools.webbrowser.open_new("http://www.google.com")

      
      agent.click("url bar")
      agent.type("http://www.google.com")
      agent.keyboard("enter")

      
      datetime = agent.get("What is the datetime at the top of the screen?")
      print(datetime)

      
      agent.act("search for a flight from Berlin to Paris in January")
  ```



  Instead of relying on the default model for the entire automation script, you can specify a model for each `click` command using the `model_name` parameter.

  |  | AskUI | Anthropic |
  |----------|----------|----------|
  | `click()`    | `askui-combo`, `askui-pta`, `askui-ocr`   | `anthropic-claude-3-5-sonnet-20241022`   |

  **Example:** `agent.click("Preview", model_name="askui-combo")`



  Under the hood agents are using a set of tools. You can also directly access these tools.



  The controller for the operating system.

  ```python
  agent.tools.os.click("left", 2) # clicking
  agent.tools.os.mouse(100, 100) # mouse movement
  agent.tools.os.keyboard_tap("v", modifier_keys=["control"]) # Paste

  ```



  The webbrowser tool powered by [webbrowser](https://docs.python.org/3/library/webbrowser.html) allows you to directly access webbrowsers in your environment.

  ```python
  agent.tools.webbrowser.open_new("http://www.google.com")

  ```



  The clipboard tool powered by [pyperclip](https://github.com/asweigart/pyperclip) allows you to interact with the clipboard.

  ```python
  agent.tools.clipboard.copy("...")
  result = agent.tools.clipboard.paste()
  ```



  You want a better understanding of what you agent is doing? Set the `log_level` to DEBUG. You can also generate a report of the automation run by setting `enable_report` to `True`.

  ```python
  import logging

  with VisionAgent(log_level=logging.DEBUG, enable_report=True) as agent:
      agent...
  ```



  You have multiple monitors? Choose which one to automate by setting `display` to 1 or 2.

  ```python
  with VisionAgent(display=1) as agent:
      agent...
  ```




  **AskUI Vision Agent** is a versatile AI powered framework that enables you to automate computer tasks in Python.

  It connects Agent OS with powerful computer use models like Anthropic's Claude Sonnet 3.5 v2 and the AskUI Prompt-to-Action series. It is your entry point for building complex automation scenarios with detailed instructions or let the agent explore new challenges on its own.


  ![image](docs/assets/Architecture.svg)


  **Agent OS** is a custom-built OS controller designed to enhance your automation experience.

   It offers powerful features like
   - multi-screen support,
   - support for all major operating systems (incl. Windows, MacOS and Linux),
   - process visualizations,
   - real Unicode character typing

  and more exciting features like application selection, in background automation and video streaming are to be released soon.


pkgId: 6378fbcc3b286626612ea065329f665d103b5e43f9b712a62abc7def1d8216d6
name: python-askvideos
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: AskVideos python library
url: https://github.com/AskYoutubeAI/askvideos-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-askvideos-0.1.6-1.src.rpm
checksum_type: sha256
description:
  `AskVideosClient` is a Python client for interacting with the AskVideos API. This client allows you to create indices, search for videos, synthesize answers from multiple videos, index videos from various sources (YouTube search, URL, playlist, channel), and more.



  To install the python client.

  ```bash
  pip install askvideos
  ```




  ```python
  from ask_videos_client import AskVideosClient

  api_url = os.environ.get("ASKVIDEOS_SERVER_URL")
  api_key = os.environ.get("ASKVIDEOS_API_KEY")
  client = AskVideosClient(api_url, api_key)

  ```

  ```python
  index_name = "coffee"
  client.create_index(index_name)
  ```


  ```
  query = "coldbrew"
  results = client.search_videos(index_name, query)
  print(results)
  ```


pkgId: 9489bbb49c6314d11417997322873554437f2a119b57416cca4cc6ba4c6bb5f5
name: python-aslack
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Asynchronous Slack API integration.
url: http://github.com/textbook/aslack/
rpm_license: License :: OSI Approved :: ISC License (ISCL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aslack-0.11.0-1.src.rpm
checksum_type: sha256
description:
  */əˈslæk/*
  aSlack is a lightweight, asynchronous wrapper for Slack's Web and Real-Time
  Messaging (RTM) APIs, designed to allow the easy development of Slack tools and
  bots in Python. It defines two principal components:
  - ``SlackApi`` - a wrapper around the Web API; and
  - ``SlackBot`` - a messaging bot built on top of the RTM API.


pkgId: 4b195a6d6489ad44c66c642535144ab02be1193f4959de96758062bc82e872ad
name: python-aslookup
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: IP to ASN routing data query script
url: https://github.com/dspruell/aslookup
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aslookup-1.6.1-1.src.rpm
checksum_type: sha256
description:
  Python client for IP to ASN lookup services

  aslookup is a client utility for two of the public IP/AS query services
  operated by the following organizations:

  * Shadowserver -- https://www.shadowserver.org/wiki/pmwiki.php/Services/IP-BGP
  * Team Cymru -- http://www.team-cymru.org/IP-ASN-mapping.html

  The client implements both a simple Python module (aslookup) as well as a CLI
  utility (`as-lookup`). The lookups are currently done using DNS, which works
  well for a one-off lookups. It is not optimized for bulk lookups over the
  Whois protocol.

  Currently only IPv4 addresses are looked up. The client also maintains a
  listing of IP networks which are unroutable internet addresses, typically
  special use ranges in RFCs. In this way it can both filter out addresses from
  queries which are a waste of time, as well as provide context to the user on
  the address.



  The app has been tested on Python 3.

  It's best to install the program into a Python virtualenv. If you will only use
  the command line interface, the recommended way to install it is using
  [pipx](https://pypa.github.io/pipx/):

      pipx install aslookup

  If you will use aslookup as a library, you'll instead want to install it using
  `pip` in your target Python environment:

      python3 -m pip install aslookup





  The Python module defaults to querying the Team Cymru data service. The
  desired service may be specified by passing the *service* parameter to
  `get_as_data`.

  ```python
  from aslookup import get_as_data
  ip = "8.8.8.8"
  get_as_data(ip, service="shadowserver")
  ```



  It is possible to provide multiple IP addresses as arguments to the script, or
  to send them as a list on standard input, in which cases the script loops over
  them and returns output on separate lines. When providing invalid IPv4
  addresses as arguments, the script reports the problem on standard error and
  exits with an error. When providing input on stdin, the error is reported on
  standard output but execution is not aborted.

      as-lookup 8.8.8.8 9.9.9.9

  or:

      as-lookup < ipaddrs.txt



  A list of test values for the script is included in the file `tests/test_input.txt`.
  This can be useful to validate included IP prefix classifications and see the
  output format.

      as-lookup < tests/test_input.txt


pkgId: 6640bdc5049bde0a9e17b96f1e2cc4081325ca01da7bf90cd08963e52562c317
name: python-asltk
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A quick to use library to process images for MRI Arterial Spin Labeling imaging protocols.
url: https://pypi.org/project/asltk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asltk-0.1.5-1.src.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/LOAMRI/asltk/refs/heads/develop/docs/assets/asltk-logo.png" width=200>

  [![Documentation Stable](https://readthedocs.org/projects/asltk/badge/?version=main)](https://asltk.readthedocs.io/en/main/?badge=main)
  [![codecov](https://codecov.io/gh/LOAMRI/asltk/graph/badge.svg?token=1W8GQ7SLU9)](https://codecov.io/gh/LOAMRI/asltk)
  ![CI_main](https://github.com/LOAMRI/asltk/actions/workflows/ci_main.yaml/badge.svg)
  [![CI_develop](https://github.com/LOAMRI/asltk/actions/workflows/ci_develop.yaml/badge.svg)](https://github.com/LOAMRI/asltk/actions/workflows/ci_develop.yaml)
  [![PyPI version](https://badge.fury.io/py/asltk.svg)](https://badge.fury.io/py/asltk)



  Welcome to the ASL toolkit!

  This library was designed to assist users in processing Arterial Spin Labeling (ASL) MRI images, from basic imaging protocols to the state-of-the-art models provided in the scientific literature.

  The major objective of this project is to give an open-source alternative to researchers in the MRI field. A profound knowledge of computing and data modelling is not a prior demand. It is expected that a simple set of Python commands can be helpful in fast prototyping an ASL experiment or even collecting simple quantitative ASL-based information.

  Please read the [full documentation](https://asltk.readthedocs.io/en/main/) to get more details about the usage, implementation and updates in the `asltk` library.

  Also, feel free to contribute directly to the project! Check it out the [issues](https://github.com/LOAMRI/asltk/issues) at the repository and get in touch to the developers of the project.




  A quick to use install is via `pip`, as follows:

  > [!NOTE]
  > The installation requires Python 3.10 or higher

  ```bash
  pip install asltk
  ```



  We appreciate if one or more of the following references can be added in your projects due to the usage of `asltk` outcomes.

  * Paper 1


pkgId: a8313095fa0bc6faa6756f2d8cddb4596879806d4a08d041ecc1f5515f10de50
name: python-asmat
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Assembly Testing and Analysis
url: https://github.com/erwanlem/atp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asmat-1.2.1-1.src.rpm
checksum_type: sha256
description:
  asmat - Assembly Analysis and Testing



  **ASMAT** is a testing and analysis tool made for checking assembly code efficency. This tool offers three main actions: **generation**, **validation** and **analysis**.
  The generation phase generates reference assembly code. This code is stored in a reference folder.
  The validation phase compares assembly code generated by the current library version with assembly code in the reference folder.
  The analysis of a program gives information about assembly code that a compiler generates. Analysis is **only available for x86 instruction set**.





  ``` shell
  pip install asmat
  ```




  **-a**, **--analysis**
  Analysis mode. Generates a detailed report of the assembly code generated by a compiler using a specific cpu extension. This mode can't be selected with validation or generation at the same time.

  **--build**
  Build default files and directories `settings.json`, `ref/`.

  **-c** *compiler*, **--compiler** *compiler*
  The code is only generated and tested for the given compiler.

  **-d**  Deep generation. When generating assembly this option will replace existing files even though they already contain assembly code. Enable this option when you want to update reference files outdated (otherwise reference files are not changed if they already exist).

  **-D** *tool*, **--disassembler** *tool*
  Defines the disassembling tool. Available disassembling tools are `standard` (*-S* option of compilers) or `objdump`. Assembly code generated by one of this tool can't be validated by the other. Default value is `objdump`. The *standard* option is only available for *gcc* and *clang* compilers.

  **-f** , **--fatal**
  Raises exception. This option interrupts the testing process if there is an assembly mismatch error. Useless for generation.

  **--flags** *flags*
  Flags used for compilation. Flags musn't contain dashes. It has the highest priority for the compilation process. It means that if flags are given, *-m* options is ignored even though it's also given. If there are no flags, default flags are used.

  **-g**  Generation mode. Generates assembly code and stores it in `ref`. Without this option, the default mode is validation.

  **-H** *headers*, **--header** *headers*
  Defines headers for compilation. *`headers`* are paths that will be add in C++ file as follows *#include <**header**>*. If this option is not given, headers are extracted from `settings.json`.

  **-i**  Instruction comparison. Compares only instructions and ignores their parameters.

  **--input** *files* | *group*
  Defines your own input file or group. Without this option all config files are used. The given file must exist in folder `config`. If a group is given it mist exist in `settings.json`. The priority is *config file*, *group*, *all*. When generating, it only generates those files. When validating, it only compares those files.

  **-j** *nbprocess*
  Defines the number of parallel compilations. The default number of parallel processes is equal to the number of processors cores.

  **-l**  Log. Generates a log file giving details about errors that occured during the validation. Two types of errors are described: *comparison errors* that occured when assembly code doesn't correspond and *missing reference* that occured when a function doesn't have a reference file.

  **--output** *path*
  The path of the output. If this option is not defined, it takes the default path which is the directory *ref*.

  **--ref** *reference_path*
  Defines a custom path for the reference folder. When generating it changes the location of the stored files. When validating it changes the place we get the reference files.

  **--reset**
  Clears the `ref` directory.

  **-s** *setup*, **--setup** *setup*
  The code is only generated and validated for the given simd extension. The given extension name **must** exist in `settings.json`.

  **-S** *limit*, **--functionsperfile** *limit*
  Limit the number of functions in *cpp* files. If the number of functions is greater than the limit it creates several *cpp* files that are compiled seperately.

  **--settings** *path*
  Defines the path to access the settings file. If not given it takes `settings.json` in the *src* directory. If given, it first searches the path in the *src* directory. If not found it searches *path*.

  **-t**  Keeps temporary files after the process. Temporary files are files used to produce assembly code:
  - tmp.cpp : Contains generated cpp functions
  - tmp.o : Compiled file
  - tmp.txt : Contains assembly code extracts from tmp.o.

  **-v**  Verbose. Displays information in the command line. At the end of the process it gives the time elapsed since the beginning of the process.




  ``` python
  import asmat


  asmat.build_dependencies()


  s = asmat.setup()
  s.verbose = True
  s.keep_tmp = True


  asmat.generate(s)


  asmat.validate(s)


  asmat.analyze(s, "gcc", "sse")
  ```





  Settings are stored in `settings.json`. This file can be generated by calling `build_dependencies()` or by using `--build` option in console.


pkgId: 05198e6081d9d56fee1407c2c76b3c2dcc17f1788088444726e66801a60ca0fe
name: python-asmbly-neon-integrations
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Various convenience functions and scripts for managing integrations at Asmbly Makerspace.
url: https://pypi.org/project/asmbly-neon-integrations/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asmbly-neon-integrations-0.1.13-1.src.rpm
checksum_type: sha256
description:
  In attempts to further simplify our administrative operations so that we can focus on making cool stuff rather than route work, we're working to integrate our member management software - NeonCRM - with all our other systems.  Completed scripts ready to set for automation are saved in the root directory.  Scripts in `/examples` are work in progress.



  <br>
  <hr>



  First, thanks for collaborating!  If you are part of the organization, please create a branch to work then submit a pull request to main.  If you are outside the organization, we still welcome your collaboration!  Just fork the repo, then submit a pull request.

  NOTE:  You will need to create a separate file `config.py` with API keys (this will be ignored by git).  Variables used are
  `D_APIkey`, `D_APIuser`, `G_password `, `G_user`, `N_APIkey`, `N_APIuser`, `O_APIkey`, `O_APIuser`, and `S_APIkey`.

  <br>
  <hr>





  - Forum for member discussion
  - [API docs](https://docs.discourse.org/)
  - `GET` calls only require API key and API user in headers
  - `POST` calls require API key, API user, and content-type in the headers
  - Neon -> Discourse to update Discourse group membership
  <br><br>



  We are switching to signNow and will use their Zapier Neon CRM integration.

  See [SWintegration.py](https://github.com/ATXHS/NeonIntegrations/blob/main/SWintegration.py).


  - System for member agreement & waiver forms
  - [API docs](https://api.smartwaiver.com/docs/v4/#api-_)
  - To authenticate, add 'sw-api-key' to the headers with the API key.
  - Smartwaiver -> Neon to update WaiverCompleted custom field in Neon
    - Smartwaiver - `GET` `/v4/waivers`
      - https://api.smartwaiver.com/docs/v4/#api-Search-Search
    - Neon - `PATCH` `/accounts/{id}`
      - https://api.smartwaiver.com/docs/v4/#api-Waivers-WaiverList
  <br><br>



  - Used for access into the space
  <br><br>



  - Scheduling system for booking time at the space
  - Checked with CSM about API, they have integrations through Zapier, but no direct access endpoint
  - We will need to explore SSO/SAML options for user management (info [here](https://support.skedda.com/en/articles/4191038-single-sign-on-sso-via-saml-2-0))
  <br><br>

  <hr>





  This is an open-source project for Asmbly Makerspace, Inc. 501(c)3.  Keep any API tokens or other private information should be stored in the `/private` directory or `config.py` both of which are ignored by git.  If you are interested in working on this project with us, please reach out to [it@asmbly.org](mailto:it@asmbly.org).


pkgId: fb2029e688e403f23c3e0ee650d46d4f68952f696ed37d7e589da77d23249a18
name: python-asn-check
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: Check ASNs and metadata for a list of IPs
url: https://pypi.org/project/asn-check/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asn-check-1.1.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/asn-check.svg)](https://badge.fury.io/py/asn-check)
  [![Python](https://img.shields.io/pypi/pyversions/asn_check)](https://img.shields.io/pypi/pyversions/asn_check)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
  Given a list of IPs the tool returns their AS numbers and names.
  Data sources:
    - [ASN ranges IPv4- Thyme APNIC](https://thyme.apnic.net/current/data-raw-table),
    - [ASN ranges IPv6- Thyme APNIC](https://thyme.apnic.net/current/ipv6-raw-table),
    - [AS names - ripe.net](https://ftp.ripe.net/ripe/asnames/asn.txt),
    - [RFC #6890](https://www.rfc-editor.org/rfc/rfc6890.txt).
  Features:
    - Caching the data from sources - first run may take a long time,
    - Binary IP network search for high throughput,
    - Returns AS Number, AS Name and a country code for each IP address,
    - Supports both IPv4 and IPv6,
    - Reserved ranges included,
    - Also available as a lib!


pkgId: 1ef7db02fc619ba6b840dfc9b7b03b9ce8899b8a908a1e59f7c5beea47b849a6
name: python-asn1ate
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: ASN.1 translation library.
url: http://github.com/kimgr/asn1ate
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asn1ate-0.6.0-1.src.rpm
checksum_type: sha256
description:
  ``asn1ate`` is a Python library for translating ASN.1 into other forms.
  It is intended for code generation from formal ASN.1 definitions, and a
  code generator for ``pyasn1`` is included.
  ``asn1ate`` is released under a 3-clause BSD license. For details, see
  LICENSE.txt.


pkgId: 9896dcec56e909aaa55d1489509a7675cefa463d1c36164a1115043e70c517eb
name: python-asn1editor
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: ASN.1 editor framework with support for encoding and decoding various codecs.
url: https://github.com/futsch1/asn1editor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asn1editor-0.8.0-1.src.rpm
checksum_type: sha256
description:
  ![Build](https://github.com/Futsch1/asn1editor/workflows/Build/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/Futsch1/asn1editor/badge.svg?branch=master)](https://coveralls.io/github/Futsch1/asn1editor?branch=master)
  [![Maintainability](https://api.codeclimate.com/v1/badges/b2492b88948ace2e8a14/maintainability)](https://codeclimate.com/github/Futsch1/asn1editor/maintainability)
  [![Documentation Status](https://readthedocs.org/projects/asn1editor/badge/?version=latest)](https://asn1editor.readthedocs.io/en/latest/?badge=latest)

  Python based ASN.1 editor

  This project contains a generic editor to view and edit ASN.1 encoded data.
  It can load and save data encoded in various ASN.1 formats. It uses
  [asn1tools](https://github.com/eerimoq/asn1tools) to parse
  ASN.1 specifications and read and write encoded data.

  The controller part of the editor is written independently of the
  used GUI framework. A view implementation with wxPython is provided.

  ![Screenshot](docs/screenshot_tree.png?raw=true "asn1editor")


  To start the wxPython based editor, install asn1editor via pip:

  ```pip install asn1editor```

  Then you can run asn1editor from the shell

  ```asn1editor [-h] [-type TYPE] [-data DATA] [asn1spec]```

  The ASN.1 specification to be loaded can be passed as an (optional) argument. The type inside the ASN.1 specification can be selected using the syntax < Module
  name >.< Type name >. Finally, a data file can be passed as well that contains data encoded in the ASN.1 specification.




  The editor supports a large variety of ASN.1 data types:
  - INTEGER
  - REAL
  - ENUMERATED
  - BOOLEAN
  - OCTET STRING, VisibleString, UTF8String, GeneralString, IA5String, OBJECT IDENTIFIER
  - BIT STRING
  - SEQUENCE, SET
  - SEQUENCE OF, SET OF
  - CHOICE
  - DATE, TIME-OF-DAY, DATE-TIME, GeneralizedTime, UTCTime


  The following encodings are supported for reading and writing data:

  - JER
  - OER
  - XER
  - DER
  - BER
  - PER
  - UPER


  - Load and save encoded data
  - View the data in a tree view or as groups

  ![Screenshot](docs/screenshot_groups.png?raw=true "asn1editor group view")
  - See limits of numeric values and texts as tooltips
  - Edit octet strings as ASCII or hex
  - List of recently opened specifications for quick access


  IMPORT references are automatically resolved if the ASN1 files containing the imported types
  reside in the same directory and have the extension ".asn".



  If you want to extend asn1editor with custom functionality, you can pass a plugin object to the WxPythonMainWindow object.
  The plugin object needs to inherit from asn1editor.Plugin.

  Example:

  ```python
  import wx
  from asn1editor import WxPythonMainWindow, Plugin

  class MyPlugin(Plugin):
      
      pass

  app = wx.App()

  frame = WxPythonMainWindow([MyPlugin()])

  frame.Show()

  app.MainLoop()
  ```



  In order to use custom data formats or to work with the data, plugins can be used. These plugins need to inherit from the Plugin.Plugin class and can use the
  PluginInterface.PluginInterface class to interact with the main application. A list of plugins can be passed to the constructor of the main editor class and is
  then automatically embedded in the application.

  An example application is if a custom header is added to an ASN.1 encoded data. Then the plugin can decode the header, choose the appropriate ASN.1
  specification, load it, decode the data and display it.



  The editor can be customized to modify the display of certain fields. This customization is provided via a class that implements the TypeAugmenter interface.
  The editor will query additional information for every field via this interface. Currently, a field can be augmented by providing a help text and a style
  IntEnum. The help text will be shown in the tooltip of each field and the style flag modifies the way how a field is displayed. A field can be hidden or be
  declared as read-only.

  The editor comes with a default implementation of this augmenter that uses a .style file to customize the way fields are displayed in asn1editor.

  If an ASN.1 file is opened, asn1editor looks for an equally named file with a .style extension in the same directory. If it is found, it is loaded and used to
  refine the layout of the specification. A style file is in JSON format and contains the name of the ASN.1 field as a key, and the layout specifier as value. The
  specifiers are named "read_only" and "hidden".

  Example:

    ```json
    {
    "firstField": "read_only",
    "secondField": "hidden"
  }
    ```



  Apart from unit tests in the source folder, there is a project on testquality.com that contains a number of manual tests to qualify an asn1editor
  release [here](https://futsch1.testquality.com). You can log in using the credentials futsch1@fehlbar.de/readonly to view the test cases and test results.


pkgId: 5e68d7f13720b6fd8d9879bbc67f9933a79dd0eb03179ff50da0a0ac1b78ce9b
name: python-asn1tools
arch: src
version: 0.167.0
epoch: 0
release: 1
summary: ASN.1 parsing, encoding and decoding.
url: https://github.com/eerimoq/asn1tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asn1tools-0.167.0-1.src.rpm
checksum_type: sha256
description:
  A Python package for `ASN.1`_ parsing, encoding and decoding.
  This project is *under development* and does only support a subset
  of the ASN.1 specification syntax.
  Supported codecs:
  - Basic Encoding Rules (BER)
  - Distinguished Encoding Rules (DER)
  - Generic String Encoding Rules (GSER)
  - JSON Encoding Rules (JER)
  - Basic Octet Encoding Rules (OER)
  - Aligned Packed Encoding Rules (PER)
  - Unaligned Packed Encoding Rules (UPER)
  - XML Encoding Rules (XER)
  Miscellaneous features:
  - `C` source code generator for OER and UPER (with some limitations).
  Project homepage: https://github.com/eerimoq/asn1tools
  Documentation: http://asn1tools.readthedocs.org/en/latest


pkgId: 182f0b538e44c09de0f6bd4f28c1c54483b887637dc80a65025887c59b9ae1b4
name: python-asp-selftest
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: A tool for running in-source unittests for Anwer Set Programming (ASP)
url: https://github.com/ejgroene/asp-selftest
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asp-selftest-0.0.18-1.src.rpm
checksum_type: sha256
description:
  In-source test runner for Answer Set Programming (ASP) with Clingo.
  With in-source testing, source and tests stay together in the same file, hence the tests are also expressed in ASP.
  The tests are as non-obstrusive as possible and and many examples are idiomatic in nature and could have been written in another way. These idioms are merely ways to provide clearer code and avoid mistakes. As such, they have value in themselves.


pkgId: 821a58ceb26fee9aeb023508a9af0f38ed90d66c4211e502e66c74ac992851b0
name: python-aspec
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: attribute specificatoin (aspec)
url: https://github.com/dsm-72/aspec
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspec-0.0.16-1.src.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->





  ``` sh

  $ mamba env create -f env.yml


  $ mamba env update -n aspec --file env.yml
  ```



  ``` sh
  pip install -e .


  pip install aspec
  ```



  ``` sh

  $ conda activate aspec


  $ pip install -e .





  $ nbdev_prepare
  ```



  ``` sh

  $ nbdev_pypi


  $ nbdev_conda --build_args '-c conda-forge'
  $ nbdev_conda --mambabuild --build_args '-c conda-forge -c dsm-72'
  ```





  Install latest from the GitHub
  [repository](https://github.com/dsm-72/aspec):

  ``` sh
  $ pip install git+https://github.com/dsm-72/aspec.git
  ```

  or from [conda](https://anaconda.org/dsm-72/aspec)

  ``` sh
  $ conda install -c dsm-72 aspec
  ```

  or from [pypi](https://pypi.org/project/aspec/)

  ``` sh
  $ pip install aspec
  ```



  Documentation can be found hosted on GitHub
  [repository](https://github.com/dsm-72/aspec)
  [pages](https://dsm-72.github.io/aspec/). Additionally you can find
  package manager specific guidelines on
  [conda](https://anaconda.org/dsm-72/aspec) and
  [pypi](https://pypi.org/project/aspec/) respectively.


pkgId: cc562008d8aa1b96c70a98b805e412871dfec0f4429f85c3b7d110e298ee1ed9
name: python-aspect-library-v1
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A Python library for aspect-based sentiment analysis with translation capabilities
url: https://github.com/yourusername/my_aspect_library
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspect-library-v1-0.1.3-1.src.rpm
checksum_type: sha256
description:
  My Aspect Library is a Python package designed for performing aspect-based sentiment analysis with integrated translation capabilities. This library allows you to easily translate text, extract aspects, and analyze sentiment, making it a powerful tool for natural language processing tasks.



  - **Translation**: Automatically translate text in your dataset to the target language before analysis.
  - **Aspect Extraction**: Extract aspect terms from text using state-of-the-art models.
  - **Sentiment Analysis**: Analyze sentiment associated with extracted aspects.
  - **Data Processing**: Clean and process text data for analysis, including stopword removal and text normalization.
  - **Pivot Table Generation**: Create pivot tables to summarize sentiment analysis results.



  To install the package, you can simply clone the repository and use `setup.py` to install it:

  ```bash
  git clone https://github.com/yourusername/my_aspect_library.git
  cd my_aspect_library
  pip install .
  ```

  Alternatively, if you want to install it in editable mode:

  ```bash
  pip install -e .
  ```



  Hereâ€™s a quick example of how to use the library:

  ```python
  import pandas as pd
  from my_aspect_library import AspectExtractor, translate_aspects, create_pivot_table, concatenate_results


  df = pd.read_excel('path_to_your_file.xlsx')


  aspect_extractor = AspectExtractor()


  result_df = aspect_extractor.extract(df, column_name='Customer Comments', target_language='en')


  translated_aspects = translate_aspects(result_df)


  pivot_table = create_pivot_table(translated_aspects)


  ```



  - `pandas`
  - `deep_translator`
  - `unlimited_machine_translator`
  - `pyabsa`
  - `nltk`

  These dependencies are automatically installed when you install the package.



  This project is licensed under the MIT License - see the LICENSE file for details.



  If you want to contribute to this project, feel free to fork the repository and submit a pull request.



  Special thanks to all the contributors and maintainers of the libraries that this project depends on.


pkgId: db714b476e231aa9f136af03e683e1d54a3c1cbf5c22358f31d1ce282f4d6d75
name: python-aspectlib
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://github.com/ionelmc/python-aspectlib
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspectlib-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  ``aspectlib`` is an aspect-oriented programming, monkey-patch and decorators library. It is useful when changing


pkgId: 6666a6961558db2a296f8bd42de4636d32aa3f6e98ae85a854aa3ab0fcd393f1
name: python-aspen
arch: src
version: 1.1
epoch: 0
release: 1
summary: A filesystem router for Python web frameworks
url: https://github.com/AspenWeb/aspen.py
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspen-1.1-1.src.rpm
checksum_type: sha256
description:
  ``aspen`` is available on `GitHub`_ and on `PyPI`_::
      $ pip install aspen
  We test against 64-bit Python 2.7 and Python 3.6 on Linux: |travis|
  And we test against 32- and 64-bit Python 2.7 on Windows: |appveyor|
  ``aspen`` is MIT-licensed.


pkgId: 164fcb94c4ad6d63f7f8bbc8744628906f510d4ca6bc0a3a18cada20fb20976c
name: python-aspire
arch: src
version: 0.13.0
epoch: 0
release: 1
summary: Algorithms for Single Particle Reconstruction
url: http://spr.math.princeton.edu/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspire-0.13.0-1.src.rpm
checksum_type: sha256
description:
  ASPIRE is a pip-installable package for Linux/Mac/Windows, and
  requires Python 3.8-3.11. The recommended method of installation for
  getting started is to use Anaconda (64-bit) for your platform to
  install Python. Python's package manager `pip` can then be used to
  install `aspire` safely in that environment.
  If you are unfamiliar with `conda`, the
  [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
  distribution for `x86_64` is recommended.
  Assuming you have `conda` and a compatible system, the following steps
  will checkout current code release, create an environment, and install
  ASPIRE.
  ```

  git clone https://github.com/ComputationalCryoEM/ASPIRE-Python.git
  cd ASPIRE-Python

  conda create --name aspire python=3.8 pip

  conda activate aspire


  pip install -e ".[dev]"
  ```
  If you prefer not to use Anaconda, or have other preferences for managing environments, you should be able to directly use `pip` with Python >= 3.8 from the local checkout or via PyPI.
  Please see the full documentation for details and advanced instructions.

  To check the installation, a unit test suite is provided,
  taking approximate 15 minutes on an average machine.
  ```
  pytest
  ```

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


pkgId: 30751f0135f3b5f78e4ce95a636c5acfdabae727c45cb7c29ee20f52751d88ad
name: python-aspire
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: Algorithms for Single Particle Reconstruction
url: http://spr.math.princeton.edu/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspire-0.13.1-1.src.rpm
checksum_type: sha256
description:
  ASPIRE is a pip-installable package for Linux/Mac/Windows, and
  requires Python 3.9-3.12. The recommended method of installation for
  getting started is to use Anaconda (64-bit) for your platform to
  install Python. Python's package manager `pip` can then be used to
  install `aspire` safely in that environment.
  If you are unfamiliar with `conda`, the
  [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
  distribution for `x86_64` is recommended.
  Assuming you have `conda` and a compatible system, the following steps
  will checkout current code release, create an environment, and install
  ASPIRE.
  ```

  git clone https://github.com/ComputationalCryoEM/ASPIRE-Python.git
  cd ASPIRE-Python

  conda create --name aspire python=3.9 pip

  conda activate aspire


  pip install -e ".[dev]"
  ```
  If you prefer not to use Anaconda, or have other preferences for managing environments, you should be able to directly use `pip` with Python >= 3.9 from the local checkout or via PyPI.
  Please see the full documentation for details and advanced instructions.

  To check the installation, a unit test suite is provided,
  taking approximate 15 minutes on an average machine.
  ```
  pytest
  ```

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


pkgId: e64d4b2c2424a84c391ae244e68a5812c43da2f42a66f8245f044d334ac1ea50
name: python-aspired
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: The iraf-free spectral data reduction toolkit.
url: https://aspired.readthedocs.io/en/latest/?badge=latest
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspired-0.5.1-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/cylammarco/ASPIRED/workflows/Python%20package/badge.svg)
  [![Coverage Status](https://coveralls.io/repos/github/cylammarco/ASPIRED/badge.svg?branch=main)](https://coveralls.io/github/cylammarco/ASPIRED?branch=main)
  [![Readthedocs Status](https://readthedocs.org/projects/aspired/badge/?version=latest&style=flat)](https://aspired.readthedocs.io/en/latest/)
  [![arXiv](https://img.shields.io/badge/arXiv-2111.02127-00ff00.svg)](https://arxiv.org/abs/2111.02127)
  [![PyPI version](https://badge.fury.io/py/aspired.svg)](https://badge.fury.io/py/aspired)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4127294.svg)](https://doi.org/10.5281/zenodo.4127294)
  [![AJ](https://img.shields.io/badge/Journal-AJ-informational)](https://doi.org/10.3847/1538-3881/acd75c)
  [![Downloads](https://pepy.tech/badge/aspired)](https://pepy.tech/project/aspired)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  We aim to provide a suite of publicly available spectral data reduction software to facilitate rapid scientific outcomes from time-domain observations. For time resolved observations, an automated pipeline frees astronomers from performance of the routine data analysis tasks to concentrate on interpretation, planning future observations and communication with international collaborators. Part of the OPTICON project coordinates the operation of a network of largely self-funded European robotic and conventional telescopes, coordinating common science goals and providing the tools to deliver science-ready photometric and spectroscopic data. As part of this activity is [SPRAT](https://ui.adsabs.harvard.edu/abs/2014SPIE.9147E..8HP/abstract), a compact, reliable, low-cost and high-throughput spectrograph and appropriate for deployment on a wide range of 1-4m class telescopes. Installed on the Liverpool Telescope since 2014, the deployable slit and grating mechanism and optical fibre based calibration system make the instrument self-contained.

  ASPIRED is written for use with python 3.7, 3.8, 3.9, 3.10 and 3.11, and is intentionally developed as a self-consistent reduction pipeline with its own diagnostics and error handling. The pipeline should be able to reduce 2D spectral data from raw image to wavelength and flux calibrated 1D spectrum automatically without any user input (quicklook quality). However, the real goal is to provide a set of easily configurable routines to build pipelines for long slit spectrographs on different telescopes (science quality). We use SPRAT as a test case for this development, but our aim is to support a much wider range of instruments. By delivering near real-time data reduction we will facilitate automated or interactive decision making, allowing "on-the-fly" modification of observing strategies and rapid triggering of other facilities.

  Further information can be referred to this [AJ article](https://iopscience.iop.org/article/10.3847/1538-3881/acd75c).

  Early stage development efforts can be referred to this [ASPC article](https://ui.adsabs.harvard.edu/abs/2020ASPC..527..655L/abstract) and this [arXiv article](https://ui.adsabs.harvard.edu/abs/2020arXiv201203505L/abstract). This is in concurrent development with the automated wavelength calibration software [RASCAL](https://github.com/jveitchmichaelis/rascal), further information can be referred to this [ASPC article](https://ui.adsabs.harvard.edu/abs/2020ASPC..527..627V/abstract) and it will appear in the same volume of ASPCS.

  Example notebooks and scripts can be found at [aspired-example](https://github.com/cylammarco/ASPIRED-example). More examples can be found at the github repository of the journal article [here](https://github.com/cylammarco/ASPIRED-apj-article), e.g.:

  ![alt text](https://github.com/cylammarco/ASPIRED-apj-article/blob/main/fig_09_reduction_compared.png?raw=true)


  We are to cover as many use cases as possible. If you would like to apply some reduction techniques that we have overseen, please use the [issue tracker](https://github.com/cylammarco/ASPIRED/issues) to request new features. The following is the list of scenarios that we can handle:


  1. [x] Dataset with science and standard field-flattened images and the respective arc image.


  2. [x] Dataset with science field-flattened image and the arc image only.


  3. [x] Dataset with science and standard field-flattened images only.


  4. [x] User supplied trace(s) for light spectrum extraction (only to extract ADU/s of the spectra).
  5. [x] User supplied trace(s) for arc extraction (only to get wavelength calibration polynomial).
  6. [x] User supplied wavelength calibration polynomial coefficients.
  7. [x] User supplied line list.
  8. [x] User supplied pixel-to-wavelength mapping (not fitted).
  9. [x] User supplied sensitivity curve.
  10. [x] Flux calibration for user supplied wavelength calibrated science and standard 1D spectra.
  11. [x] Apply atmospheric extinction correction.
  12. [x] Apply basic telluric absorption correction.


  13. [x] Save diagnostic plots in [these formats](https://plotly.com/python/renderers/#setting-the-default-renderer).
  14. [x] Save data in FITS (with header information) or ascii (csv).

  See the examples of these use cases at [aspired-example](https://github.com/cylammarco/ASPIRED-example/).


  * python >= 3.8 (It should work on 3.6 and 3.7 if you can sort out the astropy (>=5.0) requirement of >=3.8)
  * [numpy](https://numpy.org/doc/stable/index.html) >= 1.21
  * [scipy](https://scipy.org/) >= 1.7
  * [astropy](https://github.com/astropy/astropy) >= 4.3
  * [astroscrappy](https://github.com/astropy/astroscrappy) >= 1.1
  * [ccdproc](https://github.com/astropy/ccdproc)
  * [plotly](https://github.com/plotly/plotly.py) >= 5.0
  * [rascal](https://github.com/jveitchmichaelis/rascal) >= 0.3.10, < 4.0
  * [spectresc](https://github.com/cylammarco/SpectResC) >= 1.0.2
  * [statsmodels](https://www.statsmodels.org/stable/index.html) >= 0.13


  Instructions can be found [here](https://aspired.readthedocs.io/en/latest/installation/pip.html).


  Please use the [issue tracker](https://github.com/cylammarco/ASPIRED/issues) to report any issues or support questions.


  The [quickstart guide](https://aspired.readthedocs.io/en/latest/tutorials/quickstart.html) will show you how to reduce the example dataset.


  If you are interested in contributing code to the project, thank you! For those unfamiliar with the process of contributing to an open-source project, you may want to read through Github’s own short informational section on how to submit a [contribution](https://opensource.guide/how-to-contribute/#how-to-submit-a-contribution) or send me a message.

  Style -- black. See the .pre-commit-config.yaml for the other requirements.


  1. European Union’s Horizon 2020 research and innovation programme (grant agreement No. 730890)
  (January 2019 - March 2020)
  2. Polish NCN grant Daina No. 2017/27/L/ST9/03221
  (May - June 2020)
  3. European Research Council Starting Grant (grant agreement No. 852097)
  (Sept 2020 - Current)


  If you make use of the ASPIRED toolkit, we would appreciate if you can refernce the two articles and two pieces of software listed below:

  1. [ASPIRED AJ article](https://ui.adsabs.harvard.edu/abs/10.3847/1538-3881/acd75c/abstract)
  2. [ASPIRED Zenodo](https://doi.org/10.5281/zenodo.4127294)
  3. [RASCAL arXiv article](https://ui.adsabs.harvard.edu/abs/2020ASPC..527..627V/abstract)
  4. [RASCAL Zenodo](https://doi.org/10.5281/zenodo.4117516)


pkgId: bd49459a40818e4e10e5b62cce54a96abdbf5567c8f60e029d4dc71e87cb2bcc
name: python-aspose-barcode-for-python-via-java
arch: src
version: 24.11.0
epoch: 0
release: 1
url: https://pypi.org/project/aspose-barcode-for-python-via-java/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-barcode-for-python-via-java-24.11.0-1.src.rpm
checksum_type: sha256
summary:
  Barcode generation and recognition component. It allows developers to quickly and easily add barcode creation and scanning functionality to their Python applications.

description:
  Aspose.BarCode for Python via Java is a robust and reliable barcode generation and recognition component, written in Python and Java. It allows developers to quickly and easily add barcode creation and scanning functionality to their Python applications.



  - Supports most established barcode standards and barcode specifications.
  - Ability to read & export barcodes in multiple image formats including BMP, GIF, JPEG & PNG.
  - Provides full control over barcode images including background color, bar color, image quality, rotation angle, x-dimension, resolution and more.
  - Complete control over barcode captions including caption font, back color, fore color, alignment, and location.
  - Support for checksum.
  - Support for X-dimension & Y-dimension for 2D BarCodes.
  - Support for Wide to Narrow Ratio for supported symbologies.
  - Support for DataMatrix barcode with X12, EDIFACT & Base 256 encoding.



  - Can read most common 1D, 2D barcodes anywhere at any angle from an image.
  - Specify an area in the image to scan the barcode
  - Get region information for the barcodes recognized in the image



  - Manipulate the barcode's image borders, border color, style, margins, width, etc.
  - Rotate barcode images to any degree.
  - Set anti-aliasing for barcode images.
  - Manage barcode image margins.
  - Customize image resolution.
  - Set size in inches or millimeters.
  - Auto size barcode images.



  **Numeric Only:** EAN13, EAN8, UPCA, UPCE, ISBN, ISMN, ISSN, Interleaved2of5, Standard2of5, MSI, Code11, Codabar, Postnet, Planet, EAN14(SCC14), SSCC18, ITF14, IATA 2 of 5, DatabarOmniDirectional, DatabarStackedOmniDirectional, DatabarExpandedStacked, DatabarStacked, DatabarLimited, DatabarTruncated\
  **Alpha-Numeric:** GS1Code128, Code128, Code39 Extended, Code39 Standard, Code93 Extended, Code93 Standard, Australia Post, Italian Post 25, Matrix 2 of 5, DatabarExpanded, PatchCode\
  **2D Symbologies:** PDF417, DataMatrix, Aztec, QR, MicroQR, GS1DataMatrix, Code16K, CompactPDF417, Swiss QR (QR Bill)



  **Images:** JPEG, TIFF, PNG, BMP



  **Images:** JPEG, TIFF, PNG, BMP

  [Product](https://products.aspose.com/barcode/python-java) | [Documentation](https://docs.aspose.com/barcode/pythonjava/) | [Blog](https://blog.aspose.com/category/barcode/) | [API Reference](https://apireference.aspose.com/barcode/java) | [Free Support](https://forum.aspose.com/c/barcode) | [Temporary License](https://purchase.aspose.com/temporary-license)


pkgId: 54730d2ea639f93e190d4b4898d787ddfd6dc14b86b6d924dbc7a2c782cb9dfd
name: python-aspose-cells
arch: src
version: 24.10.0
epoch: 0
release: 1
url: https://products.aspose.com/cells/python-java
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-cells-24.10.0-1.src.rpm
checksum_type: sha256
summary:
  A powerful library for manipulating and converting Excel (XLS, XLSX, XLSB), ODS, CSV and HTML files.

description:
  Aspose.Cells for Python via Java is a scalable and feature-rich API to process Excel spreadsheets using Python. API offers Excel file creation, manipulation, conversion, & rendering. Developers can format worksheets, rows, columns or cells to the most granular level, create & manipulate chart & pivot tables, render worksheets, charts and specific data ranges to PDF & images, add & calculate Excel's builtin and custom formulas and much more - all without any dependency on Microsoft Office or Excel application.


pkgId: 1d40e2aa9efc3517dcd6c07dff8d7b227e43bdb95bf12b02a1bd323caecd3d86
name: python-aspose-ocr-cloud
arch: src
version: 24.11.0
epoch: 0
release: 1
summary: Aspose OCR Cloud 5.0 API
url: https://pypi.org/project/aspose-ocr-cloud/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-ocr-cloud-24.11.0-1.src.rpm
checksum_type: sha256
description:
  OCR-3977 | Added recognition of the Uyghur language, including mixed Uyghur/English texts. | New feature
  OCR-3978 | Added recognition of the Telugu language, including mixed Telugu/English texts. | New feature
  OCR-3979 | Added recognition of the Kannada language, including mixed Kannada/English texts. | New feature
  OCR-3980 | Added recognition of the Tamil language, including mixed Tamil/English texts. | New feature
  OCR-3985 | Added recognition of the Devanagari-based scripts, including mixed Devanagari/English texts. | New feature
  OCR-3986 | Added support for mixed Arabic/English texts. | Enhancement
  OCR-3984 | Added support for mixed Japanese/English texts. | Enhancement
  OCR-3983 | Added support for mixed Korean/English texts. | Enhancement
  OCR-3982 | Added support for mixed Chinese/English texts. | Enhancement
  OCR-3987 | Added support for mixed Persian/English texts. | Enhancement
  REST API changes: https://releases.aspose.cloud/ocr/release-notes/2024/aspose-ocr-cloud-24-11-0-release-notes/

  The following recognition languages have been added:


pkgId: a4c3c3e73bab1b1356f0eaa4bcc3279c5afc11bbd76251c9d1ecc9c3ad8241ad
name: python-aspose-tasks-cloud
arch: src
version: 24.11.0
epoch: 0
release: 1
summary: Aspose.Tasks Cloud API Reference
url: https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-tasks-cloud-24.11.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/api-v3.0-lightgrey) ![PyPI](https://img.shields.io/pypi/v/aspose-tasks-cloud) ![PyPI - Format](https://img.shields.io/pypi/format/aspose-tasks-cloud) ![PyPI - Downloads](https://img.shields.io/pypi/dm/aspose-tasks-cloud) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aspose-tasks-cloud) [![GitHub license](https://img.shields.io/github/license/aspose-tasks-cloud/aspose-tasks-cloud-python)](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-php/blob/master/LICENSE) ![GitHub last commit](https://img.shields.io/github/last-commit/Aspose-tasks-Cloud/aspose-tasks-cloud-python)



  Aspose.Tasks for Cloud offers the ability to manipulate and convert Microsoft Project MPT, MPP, MPX & Oracle Primavera XER, XML, and PrimaveraP6XML files in Python. [Aspose.Tasks Cloud SDK for Python](https://products.aspose.cloud/tasks/python) wraps the REST API to make it easier for the developers to integrate MS Project Task Management features in their own cloud-based Python applications on Linux, MacOS, Windows or Android.

  Feel free to explore the [Developer's Guide](https://docs.aspose.cloud/display/taskscloud/Developer+Guide) & [API Reference](https://apireference.aspose.cloud/tasks/) to know all about Aspose.Tasks Cloud API.


  - Add project assignments or delete project assignments along with their references.
  - Get the project's outline codes by index & get links to all project tasks.
  - Import projects from Primavera DB formats or from databases with the specified connection string.
  - Get UIDs of all projects contained in the file & fetch the required assignment with the project based on UID.
  - Manage project tasks, resource data, calendars & Work Breakdown Structure (WBS).
  - Perform risk analysis using Monte Carlo simulation and create a report.
  - Create and set project document properties & fetch all or specific existing properties.
  - Get a project's extended attributes, time-scaled data, or recurring info of a specific task.
  - Reschedule project tasks, dates, and other settings.
  - Calculate slacks & recalculate project completion or incompletion work.
  - Fetch a project document in the desired format.
  - Delete project task with its related references & rebuild the task tree.
  - [Convert project documents](https://docs.aspose.cloud/tasks/convert-project-document-to-the-specified-format/) to other formats.
  - Manipulate task data.
  - [Manage project's resources](https://docs.aspose.cloud/tasks/working-with-resources/).
  - Handle task links & task assignments.
  - Work with project's extended attributes.
  - [Read Microsoft ProjectвЂ™s document properties](https://docs.aspose.cloud/tasks/working-with-calendars/) such as start and finish date, tasks scheduling types and so on.
  - [Read Microsoft ProjectвЂ™s Calendars](https://docs.aspose.cloud/tasks/working-with-calendars/) and Calendar Exceptions information.


  **Microsoft Project** MPP, XML, MPT **Primavera** MPX


  XER, XLSX, HTML, XML, TXT, TIF, SVG, PNG, JPEG



  - Enhanced reading data from Primavera-specific task's properties.


  - Added new ability to get views information
  - Possibility to modify table text styles for Gantt Chart views.


  - Added new ability to read Primavera-specific task's properties.
  - Provided the ability to read more document properties.


  - Support for the batch creation of tasks (i.e. the ability to create multiple tasks in a single *API* call).


  - Ability to specify the non-default path for Project Server's *PWA* URL.
  - Ability to modify *timephasedData* collection in assignments.


  - Possibility to render comments when saving as image, HTML or PDF.
  - Option to use username and password to connect Project Online (Server) instead of auth token, incase you don't have it.
  - Ability to add assignments to your project file along with specifying its cost.
  - Quickly adding new tasks to project, when calculation mode is set to automatic.
  - Ability to add project in Microsoft Project Server.
  - Added support of reading shared resource assignments.



  Register an account at [Aspose Cloud Dashboard](https://dashboard.aspose.cloud/#/apps) to get you application information. Next, either directly use the source from this repository in your project or get the package from [PyPi](https://pypi.org/project/aspose-tasks-cloud).



  ```sh
  pip install aspose-tasks-cloud
  ```

  You may need to run `pip` command with root permission as `sudo pip install aspose-tasks-cloud`.

  Then import the package as follows.

  ```python
  import asposetaskscloud
  ```



  ```sh
  python setup.py install --user
  ```

  Alternatively, execute `sudo python setup.py install` to install the package for all users.

  Then import the package as follows.

  ```python
  import asposetaskscloud
  ```



  ```python
  	

  	api_client = asposetaskscloud.ApiClient()
  	api_client.configuration.host = 'https://api.aspose.cloud'
  	api_client.configuration.api_key['api_key'] = 'MY_CLIENT_SECRET'
  	api_client.configuration.api_key['app_sid'] = 'MY_CLIENT_ID'
  	tasks_api = asposetaskscloud.TasksApi(api_client)

  	file_name = 'SomeSeriousPlan.mpp'

  	upload_request = asposetaskscloud.models.requests.UploadFileRequest(os.path.join(self.remote_test_folder, file_name), file_name)
  	upload_result = self.tasks_api.upload_file(upload_request)

  	request = asposetaskscloud.models.requests.GetReportPdfRequest(file_name, ReportType.MILESTONES)
  	result = tasks_api.get_report_pdf(request)
  ```


  | .NET | PHP | Python| Node.js | Go |
  |---|---|---|---|---|
  | [GitHub](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-dotnet) |[GitHub](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-php) | [GitHub](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-python) | [GitHub](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-node) |[GitHub](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-go)|
  | [NuGet](https://www.nuget.org/packages/Aspose.tasks-Cloud/)| [Composer](https://packagist.org/packages/aspose/tasks-cloud-php) | [PIP](https://pypi.org/project/aspose-tasks-cloud/) | [NPM](https://www.npmjs.com/package/@asposecloud/aspose-tasks-cloud) | [Go.Dev](https://pkg.go.dev/github.com/aspose-tasks-cloud/aspose-tasks-cloud-go/) |

  [Product Page](https://products.aspose.cloud/tasks/python) | [Documentation](https://docs.aspose.cloud/display/taskscloud/Home) | [API Reference](https://apireference.aspose.cloud/tasks/) | [Code Samples](https://github.com/aspose-tasks-cloud/aspose-tasks-cloud-python) | [Blog](https://blog.aspose.cloud/category/tasks/) | [Free Support](https://forum.aspose.cloud/c/tasks) | [Free Trial](https://dashboard.aspose.cloud/#/apps)


pkgId: 04d4bcb9dee6ccd25840d0284ed5c8bf6075d38ec10776e90d8d0df37e06686f
name: python-aspose-total-java
arch: src
version: 24.10.0
epoch: 0
release: 1
url: https://products.aspose.com/total/python-java
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-total-java-24.10.0-1.src.rpm
checksum_type: sha256
summary:
  Aspose.Total for Python via Java is a file format Processing python class library that allows developers to work with Microsoft Excel®, Microsoft Visio®, and barcode file formats without needing Office Automation.

description:
  [Home](https://www.aspose.com/) | [Product Page](https://products.aspose.com/total/python-java) | [Docs](https://docs.aspose.com/total/pythonjava/) | [Demos](https://products.aspose.app/total/family) | [Examples](https://aspose.github.io/) | [Download](https://downloads.aspose.com/total/pythonjava) | [Blog](https://blog.aspose.com/category/total/) | [Releases](https://releases.aspose.com/) | [Free Support](https://forum.aspose.com/c/total/7) | [Temporary License](https://purchase.aspose.com/temporary-license)



  Aspose.BarCode for Python via Java is an on-premise API that can generate, read, & recognize barcodes without any 3rd party software. Create multiple types of barcodes (1D, 2D, Postal) with support for several barcode symbologies (numeric, alpha-numeric, 2D). Set barcode code text and configure its contents, formatting, & appearance. Support for checksum and supplement data is available. Customize barcode image color, back color, and bar color, bar height, and rotation etc. Anti-Aliasing for barcode images is also supported.



  - **Image:** JPEG, PNG, BMP, GIF

  ```python
  pip install aspose-barcode-for-python-via-java==24.10.1
  ```



  Aspose.Cells for Python via Java is a fast & reliable Python class library to incorporate spreadhseet processing capabilities into your Python programs. Create, process, render, & convert Microsoft Excel&reg; and OpenOffice&reg; spreadsheets. Work with spreadsheet, worksheet, & workbook tables, images, charts, pivot charts, formula, formatting, page setup, & conditional formatting. It offers an easy solution to automate Excel&reg; reports using python.



  - **Microsoft Excel&reg;:** XLS, XLSX, XLSB, XLTX, XLTM, XLSM, XML
  - **OpenOffice&reg;:** ODS
  - **Text:** CSV, TSV, TXT
  - **Web:** HTML, MHTML



  - **Fixed Layout:** PDF, PDF/A, XPS
  - **Images:** JPEG, PNG, BMP, SVG, EMF

  ```python
  pip install aspose-cells==24.10.0
  ```



  Aspose.Diagram for Python via Java is a class library that enables your applications to work with, process, and manipulate Microsoft Visio&reg; drawings from within your programs without the need to install any 3rd party software. Create various types of Visio&reg; diagrams from scratch, read various Visio&reg; file formats, edit Visio document properties, and export Visio&reg; Shapes to various other file formats.



  - **Microsoft Visio:** VSDX, VDX, VSX, VTX, VSSX, VSTX, VSDM, VSSM, VSTM



  - **Microsoft Visio:** VDW, VSD, VSS, VST



  - **Fixed Layout:** PDF, XPS
  - **Images:** JPEG, PNG, BMP, TIFF, SVG, EMF
  - **Others:** XAML

  ```python
  pip install aspose-diagram==24.10.0
  ```



  Effortlessly extract text from images with Aspose.OCR for Python via JAVA. This powerful yet simple OCR engine unlocks text in 28 languages, handling scans, photos, and even distorted images with minimal code. Forget complex machine learning – our robust API delivers accurate results in popular formats. Boost your Python projects with Aspose.OCR today!



  Aspose.OCR for Python via Java can recognize the following formats:

  - **Images:** JPG, PNG, TIFF/TIF, GIF, BMP, DJVU
  - **Fixed Layout:** PDF



  The recognition results can be saved into the following formats:

  - **Microsoft Office&reg;:** DOCX, XLSX
  - **Web:** HTML
  - **eBooks:** EPUB
  - **Other:** TXT, RTF, PDF, JSON, XML

  ```python
  pip install aspose-ocr-python-java==24.7.0
  ```



  Aspose.PDF for Python via Java is a robust and reliable pdf generation and recognition component, written in Python and Java. It allows developers to quickly and easily add pdf creation and scanning functionality to their Python applications.



  - **Microsoft Office&reg;:** XLS, XLSX
  - **Web:** HTML
  - **eBooks:** EPUB
  - **Other:** TEX, XML, SVG, MD, MHT



  - **Fixed Layout:** PDF, XPS
  - **Microsoft Office&reg;:** CGM
  - **Others:** PS, PCL, CGM, XSLFO/XML



  - **Microsoft Office:** DOC, DOCX, PPTX
  - **Images:** JPEG, PNG, BMP, TIFF, GIF
  - **Other:** MobiXML, XML, TEXT

  ```python
  pip install aspose-pdf-for-python-via-java==24.9
  ```



  - Read Microsoft Excel&reg; & OpenOffice&reg; Spreadsheets via Python
  - Convert Excel&reg; & ODS formats to PDF, XPS, images, & EMF
  - Work with tables, rows, columns, cells, charts, conditional formatting
  - Create Microsoft Visio&reg; diagrams & flowcharts
  - Export Visio&reg; diagrams to PDF, XPS, Images, & XAML formats
  - Generate & recognize various types of 1D, 2D, & postal barcodes
  - Set code text for barcode labels
  - Support for popular barcode symbologies
  - many many more.

  [Home](https://www.aspose.com/) | [Product Page](https://products.aspose.com/total/python-java) | [Docs](https://docs.aspose.com/total/pythonjava/) | [Demos](https://products.aspose.app/total/family) | [Examples](https://aspose.github.io/) | [Download](https://downloads.aspose.com/total/pythonjava) | [Blog](https://blog.aspose.com/category/total/) | [Releases](https://releases.aspose.com/) | [Free Support](https://forum.aspose.com/c/total/7) | [Temporary License](https://purchase.aspose.com/temporary-license)


pkgId: fa059a3175243109b9428e6c27f3c498afe1f16fd08eaa5b960d6fa33d8e7996
name: python-aspose-total-java
arch: src
version: 24.11.0
epoch: 0
release: 1
url: https://products.aspose.com/total/python-java
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-total-java-24.11.0-1.src.rpm
checksum_type: sha256
summary:
  Aspose.Total for Python via Java is a file format Processing python class library that allows developers to work with Microsoft Excel®, Microsoft Visio®, and barcode file formats without needing Office Automation.

description:
  [Home](https://www.aspose.com/) | [Product Page](https://products.aspose.com/total/python-java) | [Docs](https://docs.aspose.com/total/pythonjava/) | [Demos](https://products.aspose.app/total/family) | [Examples](https://aspose.github.io/) | [Download](https://downloads.aspose.com/total/pythonjava) | [Blog](https://blog.aspose.com/category/total/) | [Releases](https://releases.aspose.com/) | [Free Support](https://forum.aspose.com/c/total/7) | [Temporary License](https://purchase.aspose.com/temporary-license)



  Aspose.Diagram for Python via Java is a class library that enables your applications to work with, process, and manipulate Microsoft Visio&reg; drawings from within your programs without the need to install any 3rd party software. Create various types of Visio&reg; diagrams from scratch, read various Visio&reg; file formats, edit Visio document properties, and export Visio&reg; Shapes to various other file formats.



  - **Microsoft Visio:** VSDX, VDX, VSX, VTX, VSSX, VSTX, VSDM, VSSM, VSTM



  - **Microsoft Visio:** VDW, VSD, VSS, VST



  - **Fixed Layout:** PDF, XPS
  - **Images:** JPEG, PNG, BMP, TIFF, SVG, EMF
  - **Others:** XAML

  ```python
  pip install aspose-diagram==24.11.0
  ```



  Effortlessly extract text from images with Aspose.OCR for Python via JAVA. This powerful yet simple OCR engine unlocks text in 28 languages, handling scans, photos, and even distorted images with minimal code. Forget complex machine learning – our robust API delivers accurate results in popular formats. Boost your Python projects with Aspose.OCR today!



  Aspose.OCR for Python via Java can recognize the following formats:

  - **Images:** JPG, PNG, TIFF/TIF, GIF, BMP, DJVU
  - **Fixed Layout:** PDF



  The recognition results can be saved into the following formats:

  - **Microsoft Office&reg;:** DOCX, XLSX
  - **Web:** HTML
  - **eBooks:** EPUB
  - **Other:** TXT, RTF, PDF, JSON, XML

  ```python
  pip install aspose-ocr-python-java==24.7.0
  ```



  Aspose.PDF for Python via Java is a robust and reliable pdf generation and recognition component, written in Python and Java. It allows developers to quickly and easily add pdf creation and scanning functionality to their Python applications.



  - **Microsoft Office&reg;:** XLS, XLSX
  - **Web:** HTML
  - **eBooks:** EPUB
  - **Other:** TEX, XML, SVG, MD, MHT



  - **Fixed Layout:** PDF, XPS
  - **Microsoft Office&reg;:** CGM
  - **Others:** PS, PCL, CGM, XSLFO/XML



  - **Microsoft Office:** DOC, DOCX, PPTX
  - **Images:** JPEG, PNG, BMP, TIFF, GIF
  - **Other:** MobiXML, XML, TEXT

  ```python
  pip install aspose-pdf-for-python-via-java==24.9
  ```



  - Read Microsoft Excel&reg; & OpenOffice&reg; Spreadsheets via Python
  - Convert Excel&reg; & ODS formats to PDF, XPS, images, & EMF
  - Work with tables, rows, columns, cells, charts, conditional formatting
  - Create Microsoft Visio&reg; diagrams & flowcharts
  - Export Visio&reg; diagrams to PDF, XPS, Images, & XAML formats
  - Generate & recognize various types of 1D, 2D, & postal barcodes
  - Set code text for barcode labels
  - Support for popular barcode symbologies
  - many many more.

  [Home](https://www.aspose.com/) | [Product Page](https://products.aspose.com/total/python-java) | [Docs](https://docs.aspose.com/total/pythonjava/) | [Demos](https://products.aspose.app/total/family) | [Examples](https://aspose.github.io/) | [Download](https://downloads.aspose.com/total/pythonjava) | [Blog](https://blog.aspose.com/category/total/) | [Releases](https://releases.aspose.com/) | [Free Support](https://forum.aspose.com/c/total/7) | [Temporary License](https://purchase.aspose.com/temporary-license)


pkgId: e5048614c4d564af6e90104718e62ce04b94c842fa0848408993c5a7863184ce
name: python-aspose-total-net
arch: src
version: 24.11.0
epoch: 0
release: 1
url: https://products.aspose.com/total/python-net
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-total-net-24.11.0-1.src.rpm
checksum_type: sha256
summary:
  Aspose.Total for Python via .NET is a Document Processing python class library that allows developers to work with Microsoft Word®, Microsoft PowerPoint®, Microsoft Outlook®, OpenOffice®, & 3D file formats without needing Office Automation.

description:
  [Product Page](https://products.aspose.com/total/python-net) | [Docs](https://docs.aspose.com/total/pythonnet/) | [Demos](https://products.aspose.app/total/family) | [Examples](https://aspose.github.io/) | [Download](https://downloads.aspose.com/total/pythonnet) | [Blog](https://blog.aspose.com/category/total/) | [Releases](https://releases.aspose.com/) | [Free Support](https://forum.aspose.com/c/total/7) | [Temporary License](https://purchase.aspose.com/temporary-license)

  Aspose.Total for Python via .NET is a collection of powerful yet easy-to-use document processing libraries for Python developers. Create, edit, convert DOC, DOCX, XLSX, XLS, CSV, PPT, PPTX, EML, MSG, 3D, and more formats within Python apps. Render PDF and images with high fidelity, compare documents, protect or encrypt, mail merge, clone slides, work with PowerPoint tables, generate presentations from the database, create custom charts, handle email formats, TNEF attachments, and send/receive emails. Plus, manipulate 3D and CAD files. Aspose.Total for Python via .NET handles a multitude of file formats, including Microsoft Word, PowerPoint, Outlook, OpenOffice, Web, Fixed Layout, Images, and 3D & CAD files. Make Next Generation document processing Apps now!

  This release includes the following:



  Unleash the power of Aspose.3D for Python via .NET, the ultimate Python 3D manipulation high code API. Effortlessly create, process, manipulate, and convert 3D scenes, meshes, and entities - no need for 3rd party software. Enjoy scene creation, animation, geometry, scene hierarchy, triangulate mesh, target camera, 3D plane, shadows, cylinders, conversion, import, and export capabilities. Grow your 3D projects with seamless integration and exceptional 3D control!

  ```python
  pip install aspose-3d==24.10.0
  ```



  Aspose.BarCode for Python via .NET is a barcode generation and scanning library for .NET and Python developers. Create barcode images with precise control over size, captions, colors, and font. Generate QR, MicroQR, and Datamatrix barcodes with custom error correction and encoding. Support error correction and checksum for various symbologies. Adjust 2D barcode size and aspect ratio. Customize image border and style. Detect Unicode encoding, hide long codetext, or reduce font size. Colorize barcode, code text, background, border, and caption. Specify size unit in document, inch, millimeter, pixel, or point.

  ```python
  pip install aspose-barcode-for-python-via-net==24.11
  ```



  Aspose.CAD for Python via .NET is ultimate CAD and BIM drawing processing API for .NET and Python developers. Enhance your apps with high-quality conversion and rendering of DWG, DWF, DWFX, DGN, STL, OBJ, CF2, IGES, IFC, DXF, and more formats to PDF and images. No need for AutoCAD&reg; or rendering workflows. Manipulate drawing entities and blocks, select specific layouts and layers, and adjust drawing size before rendering. Exciting new features in Version 23.6 include support for OBJ file format export, HoloLens 2, and AutoCAD Plotter Configuration (PC3) files.

  ```python
  pip install aspose-cad==24.10
  ```



  Experience the full potential of Aspose.Cells for Python via .NET, our Excel&reg; file handling solution for .NET and Python developers. Create, manipulate, and save Excel&reg; files with ease. Benefit from high-quality format conversion, rendering, and printing capabilities. Effortlessly customize charts, Pivot Tables, and apply advanced formatting. Protect, merge, and parse Excel&reg; sheets seamlessly. Convert charts to images and PDFs while supporting various file formats. Take advantage of the formula calculation engine with support for all Excel functions.

  ```python
  pip install aspose-cells-python==24.11.0
  ```



  Improve Visio&reg; file processing with Aspose.Diagram for Python via .NET. Seamlessly create, manipulate, and convert Visio&reg; files, all without Microsoft Office&reg; dependencies. Enjoy features like shape conversion, comment management, and versatile format inter-conversion. Elevate your Python development workflow now!

  ```python
  pip install aspose-diagram-python==24.11
  ```



  Boost your Python applications with Aspose.Email for Python via .NET, an on-premise API designed to streamline email handling. Send & receive emails with attachments, perform email rendering and format conversions, and download messages from POP3 and IMAP servers. Seamlessly send iCalendar compliant appointments or meetings and work with message storage files. SSL & TLS support included. Uplift your email capabilities now!

  ```python
  pip install Aspose.Email-for-Python-via-NET==24.11
  ```



  Aspose.Finance for Python via .NET is a powerful API for processing finance-related formats like XBRL, iXBRL, and OFX using Python. It allows creation, manipulation, and conversion of XBRL, iXBRL, and OFX files, providing a comprehensive solution for developers. With features like XBRL and iXBRL creation, format conversion, validation, and more, Aspose.Finance streamlines financial data handling with ease and efficiency.

  ```python
  pip install aspose-finance==24.11
  ```



  Aspose.HTML for Python via .NET is a powerful API offering headless browser functionality to create, manipulate, and convert HTML documents. Effortlessly convert HTML to PDF, XPS, DOCX, PNG, JPEG, BMP, TIFF, and GIF, and handle SVG and EPUB formats. Navigate documents, monitor DOM changes, extract CSS, and use external data sources.

  ```python
  pip install aspose-html-net==24.11.0
  ```



  Aspose.Imaging for Python via .NET is an advanced image processing library. Easily create, load, manipulate, convert, compress images. Supports drawing and graphic primitives. Core features include; image export & conversion, transformations (resize, crop, flip &rotate, etc.), filtering, memory optimization. Handles popular formats like DjVu, DICOM, WebP & DNG, and extends .NET & .NET Core support. Cross-platform; Windows & Linux compatible. Explore powerful features now: create, read, write, draw, process & convert images effortlessly with Aspose.Imaging!

  ```python
  pip install aspose-imaging-python-net==24.11.0
  ```



  Aspose.OCR for Python via .NET is an easy-to-use OCR engine for Python Apps. Recognize text in 28 languages, Latin, Cyrillic & Asian scripts. Extract text from scans, photos, PDFs. Handle blurry, distorted, rotated, noisy images. Preserve original layout, detect paragraphs, lines, single words. Bulk process multipage docs, folders, archives. Identify misspelled words, compare image texts. Simplify OCR tasks with Aspose.OCR!

  ```python
  pip install aspose-ocr-python-net==24.11.1
  ```



  Aspose.Page for Python via .NET empowers developers to work with PS, EPS, and XPS formats seamlessly, eliminating the need for Microsoft Office or Adobe products entirely. Streamline your document processing workflows today! Effortlessly integrate this lightweight library into your Python projects using pip.

  ```python
  pip install aspose-page==24.9.0
  ```



  Aspose.PDF for Python via .NET is a powerful native library for PDF processing in your applications. Generate, read, convert, and manipulate PDF files without Adobe Acrobat&reg;. Perform form processing, metadata handling, text and page manipulation, annotations management, bookmarks and watermarks, attachments, custom font handling, and more. Supercharge your PDF capabilities via API!

  ```python
  pip install aspose-pdf==24.11.0
  ```



  Aspose.PSD for Python simplifies handling of PSD, PSB, and AI files. It allows creation, editing, conversion, and export to various formats while supporting advanced features like layer manipulation, effects, and drawing tools. This cross-platform library caters to diverse use cases with robust functionality.

  ```python
  pip install aspose-psd==24.11.0
  ```



  Level up your Python programs with Aspose.Slides for Python via .NET - the ultimate Python class library for PowerPoint&reg; & OpenOffice&reg; presentations. No need to install Microsoft PowerPoint&reg; or any 3rd party software. Effortlessly create, clone, and manipulate slides from templates. Master slides, animations, charts, shapes, OLE, VBA Macros, video frames, picture frames, audio frames, encryption, and decryption - all at your fingertips. Elevate your presentation game now!

  ```python
  pip install Aspose.Slides==24.11.0
  ```



  Aspose.SVG for Python via .NET is a versatile on-premise class library designed to handle a variety of tasks involving SVG files without the need for additional SVG tools. It enables you to create, edit, optimize, and convert SVG files. The Python API allows for document and element manipulation, providing advanced navigation and inspection features such as XPath queries and CSS selectors. Developers can also vectorize images and texts, apply SVG transformations, filters, gradients, and patterns, and specify colors in various formats. Aspose.SVG for Python via .NET is ideal for creating applications like SVG editors, converters, mergers, and image vectorizers, offering comprehensive SVG processing capabilities for developers.

  ```python
  pip install aspose-svg-net==24.11.0
  ```



  Aspose.Tasks for Python via .NET, a powerful native library for adding MS-Project file processing capabilities to your applications. Easily create, read, convert, and manipulate MS-Project files without Microsoft Project&reg; itself. Perform calculations, manage tasks, resources, and calendars, manipulate views, and handle attachments effortlessly. Enjoy features like export to various image formats, XLSX, HTML, CSV, and PDF, along with support for Oracle Primavera&reg; and Project Server. Supported MS-Project versions include 2003 to 2021. Convert MPP to images, Excel, HTML, CSV, and PDF with ease. Manage tasks, resources, assignments, and customize Gantt Chart view styles.

  ```python
  pip install aspose-tasks==24.11.0
  ```



  Streamline your document creation process with Aspose.TeX for Python via .NET, the powerful TeX/LaTeX processing library for developers Effortlessly typeset complex documents in various TeX and LaTeX formats, without relying on external software. Get started quickly by integrating Aspose.TeX into your Python projects using pip.

  ```python
  pip install aspose-tex-net==24.10.0
  ```



  Empower your Python applications with Aspose.Words for Python via .NET, an on-premise API for seamless Microsoft Word&reg; document handling. Create, edit, render, and convert Word&reg; files to various formats (PDF, XPS, Raster Image, PCL, EPUB, etc.) effortlessly. Enjoy report generation, data visualization, and a range of document tasks like viewing, merging, splitting, translating, watermarking, and comparison. Level up your document processing now!

  ```python
  pip install aspose-words==24.11.0
  ```



  Aspose.ZIP for Python via .NET is a powerful Python API to create, manipulate, extract & protect archive formats - ZIP, BZIP, BZ2 & TAR. Simplify compression/decompression in your Python apps without complex coding. Offers a wide range of features, including archive creation, extraction, encryption (password, AES), and compressing single/multiple files and directories. Secure your files with password or AES encryption. Explore advanced options like appending files to existing archives, Gzip/Bzip2 packing into TAR archives, and creating self-extracting compressed archives.

  ```python
  pip install aspose-zip==24.11.0
  ```

  [Product Page](https://products.aspose.com/total/python-net) | [Docs](https://docs.aspose.com/total/pythonnet/) | [Demos](https://products.aspose.app/total/family) | [Examples](https://aspose.github.io/) | [Download](https://downloads.aspose.com/total/pythonnet) | [Blog](https://blog.aspose.com/category/total/) | [Releases](https://releases.aspose.com/) | [Free Support](https://forum.aspose.com/c/total/7) | [Temporary License](https://purchase.aspose.com/temporary-license)


pkgId: 5df7472b7f34f71fe2ed3672e443ba6a2b8904354bb4a24f6576e707d245b246
name: python-aspose-words-cloud
arch: src
version: 24.11.0
epoch: 0
release: 1
url: https://github.com/aspose-words-cloud/aspose-words-cloud-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aspose-words-cloud-24.11.0-1.src.rpm
checksum_type: sha256
summary:
  Python Cloud SDK wraps Aspose.Words Cloud API so you could seamlessly integrate Microsoft Word file generation, manipulation, conversion & inspection features into your own python applications.

description:
  Python Cloud SDK wraps Aspose.Words Cloud API so you could seamlessly integrate Microsoft Word® file generation, manipulation, conversion & inspection features into your own python applications.

  [Aspose.Words Cloud SDK for Python](https://products.aspose.cloud/words/python) allows to work with Word document headers, footers, page numbering, tables, sections, document comments, drawing objects, FormFields, fonts, hyperlinks, ranges, paragraphs, math objects, watermarks, revisions and document protection. It also assists in appending documents, splitting documents as well as converting document to other supported file formats. Please feel free to explore the [Developer's Guide](https://docs.aspose.cloud/display/wordscloud/Developer+Guide) for all possible usage scenarios.



  - Programmatically create new documents of various file formats.
  - Availability of Mail Merge and report generation features.
  - Split or merge documents on demand.
  - Manage watermarks and protection.
  - Full read & write access to Document Object Model.
  - Fetch web pages via URL and save in Microsoft Word file formats.
  - Get document information in JSON or XML representation.
  - [Fetch statistical data](https://docs.aspose.cloud/display/wordscloud/Get+Document+Statistics) of a document.
  - [Remove all macros](https://docs.aspose.cloud/display/wordscloud/Remove+all+Macros+from+Document) contained in a specific document.
  - [Convert a document to desired file format](https://docs.aspose.cloud/display/wordscloud/Convert+Document+to+Destination+Format+with+Detailed+Settings+and+Save+Result+to+Storage) along with detailed settings.
  - Convert an encrypted PDF document into Word document format.



  - Added GetAllRevisions method to obtain all available revisions in document.
  - Added AppendAllEntriesToOneSection parameter to AppendDocument method to append entries to the same section.




  - Added digital signature methds for DOC, DOCX, XPS, or ODT documents.
  - Added ReplaceBackslashWithYenSign property for XpsSaveOptions and HtmlSaveOptions.
  - Added DigitalSignature property for XpsSaveOptions.
  - Added UseSdtTagAsFormFieldName property for PdfSaveOptions.
  - Added MergeWholeDocument parameter to the MailMerge operations to update fields in whole document after executing of a mail merge with regions.




  - Added the support of OpenType standard. It is usefull for languages required advanced typography.




  - Added support for azw3 (Amazon Kindle Format) documents.
  - Added 'MaxImageResolution' property for SvgSaveOptionsData class.




  - Added the 'TranslateNodeId' method to transalate a node id to a node path.




  - Added the support of multistorage operations. Saving a file as a result of an operation can be performed in a specific storage, when, used file path in the next format '@storage:path/to/file.doc'.




  - Added the 'MergeWithNext' method to merge a section with the next one.
  - Added the 'LockAspectRatio' propperty for DrawingObjectInsert and DrawingObjectUpdate methods.




  - Added support for 'RemoveEmptyCells' option for the 'Cleanup' parameter in the insert 'MailMerge' API method.




  - Added support for InsertAfterNode in the insert API without NodePath.
  - Added support for inserting nodes (runs/rows/cells/bookmarks) without NodePath.
  - Added support for transparency in the Watermark API.
  - Added support for password and encryptedPassword fields in FileReference.
  - Fixed missing href value in document responses.




  - Properties Name, Text, StartRange, EndRange marked as required for InsertBookmark operation.
  - Implemented DeleteOfficeMathObjects operation to delete all office math objects from document.
  - Parameter ProtectionRequest was removed from the UnprotectDocument operation. Now removing protection from a document does not require a password.
  - Model ProtectionRequest marked as deprecated, please use ProtectionRequestV2 instead for perform ProtectDocument operation. To change the password or protection type of protected document, the old password is no required.
  - Added fields Password and EncryptedPassword to FileReference for documents encrypted by password.
  - Removed parameter encryptedPassword2 from CompareDocument method. Please use FileReference password instead.
  - Rename aspose-client header.



  - Support of required properties in models.
  - Property StyleName marked as required for InsertStyle operation.
  - Property StyleName marked as required for CopyStyle operation.
  - Property StyleName marked as required for ApplyStyleToDocumentElement operation.
  - Properties SdtType and Level marked as required for InsertStructuredDocumentTag operation.
  - Property Text marked as required for InsertParagraphoperation.
  - Property Value marked as required for CreateOrUpdateDocumentProperty operation.
  - Property NewValue marked as required for ReplaceText operation.
  - Property Text marked as required for ReplaceWithText operation.




  - Support for class inheritance in responses from the server.




  - Fix XMLHttpRequest in web applications.




  - Added InsertSection method.




  - Added new type of RangeEndIdentifier for RangeApi: document:end




  - Fix compatibility between CreateDocument API and Dropbox storage.
  - Fix compatibility for property PageCount for FixedPageSaveOptionsData.




  - Added operations to manipulate with Structure Document Tags (SDT) in documents.




  - Various changes related to stability and performance




  - Various changes related to stability and performance




  - Added 'EmbedAttachments' property for PdfSaveOptionsData class.




  - Added 'CacheHeaderFooterShapes' property for PdfSaveOptionsData class.
  - FileReference structure has been added that allows to determine how the document will be accessed: from the remote storage, or loaded directly in the request.
  - The 'AppendDocument' and 'AppendDocumentOnline' methods takes a 'FileReference' instead of an 'href' property.
  - Added property 'StartingNumber' for 'PageNumbers' class.
  - Added property 'GlobalCultureName' for 'FieldOptions' class.




  - CompressDocument method now can handle images.
  - Added support to convert password protected document using ConvertDocument API.




  - Added optional loadEncoding and password parameters for ConvertDocument API method.




  - Expand 'AppendDocument' API method to support 'ImageEntryList' for directly appending images to documents and another images.
  - Added 'CompressDocument' API method to support compression and resizing images inside the document for reduce the size of the document.




  - Added 'DeleteBookmark' and 'DeleteBookmarkOnline' API methods for delete bookmarks by name from the document.
  - Added 'DeleteBookmarks' and 'DeleteBookmarksOnline' API methods for delete all bookmarks from the document.
  - Added 'InsertBookmark' and 'InsertBookmarkOnline' API methods for create new bookmarks in the document.
  - Support all save formats for 'CreateDocument' operation.




  - Internal API fixes and improvments.




  - Added ExportShapesAsSvg to HtmlSaveOption.
  - Added new endpoint '~/styles/copy_from'.




  - Online methods returns the dictionary of files with included original filename as key instead of single file content in responses.
  - Parameters contained sensitive data should be passed in encrypted form. Names of the parameters have 'encrypted' prefix.
  - Added Encrypt method to encrypt data on the API public key. Use it to prepare values for parameters required encrypted data.
  - Changed type of enumerations for members of SaveOptionsData and other inherited classes from string to enum.




  - Made 'SaveOprionsData.SaveFormat' property readonly with default value.
  - Added subclasses for all formats of SaveOprionsData with specified SaveFormat.
  - 'SaveOptionsData', 'FixedPageSaveOptionsData', 'ImageSaveOptionsData', 'OoxmlSaveOptionsData', 'TxtSaveOptionsBaseData' classes now is abstract.




  - Added 'FieldOptions.FieldUpdateCultureName' to set Culture for fields
  - Added 'DocumentEntry.Password' to set an encrypted password for appending document
  - Added 'encryptedPassword2' query parameter to CompareDocuments to set an encrypted password for the second comparing document




  - Added FieldOptions parameter to mail merge operations
  - Added timeout parameter to api configuration








  - Removed 'GraphicsQualityOptions' image save option as it no longer supported.
  - Added query parameter 'displayIntermediateResults' for batch requests. If 'false', the last response in batch will be returned only. Default is 'true'
  - Added 'JsonDataLoadOptions' and 'XmlDataLoadOptions' to 'ReportEngineSettings'




  - Added new api methods to get, insert, update or delete custom xml parts from documents.
  - Added parameter 'ResultDocumentFormat' to Compare API
  - Added 'ExportLanguageToSpanTag' pdf save option
  - Added 'FlatOpcXmlMappingOnly' save option




  - ImlRenderingMode option introduced witch is used to determine how ink (InkML) objects are rendered
  - MaxCharactersPerLine option introduced which is used to specify the maximum number of characters per one line
  - Added new API method to get a RSA public key to encrypt document passwords
  - Added encryptedPassword common query option to pass an encrypted document password




  - Implemented beta version of CompareDocumentOnline feature with both document sending in request
  - CompareDocument method now can handle PDF files
  - AcceptAllRevisionsBeforeComparison option introduced which is used to specify if accept all revisions before comparison




  - Update dependencies in sdk




  - Removed obsolete pdf save option 'EscapeUri'
  - SaveOptions now contains CustomTimeZoneInfo to set custom timezone when SdtType.Date structured document tag updated from custom XML
  - Url of child requests in batch can be full now (earlier it can be only relative)
  - Added 'RquestId' header to all responses




  - Added 'UpdateCreatedTimeProperty' save option
  - Added Tables into HeaderFooter so it's possible to address paragraphs inside table which is located in headerfooter (sections/0/headersfooters/1/tables/0/rows/0/cells/0/paragraphs/0)




  - Added delete all comments method




  - Added online version for all API methods




  - In configuration json file appSid / appKey has been replaced to clientId / clientSecret.
  - In Words API initialization methods clientId parameter precedes clientSecret parameter.




  - Internal API changes.




  - Added Batch API feature




  - Added new api method (PUT '/words/{name}/compatibility/optimize') which is allows to optimize the document contents as well as default Aspose.Words behavior to a particular versions of MS Word
  - Added 'ApplyBaseDocumentHeadersAndFootersToAppendingDocuments' option to 'DocumentEntryList' for AppendDocument API
  - WithoutNodePath methods have been removed, pass null values instead




  - Added 'Markdown' save format
  - Added endpoint to update paragraph format without node path (PUT '/words/{name}/paragraphs/{index}/format')




  - Added new methods:
    - DeleteAllParagraphTabStopsWithoutNodePath
    - DeleteParagraphTabStopWithoutNodePath
    - GetParagraphTabStopsWithoutNodePath
    - InsertOrUpdateParagraphTabStopWithoutNodePath
    - InsertParagraphWithoutNodePath
    - UpdateParagraphFormatWithoutNodePath
    - UpdateParagraphListFormatWithoutNodePath
    - DeleteParagraphListFormatWithoutNodePath
  - DrawingObject related methods have been changed body content. Special request classes are introduced instead of strings.
  - InsertOrUpdateParagraphTabStop, DeleteParagraphTabStop methods have been changed parameter order
  - OoxmlSaveOptionsData.CompressionLevel property has been added




  - Added methods to work with Word document lists
    - GetLists
    - GetList
    - InsertList
    - UpdateList
    - UpdateListLevel
  - Added methods to work with styles
    - GetStyles
    - UpdateStyle
    - InsertStyle
    - CopyStyle
    - GetStyleFromDocumentElement
    - ApplyStyleToDocumentElement
  - Added methods to work with paragraph list format
    - GetParagraphListFormat
    - GetParagraphListFormatWithoutNodePath
    - UpdateParagraphListFormat
    - DeleteParagraphListFormat
  - Added methods to work with paragraph tab stops
    - GetParagraphTabStops
    - InsertOrUpdateParagraphTabStop
    - DeleteAllParagraphTabStops
    - DeleteParagraphTabStop
  - Added methods to build reports
    - BuildReport
    - BuildReportOnline
  - Added Shading property to ParagraphFormat




  **Microsoft Word:** DOC, DOCX, RTF, DOT, DOTX, DOTM, FlatOPC (XML)
  **OpenOffice:** ODT, OTT
  **WordprocessingML:** XML
  **Web:** HTML, MHTML, HtmlFixed
  **Text:** TXT
  **Fixed Layout:** PDF



  **Fixed Layout:** PDF/A, XPS, OpenXPS, PS
  **Images:** JPEG, PNG, BMP, SVG, TIFF, EMF
  **Others:** PCL



  Aspose.Words Cloud’s platform independent document manipulation API is a true REST API that can be used from any platform. You can use it with any language or platform that supports REST, be it the web, desktop, mobile, or the cloud. The API integrates with other cloud services to provide you the flexibility you require for processing documents. It is suitable for the most types of businesses, documents, or content.



  Firstly, create an account at [Aspose for Cloud](https://dashboard.aspose.cloud/#/apps) to get your application information and free quota to use the API. Now execute `pip install aspose-words-cloud` from the command line to fetch the SDK. Then import the package via `import asposewordscloud`.



  Execute `python setup.py install --user` and import the package as `import asposewordscloud`.

  The complete source code is available at [GitHub Repository](https://github.com/aspose-words-cloud/aspose-words-cloud-python).



  ```python
          

          self.words_api = asposewordscloud.WordsApi(client_id, client_secret, base_url)

          upload_request = asposewordscloud.models.requests.UploadFileRequest(
              open(os.path.join(local_folder, filename), 'rb'), os.path.join(remote_folder, remote_name))
          self.words_api.upload_file(upload_request)

          request = asposewordscloud.models.requests.DeleteWatermarkRequest(remote_name, remote_folder)
          self.words_api.delete_watermark(request)

          
  ```

  [Product Page](https://products.aspose.cloud/words/python) | [Documentation](https://docs.aspose.cloud/display/wordscloud/Home) | [API Reference](https://apireference.aspose.cloud/words/) | [Code Samples](https://github.com/aspose-words-cloud/aspose-words-cloud-python) | [Blog](https://blog.aspose.cloud/category/words/) | [Free Support](https://forum.aspose.cloud/c/words) | [Free Trial](https://dashboard.aspose.cloud/#/apps)


