# packages

pkgId: d0025262c62b829ab0e7faf037d56e00fc97810b4a30aa33bc2751f399d27494
name: python-astc-encoder-py
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: a python wrapper for astc-encoder
url: https://github.com/K0lb3/astc-encoder-py
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astc-encoder-py-0.1.10-1.src.rpm
checksum_type: sha256
description:
  [![Win/Mac/Linux](https://img.shields.io/badge/platform-windows%20%7C%20macos%20%7C%20linux-informational)]()
  [![MIT](https://img.shields.io/github/license/K0lb3/astc-encoder-py)](https://github.com/K0lb3/astc-encoder-py/blob/master/LICENSE)
  [![Docs](https://github.com/K0lb3/astc-encoder-py/actions/workflows/doc.yml/badge.svg?branch=main)](k0lb3.github.io/astc-encoder-py/)


  ``astc-encoder-py`` is a  Python binding of [astc-encoder](https://github.com/ARM-software/astc-encoder).
  It can compress images into astc textures and decompress astc textures into images.



  **Python 3.7+**

  ```bash
  pip install astc-encoder-py
  ```

  There are prebuild wheels for all platforms covered by cibuildwheel.






  ```py

  import astc_encoder.pil_codec


  profile: int = 1 # LDR_SRGB = 0, LDR = 1, HDR_RGB_LDR_A = 2, HDR = 3
  block_width: int = 4
  block_height: int = 4

  Image.frombytes("RGBA", (512, 512), comp, "astc", (profile, block_width, block_height)).show()

  quality: float = 100 # 0-100, medium is 60
  Image.tobytes("astc", (profile, quality, block_width, block_height))
  ```


  ```py
  from PIL import Image

  from astc_encoder import (
   ASTCConfig,
   ASTCContext,
   ASTCImage,
   ASTCProfile,
   ASTCSwizzle,
   ASTCType,
  )






  config = ASTCConfig(ASTCProfile.LDR_SRGB, 4, 4)




  context = ASTCContext(config)


  img = Image.new("RGBA", (512, 512), (255, 0, 0, 255))


  image = ASTCImage(ASTCType.U8, *img.size, data=img.tobytes())


  swizzle = ASTCSwizzle.from_str("RGBA")


  comp = context.compress(image, swizzle)


  image_dec = ASTCImage(ASTCType.U8, *img.size)



  context.decompress(comp, image_dec, swizzle)


  img = Image.frombytes("RGBA", img.size, image_dec.data)
  ```


  - [x] figuring out segfault for re-using ASTCImage
  - [x] creating ASTCSwizzle from strings instead of from ints
  - [ ] creating ASTCImage directly from PIL.Image
  - [x] ~~export ASTCImage directly to PIL.Image~~ via PIL.ImageDecoder
  - [ ] SVE support for arm
  - [x] tests
  - [x] docs page

rpm_license:
  MIT License  Copyright (c) 2024 Rudolf Kolbe  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: 631e066b1de6daf80bf14b2c4427ff1b45f226cdb71f834857ae2324d7975263
name: python-astcheck
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Check Python ASTs against templates
url: https://pypi.org/project/astcheck/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astcheck-0.4.0-1.src.rpm
checksum_type: sha256
description:
  astcheck compares Python Abstract Syntax Trees against a template. This is
  useful for testing software that automatically generates or modifies Python code.
  Installation::
      pip install astcheck
  Example use:
      import ast, astcheck
      template = ast.Module(body=[
          ast.FunctionDef(name='double', args=ast.arguments(args=[ast.arg(arg='a')])),
          ast.Assign(value=ast.Call(func=ast.Name(id='double')))
      ])
      sample = """
      def double(a):
          do_things()
          return a*2
      b = double(a)
      """
      astcheck.assert_ast_like(ast.parse(sample), template)
  Only the parts specified in the template are checked. In this example, the code
  inside the function, and the assignment target (``b``) could be anything.
  For more details, see `the documentation <http://astcheck.readthedocs.org/en/latest/index.html>`_.


pkgId: e9669e30c97b2078cb8ca57ac377ff21f02f8dc5c919c98a1330b730fad27e9f
name: python-asteca
arch: src
version: 0.5.8
epoch: 0
release: 1
summary: Stellar cluster analysis package
url: https://asteca.github.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asteca-0.5.8-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <br>
    <img src="https://raw.githubusercontent.com/asteca/ASteCA/main/docs/_static/asteca_icon.webp" alt="asteca" width="200"/>
    <br>
  </div>



  [![AA](https://img.shields.io/badge/A%26A-576--A6,%202015-yellowgreen.svg)][1]
  [![License](https://img.shields.io/badge/license-MIT-blue)][2]

  **ASteCA** is a package designed to automatize the usual analysis applied on star
  clusters, in order to estimate their characteristics and fundamental parameters.

  Install with:

  ```
  pip install asteca
  ```

  See the [documentation](https://asteca.github.io) for more details. If you use this
  package in your research, please cite its accompanying [article][1] using the following
  Bibtex:

  ````
  @article{Perren_2015,
      author = {{Perren, G. I.} and {V\'azquez, R. A.} and {Piatti, A. E.}},
      title = {ASteCA: Automated Stellar Cluster Analysis},
      DOI= "10.1051/0004-6361/201424946",
      url= "http://dx.doi.org/10.1051/0004-6361/201424946",
      journal = {A\&A},
      year = 2015,
      volume = 576,
      pages = "A6",
      month = "04",
  }
  ````

  [1]: http://www.aanda.org/articles/aa/abs/2015/04/aa24946-14/aa24946-14.html
  [2]: https://opensource.org/license/mit/
  [3]: http://asteca.github.io
  [4]: https://github.com/asteca/asteca/releases/latest


pkgId: 2a678b76121d0a6a12995c634c9b7ffc9e86a17c5fe91a417a8246a6b5cc32cd
name: python-asterisk-security
arch: src
version: 0.1.4.1203.2254
epoch: 0
release: 1
summary: Security module for asterisk series.
url: https://pypi.org/project/asterisk-security/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asterisk-security-0.1.4.1203.2254-1.src.rpm
checksum_type: sha256
description:
  这个小项目最初是几年前写Django的项目，想在后端写个cookie的加密功能，后来就自己动手写了一个可以加密的函数。主要是个人工作的积累而已。随着后续开发的需求，将不断将更多的个人经验总结道这个开源项目。

  项目交流与缺陷提交[这里](https://gitee.com/zhangxin_1/asterisk-security)

  注意：

  * 发行版本的版本号不一定连续，中间的版本号都是开发中的版本号，不正式发布。
  * 版本号为A.B.C.mmdd.hhmm的格式，只须关注A.B.C即可，mmdd.hhmm为build时间戳



  ```markdown
  /
  |-- asterisksecurity/
  |   |-- encryption.py
  |   |   |-- AsteriskEncrypt
  |   |
  |   |-- error.py
  |   |   |-- InvalidEncriptionKey
  ```



  1. `pip install asterisk-security`





  1. 需要以key来实例化`AsteriskEncrypt`类
  2. `encrypt`方法可以将传参字符串进行加密并返回字符串
  3. `decrypt`方法将已加密的字符串进行解密

  例子：

  ```python
  from asterisksecurity.encryption import AsteriskEncrypt

  def test_encrypt():
      key = 'X7UJi2VdqcQlc3thv2dDPEn5y3yv3eTk35yyAhlKeAY1'
      a = AsteriskEncrypt(key)
      s = '你好世界！Hello World!'
      s_enc = a.encrypt(s)
      print(s_enc)

      a_dec = a.decrypt(s_enc)
      print(a_dec)

  if __name__ == '__main__':
      test_encrypt()

  ```



  * 使用asencrypt命令

  ```command-line
  usage: asencrypt [-h] [-key K] [-txt T]

  asterisk-security加密工具

  options:
    -h, --help  show this help message and exit
    -key K      加密密钥，长度不能超过22个字符，否则，进行左右11个字符截取，格式：[a-zA-Z0-9]+，不得包含特殊字符 encrypt key, length should not exceed 22 characters, otherwise, left and
                right 11 characters will be intercepted, format: [a-zA-Z0-9]+, no special characters allowed
    -txt T      需要加密的字符串 string to be encrypted```markdown


  ```

  * 使用asdecrypt命令

  ```command-line
  usage: asdecrypt [-h] [-key K] [-txt T]

  asterisk-security解密工具

  options:
    -h, --help  show this help message and exit
    -key K      解密密钥，长度不能超过22个字符，否则，进行左右11个字符截取，格式：[a-zA-Z0-9]+，不得包含特殊字符 decrypt key, length should not exceed 22 characters, otherwise, left and
                right 11 characters will be intercepted, format: [a-zA-Z0-9]+, no special characters allowed
    -txt T      需要解密的字符串 string to be decrypted
  ```



  1. key字符串如果不符合格式要求，会抛出error
  2. 其他在解密过程中有任何error都不做处理。



  1. Fork 本仓库
  2. 新建 Feat_xxx 分支
  3. 提交代码
  4. 新建 Pull Request


pkgId: 71aef19c8e7a25ab952b54c710cb04e10be08d5c0369ea2950f386912c4d5cf6
name: python-asterism
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Helpers for Project Electron infrastructure
url: http://github.com/RockefellerArchiveCenter/asterism
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asterism-1.1.0-1.src.rpm
checksum_type: sha256
description:
  Helpers and common patterns used in Project Electron infrastructure. This package is named after a pattern or group of stars that is visually obvious, but not officially recognized as a constellation. Read more about asterisms on [Wikipedia](https://en.wikipedia.org/wiki/Asterism_(astronomy)).

  [![Build Status](https://app.travis-ci.com/RockefellerArchiveCenter/asterism.svg?branch=base)](https://app.travis-ci.com/RockefellerArchiveCenter/asterism)



  Make sure this library is installed:

      $ pip install asterism




  You can then use `asterism` in your Python scripts and applications by importing it:

      import asterism



  `bagit_helpers` - contains generic bagit functions to validate and update bags.
  `file_helpers` - generic functions for manipulating files and directories, as well as working with ZIP and TAR files.
  `models` - a `BasePackage` abstract base model that represents a bag of archival records.
  `views` - a `BaseServiceView` and a `RoutineView` which provide abstract wrapping methods for handling JSON requests and responses.



  This repository contains a configuration file for git [pre-commit](https://pre-commit.com/) hooks which help ensure that code is linted before it is checked into version control. It is strongly recommended that you install these hooks locally by installing pre-commit and running `pre-commit install`.




  This code is released under an [MIT License](LICENSE).


pkgId: 80dd0d3469e6bd2b0c7337b3a577825852fa828d074395ecbd2a0f9e02122c55
name: python-asteroid
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: PyTorch-based audio source separation toolkit
url: https://github.com/asteroid-team/asteroid
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asteroid-0.7.0-1.src.rpm
checksum_type: sha256
description:
  Asteroid is a Pytorch-based audio source separation toolkit
  that enables fast experimentation on common datasets.
  It comes with a source code that supports a large range
  of datasets and architectures, and a set of
   recipes to reproduce some important papers.

  Please, if you have found a bug, [open an issue][issue],
  if you solved it, [open a pull request][pr]!
  Same goes for new features, tell us what you want or help us building it!
  Don't hesitate to [join the slack][slack-invite]
  and ask questions / suggest new features there as well!
  Asteroid is intended to be a __community-based project__
  so hop on and help us!

  - [Contents](#contents)
  - [Installation](#installation)
  - [Tutorials](#tutorials)
  - [Running a recipe](#running-a-recipe)
  - [Available recipes](#available-recipes)
  - [Supported datasets](#supported-datasets)
  - [Pretrained models](#pretrained-models)
  - [Contributing](#contributing)
  - [TensorBoard visualization](#tensorboard-visualization)
  - [Guiding principles](#guiding-principles)
  - [Citing Asteroid](#citing-asteroid)

  ([↑up to contents](#contents))
  To install Asteroid, clone the repo and install it using
  conda, pip or python :
  ```bash

  git clone https://github.com/asteroid-team/asteroid
  cd asteroid
  ```
  - With `pip`
  ```bash

  pip install -e .


  ```
  - With conda (if you don't already have conda, see [here][miniconda].)
  ```bash
  conda env create -f environment.yml
  conda activate asteroid
  ```
  - Asteroid is also on PyPI, you can install the latest release with
  ```bash
  pip install asteroid
  ```

  ([↑up to contents](#contents))
  Here is a list of notebooks showing example usage of Asteroid's features.
  - [Getting started with Asteroid](./notebooks/00_GettingStarted.ipynb)
  - [Introduction and Overview](./notebooks/01_APIOverview.ipynb)
  - [Filterbank API](./notebooks/02_Filterbank.ipynb)
  - [Permutation invariant training wrapper `PITLossWrapper`](./notebooks/03_PITLossWrapper.ipynb)
  - [Process large wav files](./notebooks/04_ProcessLargeAudioFiles.ipynb)

  ([↑up to contents](#contents))
  Running the recipes requires additional packages in most cases,
  we recommend running :
  ```bash

  pip install -r requirements.txt
  ```
  Then choose the recipe you want to run and run it!
  ```bash
  cd egs/wham/ConvTasNet
  . ./run.sh
  ```
  More information in [egs/README.md](./egs).

  ([↑up to contents](#contents))
  * [x] [ConvTasnet](./egs/wham/ConvTasNet) ([Luo et al.](https://arxiv.org/abs/1809.07454))
  * [x] [Tasnet](./egs/whamr/TasNet) ([Luo et al.](https://arxiv.org/abs/1711.00541))
  * [x] [Deep clustering](./egs/wsj0-mix/DeepClustering) ([Hershey et al.](https://arxiv.org/abs/1508.04306) and [Isik et al.](https://arxiv.org/abs/1607.02173))
  * [x] [Chimera ++](./egs/wsj0-mix/DeepClustering) ([Luo et al.](https://arxiv.org/abs/1611.06265) and [Wang et al.](https://ieeexplore.ieee.org/document/8462507))
  * [x] [DualPathRNN](./egs/wham/DPRNN) ([Luo et al.](https://arxiv.org/abs/1910.06379))
  * [x] [Two step learning](./egs/wham/TwoStep)([Tzinis et al.](https://arxiv.org/abs/1910.09804))
  * [x] [SudoRMRFNet](./asteroid/models/sudormrf.py) ([Tzinis et al.](https://arxiv.org/abs/2007.06833))
  * [x] [DPTNet](./asteroid/models/dptnet.py) ([Chen et al.](https://arxiv.org/abs/2007.13975))
  * [x] [DCCRNet](./asteroid/models/dccrnet.py) ([Hu et al.](https://arxiv.org/abs/2008.00264))
  * [x] [DCUNet](./asteroid/models/dcunet.py) ([Choi et al.](https://arxiv.org/abs/1903.03107))
  * [x] [CrossNet-Open-Unmix](./asteroid/models/x_umx.py) ([Sawata et al.](https://arxiv.org/abs/2010.04228))
  * [x] [Multi-Decoder DPRNN](./egs/wsj0-mix-var/Multi-Decoder-DPRNN) ([Zhu et al.](http://www.isle.illinois.edu/speech_web_lg/pubs/2021/zhu2021multi.pdf))
  * [ ] Open-Unmix (coming) ([Stöter et al.](https://sigsep.github.io/open-unmix/))
  * [ ] Wavesplit (coming) ([Zeghidour et al.](https://arxiv.org/abs/2002.08933))

  ([↑up to contents](#contents))
  * [x] [WSJ0-2mix](./egs/wsj0-mix) / WSJ03mix ([Hershey et al.](https://arxiv.org/abs/1508.04306))
  * [x] [WHAM](./egs/wham) ([Wichern et al.](https://arxiv.org/abs/1907.01160))
  * [x] [WHAMR](./egs/whamr) ([Maciejewski et al.](https://arxiv.org/abs/1910.10279))
  * [x] [LibriMix](./egs/librimix) ([Cosentino et al.](https://arxiv.org/abs/2005.11262))
  * [x] [Microsoft DNS Challenge](./egs/dns_challenge) ([Chandan et al.](https://arxiv.org/abs/2001.08662))
  * [x] [SMS_WSJ](./egs/sms_wsj) ([Drude et al.](https://arxiv.org/abs/1910.13934))
  * [x] [MUSDB18](./asteroid/data/musdb18_dataset.py) ([Raffi et al.](https://hal.inria.fr/hal-02190845))
  * [x] [FUSS](./asteroid/data/fuss_dataset.py) ([Wisdom et al.](https://zenodo.org/record/3694384#.XmUAM-lw3g4))
  * [x] [AVSpeech](./asteroid/data/avspeech_dataset.py) ([Ephrat et al.](https://arxiv.org/abs/1804.03619))
  * [x] [Kinect-WSJ](./asteroid/data/kinect_wsj.py) ([Sivasankaran et al.](https://github.com/sunits/Reverberated_WSJ_2MIX))

  ([↑up to contents](#contents))
  See [here](./docs/source/readmes/pretrained_models.md)

  ([↑up to contents](#contents))
  We are always looking to expand our coverage of the source separation
  and speech enhancement research, the following is a list of
  things we're missing.
  You want to contribute? This is a great place to start!
  * Wavesplit ([Zeghidour and Grangier](https://arxiv.org/abs/2002.08933))
  * FurcaNeXt ([Shi et al.](https://arxiv.org/abs/1902.04891))
  * DeepCASA ([Liu and Want](https://arxiv.org/abs/1904.11148))
  * VCTK Test sets from [Kadioglu et al.](https://arxiv.org/pdf/2002.08688.pdf)
  * Interrupted and cascaded PIT ([Yang et al.](https://arxiv.org/abs/1910.12706))
  * ~Consistency contraints ([Wisdom et al.](https://ieeexplore.ieee.org/abstract/document/8682783))~
  * ~Backpropagable STOI and PESQ.~
  * Parametrized filterbanks from [Tukuljac et al.](https://openreview.net/forum?id=HyewT1BKvr)
  * ~End-to-End MISI ([Wang et al.](https://arxiv.org/abs/1804.10204))~
  Don't forget to read our [contributing guidelines](./CONTRIBUTING.md).
  You can also open an issue or make a PR to add something we missed in this list.

  The default logger is TensorBoard in all the recipes. From the recipe folder,
  you can run the following to visualize the logs of all your runs. You can
  also compare different systems on the same dataset by running a similar command
  from the dataset directiories.
  ```bash

  tensorboard --logdir exp/ --port tf_port
  ```
  If your launching tensorboard remotely, you should open an ssh tunnel
  ```bash

  ssh -L local_port:localhost:tf_port user@ip
  ```
  Then open `http://localhost:local_port/`. If both ports are the same, you can
  click on the tensorboard URL given on the remote, it's just more practical.

  ([↑up to contents](#contents))
  * __Modularity.__ Building blocks are thought and designed to be seamlessly
  plugged together. Filterbanks, encoders, maskers, decoders and losses are
  all common building blocks that can be combined in a
  flexible way to create new systems.
  * __Extensibility.__ Extending Asteroid with new features is simple.
  Add a new filterbank, separator architecture, dataset or even recipe very
  easily.
  * __Reproducibility.__ Recipes provide an easy way to reproduce
  results with data preparation, system design, training and evaluation in a
  single script. This is an essential tool for the community!

  ([↑up to contents](#contents))
  If you loved using Asteroid and you want to cite us, use this :
  ```BibTex
  @inproceedings{Pariente2020Asteroid,
      title={Asteroid: the {PyTorch}-based audio source separation toolkit for researchers},
      author={Manuel Pariente and Samuele Cornell and Joris Cosentino and Sunit Sivasankaran and
              Efthymios Tzinis and Jens Heitkaemper and Michel Olvera and Fabian-Robert Stöter and
              Mathieu Hu and Juan M. Martín-Doñas and David Ditter and Ariel Frank and Antoine Deleforge
              and Emmanuel Vincent},
      year={2020},
      booktitle={Proc. Interspeech},
  }
  ```
  [comment]: <> (Badge)
  [miniconda]: https://conda.io/miniconda.html
  [codecov-badge]: https://codecov.io/gh/asteroid-team/asteroid/branch/master/graph/badge.svg
  [codecov]: https://codecov.io/gh/asteroid-team/asteroid
  [slack-badge]: https://img.shields.io/badge/slack-chat-green.svg?logo=slack
  [slack-invite]: https://join.slack.com/t/asteroid-dev/shared_invite/zt-cn9y85t3-QNHXKD1Et7qoyzu1Ji5bcA
  [comment]: <> (Others)
  [issue]: https://github.com/asteroid-team/asteroid/issues/new
  [pr]: https://github.com/asteroid-team/asteroid/compare


pkgId: cc7536bc865d3a1d411b5dbb5d9c1b0c08eb9b7c2710c62b76319fdf3965aa88
name: python-asteroid-filterbanks
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Asteroid's filterbanks
url: https://github.com/asteroid-team/asteroid-filterbanks
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asteroid-filterbanks-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Latest release using pip:
  ```bash
  pip install asteroid-filterbanks
  ```
  Dev install
  ```bash
  git clone https://github.com/asteroid-team/asteroid-filterbanks
  cd asteroid-filterbanks
  pip install -e .["all"]
  ```

  ```BibTex
  @inproceedings{Pariente2020Asteroid,
      title={Asteroid: the {PyTorch}-based audio source separation toolkit for researchers},
      author={Manuel Pariente and Samuele Cornell and Joris Cosentino and Sunit Sivasankaran and
              Efthymios Tzinis and Jens Heitkaemper and Michel Olvera and Fabian-Robert Stöter and
              Mathieu Hu and Juan M. Martín-Doñas and David Ditter and Ariel Frank and Antoine Deleforge
              and Emmanuel Vincent},
      year={2020},
      booktitle={Proc. Interspeech},
  }
  ```
  [comment]: <> (Badge)
  [codecov-badge]: https://codecov.io/gh/mpariente/asteroid-filterbanks/branch/master/graph/badge.svg
  [codecov]: https://codecov.io/gh/asteroid-team/asteroid-filterbanks
  [slack-badge]: https://img.shields.io/badge/slack-chat-green.svg?logo=slack
  [slack-invite]: https://join.slack.com/t/asteroid-dev/shared_invite/zt-cn9y85t3-QNHXKD1Et7qoyzu1Ji5bcA


pkgId: 2bbf3b6df0a0e5f27865170d7bfe11f2648def587843b8b96f8880878ad84aeb
name: python-asteroid-sdk
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Asteroid's Python SDK enables efficient control of thousands of agents.
url: https://asteroid.sh/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asteroid-sdk-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Sentinel is an agent control plane developed by Asteroid that allows you to efficiently control thousands of agents running in parallel.


  - Efficient control of parallel-running agents
  - Various types of supervisors including human, bash, python or LLM-powered supervisors
  - Integration with OpenAI, Anthropic
  - Integraiton with AISI's Inspect platform
  - Standalone usage capability



  For more detailed information, documentation, and usage examples, please visit the main GitHub repository:

  [https://github.com/asteroidai/sentinel](https://github.com/asteroidai/sentinel)


pkgId: 62fb1d175592195166d4cc1c496d863b7bf17a7fe3b32cecfa1aeff19bda213d
name: python-astetik
arch: src
version: 1.16
epoch: 0
release: 1
summary: Astetik data visualization and reporting library
url: http://mikkokotila.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astetik-1.16-1.src.rpm
checksum_type: sha256
description:
  <img width=250 src='https://raw.githubusercontent.com/autonomio/astetik/master/logo.png'>

      pip install astetik      # TL;DR



  Astetik takes the amazing potential of matplotlib and seaborn, and makes it available through single-line commands. While much of the lower level complexity is made invisible, some completely new features are added. Whatever is added is further taking away from the complexity of the visualizastion workflow.

  You might ask, why not use one of...

  - matplotlib
  - plotly
  - bokeh
  - mpl3d
  - seaborn

  ...and so forth. The short answer is simplicity. Simplicity that focus equally on the user experience of the data scientist, and the experience of the audience. While the data scientist should not have to think about it, the audience should be vowed by it. Without compromising the capabilities that are essential for visual storytelling.

  In *Five Essential Points of Data Visualization* I explain some of the frustrations, and ideas, conceived over more than 20 years working with data visualization and data-driven storytelling, that led to Astetik. You can [read it here](https://medium.com/@mikkokotila/five-essential-points-on-data-visualization-2856b80730b3).





  Every plot has three kinds of parameters; data inputs, plot specific, and common. The common are identical, and presented in the identical order in every plot. This means that once you learn one plot, you've more or less learn the all. The only exception is the plot specific parameters, which have been kept to absolute minimum, in many cases as few as 2 or 3.



  Partially owing to the well unified parameter space between the plots, the docstrings are very clear, and easy to digest. The input related are given first, following the plot specifics, and last the common parameters, in which case the dosctring is identical in every plot. At the top of each docstring several key points are made clear:

  - range of dimensions the plot supports
  - type of features (e.g. categorical and continous) work the best
  - recommended max number of features/columns



  As someone else so eloquently put it, the merit, and also the curse, of Matplotlib is how everything is made possible for the user. It is with this vast flexibility, that also comes great confusion. Still the only purpose a plotting library serves, is in its ability to bring the data scientist closer to the end goal; being able to tell visually compelling stories with data. We want to tell those stories without having to think about the plots too much, as a plot is just a means to an end. If you want to quench your thirst, you don't want to spend too much time producing water, but drink it, and move on. Data visualization in the pydata ecosystem should be like this. Amazing looking, publication quality visualizations should be available through single-line, easy-to-understand, and easy-to-remember commands. One command per plot. No more, no less.

  That's the problem astetik solves.



  It started from the realization that there was not a single library for Python, able to produce publication quality descriptive stats tables. The first version just did one thing, and it looked like this:

  [![pretty table](https://s14.postimg.org/hnoexoujl/Screen_Shot_2016_11_04_at_18_37_44.png)](https://postimg.org/image/70uls9me5/)

  At the time I was doing a lot of analysis that involved correlation, and ended up doing a simple heatmap plot which took about 20 lines of codes to polish it, and several hours of work having no previous knowledge of matplotlib or seaborn. The first plot looked like this:

  <img width=600 src=https://raw.githubusercontent.com/autonomio/astetik/master/examples/images/heat_titanic.png>

  The code to run it was (and still is):

      ast.corr(titanic, title='TITANIC SURVIVAL DATA', sub_title="Economics of Making it Alive")

  Today Astetik include, in addition to the original descriptive table and the heatmap correlation, over 20 unique plots and many unique features to make the daily life of data scientists and visual storytellers more enjoyable. The focus remains on simplicity in both use and aesthetic:

  <img width=600 src=https://raw.githubusercontent.com/autonomio/astetik/master/examples/images/foon_line.png>

  The code to produce the above line graph:

      ast.line(data=global_totals,
               x=['population','food'],
               y='year',
               palette='colorblind',
               legend=True,
               title='Global Food Trends',
               sub_title='Production on its own trajectory since 1992')



  One of the key problems related with plotting library use is uncertainty related with settings and data format. With astetik you give away much of the low-level tinkering ability, and get amazing looking plots in return. The plots look just as good regardless of the dataset, length of titles, and other factors that typically make it hard to standardize look and feel across all of your plots. In terms of uncertainty, every single plot comes with a standard call for displaying an example dataframe, and an example output using the example data. The example data is always from the same dataset. For example:



      ast.corr()



      ast.corr.in()



      ast.corr.out()

  This way you never have to think twice if your data is suitable for a given plot.



  - Over 20 plot types

  - Descriptive table

  - Wordcloud








     pip install astetik



     import astetik as ast

  That's it, you're ready to go.



  FEATURES:
  - add limiter to all relevant plots
  - add scaler to all relevant plots
  - add outlier removal to all plots

  USABILITY:
  - add sample data to all plots
  - add sample plot resulting from the data
  - unify docstrings
  - unify parameters

  OTHER:
  - unify the color pickers
  - add saving figure to all



  - Not all plots can handle x and y limits in the same way (just few are exceptions)
  - Scaling is not applicable to all plots


pkgId: 0d237c2f25cf85493aedb00821f363054ec8d2c93796b3411628c00d4926550f
name: python-asteval
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Safe, minimalistic evaluator of python expression using ast module
url: https://github.com/lmfit/asteval
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asteval-1.0.3-1.src.rpm
checksum_type: sha256
rpm_license:
  The MIT License  Copyright (c) 2024 Matthew Newville, The University of Chicago  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: 3738c964fa3d91996b7a62faef1a7b9d8c41ad4389ab5baa9e0991a220695f9b
name: python-astmain
arch: src
version: 0.0.155
epoch: 0
release: 1
summary: 描述:我的工具包💗2024/07/01💗10_52_53#💗 pip install astmain==0.0.155
url: https://pypi.org/project/astmain/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astmain-0.0.155-1.src.rpm
checksum_type: sha256
description:
      pip uninstall astmain  -y
      pip install     astmain



      pip install requests
      pip install pyppeteer
      pip install pyppeteer_stealth

      pip install arrow

      pip install nuitka
      pip install pytoml
      pip install toml
      pip install flit


pkgId: 4e404d023f8c9dc5962bd12c2744c200120512db9ed4763cd3443e057fcd1701
name: python-asto
arch: src
version: 0.0.34
epoch: 0
release: 1
summary: asto
url: https://github.com/dsm-72/asto
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asto-0.0.34-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 asto --file env.yml
  ```



  ``` sh
  pip install -e .


  pip install asto
  ```



  ``` sh

  $ conda activate asto


  $ 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/asto):

  ``` sh
  $ pip install git+https://github.com/dsm-72/asto.git
  ```

  or from [conda](https://anaconda.org/dsm-72/asto)

  ``` sh
  $ conda install -c dsm-72 asto
  ```

  or from [pypi](https://pypi.org/project/asto/)

  ``` sh
  $ pip install asto
  ```



  Documentation can be found hosted on GitHub
  [repository](https://github.com/dsm-72/asto)
  [pages](https://dsm-72.github.io/asto/). Additionally you can find
  package manager specific guidelines on
  [conda](https://anaconda.org/dsm-72/asto) and
  [pypi](https://pypi.org/project/asto/) respectively.


pkgId: c5145e54d8ad556876155a8ca0d3496fe88868918a65d50b3fd99c0742149eca
name: python-astpretty
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Pretty print the output of python stdlib `ast.parse`.
url: https://github.com/asottile/astpretty
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astpretty-3.0.0-1.src.rpm
checksum_type: sha256
description:
  Pretty print the output of python stdlib `ast.parse`.
  astpretty is intended to be a replacement for `ast.dump`.

  `pip install astpretty`

  `astpretty` provides two api functions:

  Print a representation of the ast node.
  ```python
  >>> astpretty.pprint(ast.parse('if x == y: y += 4').body[0])
  If(
      lineno=1,
      col_offset=0,
      test=Compare(
          lineno=1,
          col_offset=3,
          left=Name(lineno=1, col_offset=3, id='x', ctx=Load()),
          ops=[Eq()],
          comparators=[Name(lineno=1, col_offset=8, id='y', ctx=Load())],
      ),
      body=[
          AugAssign(
              lineno=1,
              col_offset=11,
              target=Name(lineno=1, col_offset=11, id='y', ctx=Store()),
              op=Add(),
              value=Num(lineno=1, col_offset=16, n=4),
          ),
      ],
      orelse=[],
  )
  ```
  `indent` allows control over the indentation string:
  ```python
  >>> astpretty.pprint(ast.parse('if x == y: y += 4').body[0], indent='  ')
  If(
    lineno=1,
    col_offset=0,
    test=Compare(
      lineno=1,
      col_offset=3,
      left=Name(lineno=1, col_offset=3, id='x', ctx=Load()),
      ops=[Eq()],
      comparators=[Name(lineno=1, col_offset=8, id='y', ctx=Load())],
    ),
    body=[
      AugAssign(
        lineno=1,
        col_offset=11,
        target=Name(lineno=1, col_offset=11, id='y', ctx=Store()),
        op=Add(),
        value=Num(lineno=1, col_offset=16, n=4),
      ),
    ],
    orelse=[],
  )
  ```
  `show_offsets` controls whether the output includes line / column information:
  ```python
  >>> astpretty.pprint(ast.parse('x += 5').body[0], show_offsets=False)
  AugAssign(
      target=Name(id='x', ctx=Store()),
      op=Add(),
      value=Num(n=5),
  )
  ```

  Return a string representation of the ast node.
  Arguments are identical to `astpretty.pprint`.
  ```python
  >>> astpretty.pformat(ast.parse('if x == y: y += 4').body[0])
  "If(\n    lineno=1,\n    col_offset=0,\n    test=Compare(\n        lineno=1,\n        col_offset=3,\n        left=Name(lineno=1, col_offset=3, id='x', ctx=Load()),\n        ops=[Eq()],\n        comparators=[Name(lineno=1, col_offset=8, id='y', ctx=Load())],\n    ),\n    body=[\n        AugAssign(\n            lineno=1,\n            col_offset=11,\n            target=Name(lineno=1, col_offset=11, id='y', ctx=Store()),\n            op=Add(),\n            value=Num(lineno=1, col_offset=16, n=4),\n        ),\n    ],\n    orelse=[],\n)"
  ```

  ```python
  >>> print(ast.dump(ast.parse('if x == y: y += 4').body[0]))
  If(test=Compare(left=Name(id='x', ctx=Load()), ops=[Eq()], comparators=[Name(id='y', ctx=Load())]), body=[AugAssign(target=Name(id='y', ctx=Store()), op=Add(), value=Num(n=4))], orelse=[])
  ```

  `astpretty` works with [typed-ast](https://github.com/python/typed_ast)!
  For usage with `typed-ast` make sure you have `typed-ast` installed, a
  convenient way to do this is with the `typed` extra to `astpretty`:
  ```bash
  pip install astpretty[typed]
  ```
  The apis above work equally well with the return values from the `ast` modules
  provided by `typed_ast`:
  ```pycon
  >>> import astpretty
  >>> from typed_ast import ast3
  >>> astpretty.pprint(ast3.parse('x = 4  # type: int'))
  Module(
      body=[
          Assign(
              lineno=1,
              col_offset=0,
              targets=[Name(lineno=1, col_offset=0, id='x', ctx=Store())],
              value=Num(lineno=1, col_offset=4, n=4),
              type_comment='int',
          ),
      ],
      type_ignores=[],
  )
  ```
  With `typed-ast` installed, the commandline interface adds `--typed-27` and
  `--typed-3` options for using the alternative ast parsers:
  ```console
  $ astpretty --typed-3 t.py
  Module(
      body=[
          Assign(
              lineno=1,
              col_offset=0,
              targets=[Name(lineno=1, col_offset=0, id='x', ctx=Store())],
              value=Num(lineno=1, col_offset=4, n=4),
              type_comment='int',
          ),
      ],
      type_ignores=[],
  )
  ```


pkgId: ab72c9a19af314734c212fab8d3ca58242a030ab2a0eaffbe5b16221b3e35b08
name: python-astr
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: astr (attribute string) for defined getter / setter methods
url: https://github.com/dsm-72/astr
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astr-0.0.11-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 astr --file env.yml
  ```



  ``` sh
  pip install -e .


  pip install astr
  ```



  ``` sh

  $ conda activate astr


  $ 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/astr):

  ``` sh
  $ pip install git+https://github.com/dsm-72/astr.git
  ```

  or from [conda](https://anaconda.org/dsm-72/astr)

  ``` sh
  $ conda install -c dsm-72 astr
  ```

  or from [pypi](https://pypi.org/project/astr/)

  ``` sh
  $ pip install astr
  ```



  Documentation can be found hosted on GitHub
  [repository](https://github.com/dsm-72/astr)
  [pages](https://dsm-72.github.io/astr/). Additionally you can find
  package manager specific guidelines on
  [conda](https://anaconda.org/dsm-72/astr) and
  [pypi](https://pypi.org/project/astr/) respectively.


pkgId: 072c6cfba6f33c8ca57d3499fdfa8c646d5af2407d7076b2fa3de3a9ac99067f
name: python-astra-assistants
arch: src
version: 2.2.2
epoch: 0
release: 1
summary: Astra Assistants API - drop in replacement for OpenAI Assistants, powered by AstraDB
url: https://pypi.org/project/astra-assistants/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astra-assistants-2.2.2-1.src.rpm
checksum_type: sha256
description:
  Astra Assistants is a drop in replacement for OpenAI's assistant API that supports the full Assistants v2 API (including streaming and vector_stores). This python library wraps the OpenAI SDK with additional capabilities and provides syntactic sugar for passing credentials for third party LLMs.



  Install astra_assistants using your python package manager of choice:

  ```
  poetry add astra_assistants
  ```


  import and patch your client:

  ```
  from openai import OpenAI
  from astra_assistants import patch

  client = patch(OpenAI())
  ```



  The astra-assistants server code is now open source (Apache2)!

  Check it out here https://github.com/datastax/astra-assistants-api



  Provide api keys for third party LLMs via environment variables. We support LLM completions through [litellm](https://github.com/BerriAI/litellm) and support litellm environmental variables and models.

  Rename the [.env.bkp](./.env.bkp) to `.env` and fill in the appropriate values for the LLMs you want to use.

  ```



  export ASTRA_DB_APPLICATION_TOKEN=""


  export OPENAI_API_KEY=""


  export GROQ_API_KEY=""


  export ANTHROPIC_API_KEY=""


  export GEMINI_API_KEY=""


  export PERPLEXITYAI_API_KEY=""


  export COHERE_API_KEY=""


  export AWS_REGION_NAME=""
  export AWS_ACCESS_KEY_ID=""
  export AWS_SECRET_ACCESS_KEY=""


  export GOOGLE_JSON_PATH=""
  export GOOGLE_PROJECT_ID=""


  export AI21_API_KEY=""


  export ALEPHALPHA_API_KEY=""


  export ANYSCALE_API_KEY=""


  export AZURE_API_KEY=""
  export AZURE_API_BASE=""
  export AZURE_API_VERSION=""
  export AZURE_AD_TOKEN=""
  export AZURE_API_TYPE=""


  export BASETEN_API_KEY=""


  export CLOUDFLARE_API_KEY=""
  export CLOUDFLARE_ACCOUNT_ID=""


  export DEEPINFRA_API_KEY=""


  export DEEPSEEK_API_KEY=""


  export FIREWORKS_AI_API_KEY=""


  export HUGGINGFACE_API_KEY=""
  export HUGGINGFACE_API_BASE=""


  export MISTRAL_API_KEY=""


  export NLP_CLOUD_API_KEY=""


  export OPENAI_API_KEY=""
  export OPENAI_ORGANIZATION=""
  export OPENAI_API_BASE=""


  export OPENROUTER_API_KEY=""
  export OR_SITE_URL=""
  export OR_APP_NAME=""


  export PALM_API_KEY=""


  export REPLICATE_API_KEY=""


  export TOGETHERAI_API_KEY=""


  export VERTEXAI_PROJECT=""
  export VERTEXAI_LOCATION=""
  export GOOGLE_APPLICATION_CREDENTIALS=""


  export VOYAGE_API_KEY=""


  export WATSONX_URL=""
  export WATSONX_APIKEY=""
  export WATSONX_TOKEN=""
  export WATSONX_PROJECT_ID=""
  export WATSONX_DEPLOYMENT_SPACE_ID=""


  export XINFERENCE_API_BASE=""
  export XINFERENCE_API_KEY=""
  ```


pkgId: 3b2de3781749211086211f6c882678ce98c51e6a6547a762a9985da647179d45
name: python-astra-bot
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Discord bot capable of storing 'quotes' by users and simple construction of humorous sentences.
url: https://github.com/anoaky/AstraSE
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astra-bot-1.3.4-1.src.rpm
checksum_type: sha256
description:
  ![Release](https://github.com/anoaky/AstraSE/actions/workflows/publish-stable.yml/badge.svg) ![PyPI](https://github.com/anoaky/AstraSE/actions/workflows/publish-pypi.yml/badge.svg)

  Readme in progress.


pkgId: 9c0c9f7ef7aeb33f833dcb1449286b291dcc0efa972c8dac2675a9173b3953ff
name: python-astra-haystack
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://pypi.org/project/astra-haystack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astra-haystack-0.10.0-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/deepset-ai/document-store/actions/workflows/test.yml/badge.svg)](https://github.com/deepset-ai/document-store/actions/workflows/test.yml)





  ```bash
  pip install astra-haystack
  ```



  install astra-haystack package locally to run integration tests:

  Open in gitpod:
  [![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/Anant/astra-haystack/tree/main)

  Switch Python version to 3.9 (Requires 3.9+ but not 3.12)

  ```bash
  pyenv install 3.9
  pyenv local 3.9
  ```

  Local install for the package
  `pip install -e .`
  To execute integration tests, add needed environment variables
  `ASTRA_DB_API_ENDPOINT="https://<id>-<region>.apps.astra.datastax.com"`,
  `ASTRA_DB_APPLICATION_TOKEN="AstraCS:..."`
  and execute
  `python examples/example.py`

  Install requirements
  `pip install -r requirements.txt`

  Export environment variables

  ```bash
  export ASTRA_DB_API_ENDPOINT="https://<id>-<region>.apps.astra.datastax.com"
  export ASTRA_DB_APPLICATION_TOKEN="AstraCS:..."
  export COLLECTION_NAME="my_collection"
  export OPENAI_API_KEY="sk-..."
  ```

  run the python examples
  `python example/example.py`
  or
  `python example/pipeline_example.py`



  This package includes Astra Document Store and Astra Embedding Retriever classes that integrate with Haystack, allowing you to easily perform document retrieval or RAG with Astra, and include those functions in Haystack pipelines.



  Import the Document Store:

  ```python
  from haystack_integrations.document_stores.astra import AstraDocumentStore
  from haystack.document_stores.types.policy import DuplicatePolicy
  ```

  Load in environment variables:

  ```python
  namespace = os.environ.get("ASTRA_DB_KEYSPACE")
  collection_name = os.environ.get("COLLECTION_NAME", "haystack_vector_search")
  ```

  Create the Document Store object (API Endpoint and Token are read off the environment):

  ```python
  document_store = AstraDocumentStore(
      collection_name=collection_name,
      namespace=namespace,
      duplicates_policy=DuplicatePolicy.SKIP,
      embedding_dimension=384,
  )
  ```

  Then you can use the document store functions like count_document below:
  `document_store.count_documents()`



  Create the Document Store object like above, then import and create the Pipeline:

  ```python
  from haystack import Pipeline
  pipeline = Pipeline()
  ```

  Add your AstraEmbeddingRetriever into the pipeline
  `pipeline.add_component(instance=AstraEmbeddingRetriever(document_store=document_store), name="retriever")`

  Add other components and connect them as desired. Then run your pipeline:
  `pipeline.run(...)`



  When creating an Astra DB document store, you may see a warning similar to the following:

  > Astra DB collection '...' is detected as having indexing turned on for all fields (either created manually or by older versions of this plugin). This implies stricter limitations on the amount of text each string in a document can store. Consider indexing anew on a fresh collection to be able to store longer texts.

  or,

  > Astra DB collection '...' is detected as having the following indexing policy: {...}. This does not match the requested indexing policy for this object: {...}. In particular, there may be stricter limitations on the amount of text each string in a document can store. Consider indexing anew on a fresh collection to be able to store longer texts.

  The reason for the warning is that the requested collection already exists on the database, and it is configured to [index all of its fields for search](https://docs.datastax.com/en/astra-db-serverless/api-reference/collections.html#the-indexing-option), possibly implicitly, by default. When the Haystack object tries to create it, it attempts to enforce, instead, an indexing policy tailored to the prospected usage: this is both to enable storing very long texts and to avoid indexing fields that will never be used in filtering a search (indexing those would also have a slight performance cost for writes).

  Typically there are two reasons why you may encounter the warning:

  1. you have created a collection by other means than letting this component do it for you: for example, through the Astra UI, or using AstraPy's `create_collection` method of class `Database` directly;
  2. you have created the collection with an older version of the plugin.

  Keep in mind that this is a warning and your application will continue running just fine, as long as you don't store very long texts.
  However, should you need to add to the document store, for example, a document with a very long textual content, you will get an indexing error from the database.



  You have several options:

  - you can ignore the warning because you know your application will never need to store very long textual contents;
  - if you can afford populating the collection anew, you can drop it and re-run the Haystack application: the collection will be created with the optimized indexing settings. **This is the recommended option, when possible**.


pkgId: 6a59001da5400ff38ce225eae27fd85907e1dcaee974eee92514b5d5abf916dd
name: python-astrago
arch: src
version: 0.0.9
epoch: 0
release: 1
url: https://github.com/xiilab/astrago
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrago-0.0.9-1.src.rpm
checksum_type: sha256
summary:
  The Astrago package helps track model training data, allowing you to efficiently collect and manage various metrics and log data generated during the training process.


pkgId: beb4b5d8ea6f60b86370ed6bac3d99ca22ae478735e231c880b2d72a824f16f5
name: python-astrape
arch: src
version: 0.8.13
epoch: 0
release: 1
summary: Astrape: A STrategic, Reproducible & Accesible Project and Experiment.
url: https://github.com/benchay1999/astrape
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrape-0.8.13-1.src.rpm
checksum_type: sha256
description:
  <div align="right">
        <b>Creator : Woosog Benjamin Chay</b>
  </div>
  <div align="right">
        <b>benchay1@gmail.com (preferred) / benchay@kaist.ac.kr</b>
  </div>
  <br/>
  <br/>

  <div align="center">
        <code><font size=4>pip install astrape</code>
  </div>

  <div align="center">
        <a href="https://astrape.readthedocs.io/en/latest/index.html">docs</a>
  </div>

  <div align="right">
        <a href="https://colab.research.google.com/drive/1w1zX8LAA6rl-u0LwdxvjQ1EDBMJiYrV4?usp=sharing">tutorial for 'Experiment'</a> <br/>
        <a href="https://colab.research.google.com/drive/1WNbVmZBP-gyhHYmg9FIS0QrXA2XRy8sN?usp=sharing">tutorial for 'Project'</a>
  </div>

  **********



  - [ASTRAPE : A STrategic, Reproducible & Accessible Project and Experiment](#astrape--a-strategic-reproducible--accessible-project-and-experiment)
  - [1. Overview](#1-overview)
  - [2. Project](#2-project)
    - [2-1. Visulaizing Data](#2-1-visulaizing-data)
    - [2-2. Creating *Experiment*s With Different Random Seeds](#2-2-creating-experiments-with-different-random-seeds)
    - [2-3. Set Models in Each Experiment](#2-3-set-models-in-each-experiment)
    - [2-4. Fit Models in Each Experiment](#2-4-fit-models-in-each-experiment)
    - [2-5. Save Fitted Models in Each Experiment](#2-5-save-fitted-models-in-each-experiment)
    - [2-6. Plot Results](#2-6-plot-results)
      - [2-6-1. Plot Performances With an Identical Model Type](#2-6-1-plot-performances-with-an-identical-model-type)
      - [2-6-2. Plot Performances With an Identical Model Structure](#2-6-2-plot-performances-with-an-identical-model-structure)
      - [2-6-3. Plot Performances of All Model Structures](#2-6-3-plot-performances-of-all-model-structures)
  - [3. Experiment](#3-experiment)
    - [3-1. Specifying Models](#3-1-specifying-models)
    - [3-2. (Optional) Specifying Trainers](#3-2-optional-specifying-trainers)
    - [3-3. Fitting the Model](#3-3-fitting-the-model)
    - [3-4. Stacking Fitted Models](#3-4-stacking-fitted-models)
    - [3-5. Saving Models](#3-5-saving-models)
    - [3-6. Checking the Best Model Thus Far](#3-6-checking-the-best-model-thus-far)
    - [3-7. (Stratified) K-Fold Cross-Validation](#3-7-stratified-k-fold-cross-validation)

  **********

  Astrape : [https://en.wikipedia.org/wiki/Astrape_and_Bronte](https://en.wikipedia.org/wiki/Astrape_and_Bronte)

  Astrape is a package that would help you organize machine learning projects. It is written mostly in PyTorch Lightning([https://pytorchlightning.ai](https://pytorchlightning.ai)).



  This project is motivated by the need to provide packages, of which only "human-language-level codings" are necessary, to whom that is not familiar with machine learning or with programming. Even though there are high-level machine learning frameworks such as PyTorch(and PyTorch-Lightning) or Tensorflow, it is difficult for beginners even to run a simple Perceptron due to the presence of magic commands e.g., codes regarding saving results, hyperparameter tuning, etc. Even if one has a strong background in learning theory, it would be a long journey to conduct an experiment when he/she hasn't acquired basic programming skills.

  Astrape eliminated most of the low-level codings of the entire machine learning process so that every process in machine learning experiment can be done by typing nearly-human-level languages.

  I am currently writing lecture notes/slides about machine learning with practice sessions using astrape. Most of the materials are originated from machine learning courses held in [SK Hynix](https://www.skhynix.com/)(May, 2021 ~ Oct, 2021 : 16 days) and [Hyundai NGV](http://www.hyundai-ngv.com/main/index.do) (Feb, 2022: 10 days), where I joined as a teaching assistant developing such lecture materials and practice sessions.

  ***Updates***
  - [ ] Add generative models in `astrape.models.models_lightning` (~ Aug, 2022)
  - [ ] Enable real-time tracking of training process for sci-kit learn models(~ Oct, 2022)
  - [ ] Add features regarding pre/post-processing of data(~ Oct, 2022)
  - [ ] Release publicly available machine learning lectures with practice sessions integrated w/ astrape(~ Dec, 2022)
  ************

  :zap: Astrape :zap:


  ![Outline of Astrape](https://github.com/benchay1999/astrape/blob/main/astrape_outline.jpg?raw=true)


  "Project" and "Experiment" conspire to the soul of astrape. The term "Project" here refers to "all set of possible machine learning *experiments* for analyzing the given data". Wait, what is an *experiment* anyway? An *experiment* here means "a process of train/validation/test phase with certain random state acquired for all random operations such as splitting scheme, initialization scheme, etc.". "Experiment" is a collection of *experiments* with the same random state.

  For stability's sake, you are tempted to (and should) conduct several "Experiments" with different random states to verify that your data analysis is indeed accurate. Astrape organizes such "Experiments" in a way that makes this sanity-checking process succinct and reproducible.





  **Project** is defined as a set of *experiments*, with different random seed allocated to each *experiment*. It performs the A to Z of the process of a machine learning experiment.

  *Project* can visualize the data according to its type of domain e.g., image data, points.

  Check details in the [project tutorial](https://colab.research.google.com/drive/1WNbVmZBP-gyhHYmg9FIS0QrXA2XRy8sN?usp=sharing).

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/project.JPG?raw=true)




  You can visualize data using `.plot_data()` method. Depending on the domain of the data, such as image data or simple points in Euclidean space, `.plot_data()` automatically visulizes and saves the visualized figure. If the data is image data, you should specify the argument `domain_type` as `"image"`. Else if the data is points in Euclidean space, you should specify the argument `domain_type` as `"points"`. When the dimensionality of the points data is higher than 3, `.plot_data()` plots a 2D figure with 2 principal axes.



  You can create *experiment*s with different random states using `.create_experiments()` method. Random seeds will be generated as per the `amount` of experiments you want to create.

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/create_experiments.JPG?raw=true)



  You can set identical models among the created *experiment*s using `.set_models()` method. You should pass the type (class) of the model and its hyperparameters.



  You can train the model sequentially using `fit_experiments()` method.
  Event file for the real-time tracking of the experiment via TensorBoard is saved in {path}/{project_name}/FIT.


  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/set_and_fit_new.JPG?raw=true)
  *Astrape uses Rich ProcessBar*


  You can save the fitted models using `.save_stacks()`, which is basically performing `.save_stack()` for the created *experiments*. Read [3-5. Saving Models](#3-5-saving-models) for details.

  You can also save the fitted models using `.save_project()` method.



  Astrape supports plotting results of the following:



  `.plot_identical_model_type()` method plots & saves a figure showing performance of a specified model type (e.g., MLP, UNet) generated in each experiment.

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/plot_identical_model_type.JPG?raw=true)
  *AUC among different random states*



  `.plot_identical_model_structure()` method plots & saves a figure showing performance of a specified model structure generated in each experiment.
  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/plot_identical_model_structure.JPG?raw=true)
  *AUC among different random states*



  `.plot_all_model_structures()` method plots & saves two figures showing performances of all model structrues created in the *project*. One is a line plot of performances among different random states and the second is a box plot of performances of all model structures.
  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/plot_all_model_structures.JPG?raw=true)
  *Upper image shows performances of all model structures and the lower image shows a boxplot of all model structures trained in the project*



  When using Astrape, we expect you to conduct all experiments inside the `experiment.Experiment` class. This class takes a number of parameters, and you can check the details in the [tutorial](https://colab.research.google.com/drive/1VZCR84K2pzKpZoFGy3kp8vOZYAYyvQjJ?usp=sharing).

  Once you declare an experiment, all random operations are governed by the same random seed you defined as a parameter for the experiment. When initialized (with a given random state) and the train/validation/test data are specified, you should now declare models for the task.



  Declare a model using `.set_model()` method. There are pre-defined models in `astrape.models.models_lightning` that are easy to use, but you can also set any `pl.LightningModule`s or descendants of `sklearn.base.BaseEstimator` as well.


  > You can also declare sci-kit learn models and their variants(e.g., xgboost) as well using `.set_model()`. Astrape is compatible with sci-kit learn and PyTorch-lightning modules.




  PyTorch Lightning uses `Trainer` for training, validating, and testing models. You can specify it using the `.set_trainer()` method with trainer configurations as parameters. If you don't, default values will be set for the `Trainer`. Check the [tutorial]([https://github.com/benchay1999/astrape/blob/main/tutorial/tutorial.ipynb](https://colab.research.google.com/drive/1VZCR84K2pzKpZoFGy3kp8vOZYAYyvQjJ?usp=sharing)) for details.



  You can fit the model using `.fit()` method. When you didn't specify a `Trainer` in previous step, default settings would be used in the fitting. Else, you can specify `Trainer` implicitly by passing the trainer configurations as parameters for `.fit()`.

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/fit_tutorial.JPG?raw=true)



  > Training and valiation process of a LightningModule-Based models are visualized in real-time using TensorBoard.



  `Experiment` class has `.stack` as an attribute. If `.stack_models` is set to `True`, fitted models will automatically be saved to `.stack`. If `.stack_models` is set to `False`, it would stop stacking fitted models to the stack. However, it would still save the model that is just fitted i.e., it will have memory of 1 fit. You can toggle `.stack_models` using `.toggle_stack_models()` method.

  Plus, you can check which model in the stack has the best performance using `.best_ckpt_in_stack()`.



  You can save the current model using `.save_ckpt()` method, or you can save the models in the stack using `.save_stack()` method. After `.save_stack()`, `.stack` will be flushed.

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/stack_example.JPG?raw=true)
  *An example of a `.stack`.*


  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/after_save_stack.JPG?raw=true)
  *`stack` is flushed after `.save_stack()`.*

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/file_tree.JPG?raw=true)
  *Example of a file tree*




  With `.best_ckpt_thus_far()` method, you can check the best model saved (in local) thus far. It searches for the checkpoint with the best performance as per the validation metric you specify in `val_metric` argument.

  When defining `pl.LightningModule`, you can make your model to log metrics during each step/epoch, like the way in the following figure.

  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/validation_step.JPG?raw=true)
  *you can log metrics using `.log()` method in `pl.LightningModule` class*

  The value that should be passed into `val_metric` in `.best_ckpt_thus_far()` is the name of the metric you logged using `.log()`.

  Models in `astrape.models.models_lightning` logs metrics in the following way:
  - training phase: `"train/loss"`, `"train/acc"`, `"train/auc"`
  - validation phase: `"val/loss"`, `"val/acc"`, `"val/auc"`
  - prediction phase: `"pred/loss"`, `"pred/acc"`, `"pred/auc"`
  - test phase: `"test/loss"`, `"test/acc"`, `"test/auc"`

  > In regression, only `"{phase}/loss"` is logged.

  > For sci-kit learn models and its variants, The metrics are logged after the entire training.


  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/best_ckpt_thus_far_tutorial.JPG?raw=true)



  You can perform (stratified) k-fold cross-validation using `.cross_validation()` method. See details in the [tutorial](https://colab.research.google.com/drive/1w1zX8LAA6rl-u0LwdxvjQ1EDBMJiYrV4?usp=sharing).

  One of the arguments that is passed to `cross_validation()` is `parameters`. `parameters` should be a dictionary containing the name of each hyperparameter to tune as keys and its configuration as values.

  The values corresponding to the hyperparameter is also a dictionary and should follow the below format:


  Suppose you want to tune the hyperparameters with the following scheme.


  |hyperparameter  | values  | distribution |
  |---------|---------|---------|
  |batch_size     |   in {32,64,128,256} | grid |
  |lr     |   in [1e-4,1e-2]      |  sampled from uniform distribution(in log scale)|

  For the batch size, the value corresponding to the key `"batch_size"` should be:

        >>> {"values": [32,64,128,256]}

  and for the learning rate, the value corresponding to the key `"lr"` should be:

        >>> {"distribution" : "log_scale_uniform", "min" : -4, "max" : -2}

  To sum up, this should be passed as a value of the argument `parameters`.

        >>> parameters = {
              "batch_size" : {
                    "values" : [32,64,128,256]
              },
              "lr" : {
                    "distribution" : "log_scale_uniform",
                    "min" : -4,
                    "max" : -2
              }
        }


  ![alt text](https://github.com/benchay1999/astrape/blob/main/tutorial/cv_example.JPG?raw=true)


pkgId: 365de74b1205d179dbeea509bcb5310ec3788822e59b78a1c8a59fbd16a679c1
name: python-astrapy
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: AstraPy is a Pythonic SDK for DataStax Astra and its Data API
url: https://github.com/datastax/astrapy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrapy-1.5.2-1.src.rpm
checksum_type: sha256
description:
  A pythonic client for [DataStax Astra DB](https://astra.datastax.com).

  _This README targets AstraPy version **1.0.0+**, which introduces a whole new API.
  Click [here](https://github.com/datastax/astrapy/blob/cd3f5ce8146093e10a095709c0f5c3f8e3f2c7da/README.md) for the pre-existing API (fully compatible with newer versions)._




  Install with `pip install astrapy`.

  Get the *API Endpoint* and the *Token* to your Astra DB instance at [astra.datastax.com](https://astra.datastax.com).

  Try the following code after replacing the connection parameters:

  ```python
  import astrapy

  ASTRA_DB_APPLICATION_TOKEN = "AstraCS:..."
  ASTRA_DB_API_ENDPOINT = "https://01234567-....apps.astra.datastax.com"

  my_client = astrapy.DataAPIClient()
  my_database = my_client.get_database(
      ASTRA_DB_API_ENDPOINT,
      token=ASTRA_DB_APPLICATION_TOKEN,
  )

  my_collection = my_database.create_collection(
      "dreams",
      dimension=3,
      metric=astrapy.constants.VectorMetric.COSINE,
  )

  my_collection.insert_one({"summary": "I was flying", "$vector": [-0.4, 0.7, 0]})

  my_collection.insert_many(
      [
          {
              "_id": astrapy.ids.UUID("018e65c9-e33d-749b-9386-e848739582f0"),
              "summary": "A dinner on the Moon",
              "$vector": [0.2, -0.3, -0.5],
          },
          {
              "summary": "Riding the waves",
              "tags": ["sport"],
              "$vector": [0, 0.2, 1],
          },
          {
              "summary": "Friendly aliens in town",
              "tags": ["scifi"],
              "$vector": [-0.3, 0, 0.8],
          },
          {
              "summary": "Meeting Beethoven at the dentist",
              "$vector": [0.2, 0.6, 0],
          },
      ],
  )

  my_collection.update_one(
      {"tags": "sport"},
      {"$set": {"summary": "Surfers' paradise"}},
  )

  cursor = my_collection.find(
      {},
      sort={"$vector": [0, 0.2, 0.4]},
      limit=2,
      include_similarity=True,
  )

  for result in cursor:
      print(f"{result['summary']}: {result['$similarity']}")




  ```

  Next steps:

  - More info and usage patterns are given in the docstrings of classes and methods
  - [Data API reference](https://docs.datastax.com/en/astra-db-serverless/api-reference/overview.html)
  - [AstraPy reference](https://docs.datastax.com/en/astra-api-docs/_attachments/python-client/astrapy/index.html)
  - Package on [PyPI](https://pypi.org/project/astrapy/)



  The main difference to target e.g. a Hyper-Converged Database (HCD)
  installation is how the client is
  initialized. Here is a short example showing just how to get to a `Database`
  (what comes next is unchaged compared to using Astra DB).

  ```python
  from astrapy import DataAPIClient
  from astrapy.constants import Environment
  from astrapy.authentication import UsernamePasswordTokenProvider



  tp = UsernamePasswordTokenProvider("username", "password")


  client = DataAPIClient(token=tp, environment=Environment.HCD)
  database = client.get_database("http://localhost:8181", token=tp)
  ```

  For more on this case, please consult the [dedicated reference](https://docs.datastax.com/en/hyper-converged-database/1.0/connect/python-client.html).





  AstraPy's abstractions for working at the data and admin layers are structured
  as depicted by this diagram:

  ![AstraPy, abstractions chart](https://raw.githubusercontent.com/datastax/astrapy/master/pictures/astrapy_abstractions.png)

  Here's a small admin-oriented example:

  ```python
  import astrapy



  ASTRA_DB_APPLICATION_TOKEN = "AstraCS:..."

  my_client = astrapy.DataAPIClient(ASTRA_DB_APPLICATION_TOKEN)

  my_astra_admin = my_client.get_admin()

  database_list = list(my_astra_admin.list_databases())

  db_info = database_list[0].info
  print(db_info.name, db_info.id, db_info.region)

  my_database_admin = my_astra_admin.get_database_admin(db_info.id)

  my_database_admin.list_keyspaces()
  my_database_admin.create_keyspace("my_dreamspace")
  ```



  The package comes with its own set of exceptions, arranged in this hierarchy:

  ![AstraPy, exception hierarchy](https://raw.githubusercontent.com/datastax/astrapy/master/pictures/astrapy_exceptions.png)

  For more information, and code examples, check out the docstrings and consult
  the API reference linked above.



  Date and datetime objects, i.e. instances of the standard library
  `datetime.datetime` and `datetime.date` classes, can be used anywhere in documents:

  ```python
  import datetime
  import astrapy


  ASTRA_DB_APPLICATION_TOKEN = "AstraCS:..."
  ASTRA_DB_API_ENDPOINT = "https://01234567-....apps.astra.datastax.com"

  my_client = astrapy.DataAPIClient()
  my_database = my_client.get_database(
      ASTRA_DB_API_ENDPOINT,
      token=ASTRA_DB_APPLICATION_TOKEN,
  )
  my_collection = my_database.dreams

  my_collection.insert_one({"when": datetime.datetime.now()})
  my_collection.insert_one({"date_of_birth": datetime.date(2000, 1, 1)})

  my_collection.update_one(
      {"registered_at": datetime.date(1999, 11, 14)},
      {"$set": {"message": "happy Sunday!"}},
  )

  print(
      my_collection.find_one(
          {"date_of_birth": {"$lt": datetime.date(2001, 1, 1)}},
          projection={"_id": False},
      )
  )


  ```

  _**Note**: reads from a collection will always_
  _return the `datetime` class regardless of wheter a `date` or a `datetime` was provided_
  _in the insertion._



  Astrapy repackages the ObjectId from `bson` and the UUID class and utilities
  from the `uuid` package and its `uuidv6` extension. You can also use them directly.

  Even when setting a default ID type for a collection, you still retain the freedom
  to use any ID type for any document:

  ```python
  import astrapy
  import bson

  ASTRA_DB_APPLICATION_TOKEN = "AstraCS:..."
  ASTRA_DB_API_ENDPOINT = "https://01234567-....apps.astra.datastax.com"

  my_client = astrapy.DataAPIClient()
  my_database = my_client.get_database(
      ASTRA_DB_API_ENDPOINT,
      token=ASTRA_DB_APPLICATION_TOKEN,
  )

  my_collection = my_database.create_collection(
      "ecommerce",
      default_id_type=astrapy.constants.DefaultIdType.UUIDV6,
  )

  my_collection.insert_one({"_id": astrapy.ids.ObjectId("65fd9b52d7fabba03349d013")})
  my_collection.find({
      "_id": astrapy.ids.UUID("018e65c9-e33d-749b-9386-e848739582f0"),
  })

  my_collection.update_one(
      {"tag": "in_stock"},
      {"$set": {"inventory_id": bson.objectid.ObjectId()}},
      upsert=True,
  )

  my_collection.insert_one({"_id": astrapy.ids.uuid8()})
  ```



  First install poetry with `pip install poetry` and then the project dependencies with `poetry install --with dev`.

  Linter, style and typecheck should all pass for a PR:

  ```bash
  make format
  ```

  With `make format-fix` the style and imports are autofixed (by `ruff`)

  Features must be thoroughly covered in tests (see `tests/idiomatic/*` for
  naming convention and module structure).



  Tests are grouped in three _blocks_ (in as many subdirs of `tests/`):

  - **idiomatic**: all 1.0+ classes and APIs, except...
  - **vectorize**: ... everything making use of `$vectorize` (within the idiomatic classes)
  - _(core: pre-1.0 classes). Frozen as of v1.5, deprecated for removal in v2.0_

  Actually, for convenience, _sub-blocks_ of tests are considered:

  - **idiomatic regular**: everything except the admin parts
  - **idiomatic admin Astra**: the Astra-specific admin operations
  - **idiomatic admin nonAstra**: the nonAstra-specific admin operations
  - **vectorize in-depth**: many Data API interactions for a single choice of provider/model. This is mostly test the client
  - **vectorize all-providers**: a slightly more shallow test repeated for all providers, models, auth methods etc. This is mostly testing the API
  - _(core regular: everything except DevOps interactions)_
  - _(core ops: core DevOps operations)_

  Tests can be run on three types of Data API _targets_ (with slight differences in what is applicable):

  - **DockerCompose**: HCD started by the test initialization with `docker-compose`. _Note that in this case you will have to manually destroy the created containers._
  - **nonAstra**: a ready-to-use (user-supplied) local Data API
  - **Astra**: an Astra DB target account (or two, as some tests are specific to dev environment)

  Depending on the (sub-block, target) combination, some environment variables may be needed.
  Templates for the environment variables are to be found in `tests/env_templates`.

  The general expectation is that idiomatic non-Admin tests, and vectorize in-depth tests, are
  part of the main CI flow; conversely, core, admin and vectorize all-providers are kept as a
  manual task to run (locally in most cases) when circumstances require it (use your judgement).



  Below is a detail of the reference template files needed for the various types
  of testing:

  - **DockerCompose**: generally no variables needed, except:
    - **vectorize in-depth**: provide as in `env.vectorize-minimal.template`
    - **vectorize all-providers**: provide as in `env.vectorize.template`
    - (also note that _core ops_ and _idiomatic admin Astra_ amount to nothing in this case)
  - **nonAstra**: all tests require as in `env.local.template`, plus:
    - **vectorize in-depth**: also provide as in `env.vectorize-minimal.template`
    - **vectorize all-providers**: also provide as in `env.vectorize.template`
    - (also note that _core ops_ and _idiomatic admin Astra_ amount to nothing in this case)
  - **Astra**: all tests require as in `env.astra.template`, plus:
    - **core ops**: the token must have at least "Database Administrator" role (possibly through definition of a separate `ASTRA_DB_OPS_APPLICATION_TOKEN`), and `ASTRA_DB_ID` must also be defined
    - **idiomatic admin Astra**: also provide as in `env.astra.admin.template`
    - **vectorize in-depth**: also provide as in `env.vectorize-minimal.template`
    - **vectorize all-providers**: also provide as in `env.vectorize.template`
    - (also note that _idiomatic admin nonAstra_ amounts to nothing in this case)



  For the **DockerCompose** case, prepend all of the following with `DOCKER_COMPOSE_LOCAL_DATA_API="yes" `.

  All the usual `pytest` ways of restricting the test selection hold in addition
  (e.g. `poetry run pytest tests/idiomatic/unit` or `[...] -k <test_name_selector>`).



  ```
  poetry run pytest tests/core
  ```



  Note the special variable needed to actually run this. You will have to manually clean up afterwards.

  ```
  TEST_ASTRADBOPS="1" poetry run pytest tests/core/test_ops.py
  ```



  Warning: this will also trigger the very long-running _idiomatic admin Astra_ if the vars as in `env.astra.admin.template` are also detected. Likewise, the _idiomatic admin nonAstra_ may start (if `DO_IDIOMATIC_ADMIN_TESTS` is set), which however takes few seconds.

  ```
  poetry run pytest tests/idiomatic
  ```



  ```
  poetry run pytest tests/idiomatic/integration/test_admin.py
  ```



  ```
  DO_IDIOMATIC_ADMIN_TESTS="1" poetry run pytest tests/idiomatic/integration/test_nonastra_admin.py
  ```



  ```
  poetry run pytest tests/vectorize_idiomatic/integration/test_vectorize_methods*.py
  ```

  or just:

  ```
  poetry run pytest tests/vectorize_idiomatic/integration/test_vectorize_methods_sync.py
  ```



  This generates all possible test cases and runs them:

  ```
  poetry run pytest tests/vectorize_idiomatic
  ```

  For a spot test, you may restrict to one case, e.g.

  ```
  EMBEDDING_MODEL_TAGS="openai/text-embedding-3-large/HEADER/0" poetry run pytest tests/vectorize_idiomatic/integration/test_vectorize_providers.py -k test_vectorize_usage_auth_type_header_sync
  ```



  Remove logging noise with:

  ```
  poetry run pytest [...] -o log_cli=0
  ```

  Increase logging level to `DEBUG` (i.e. level `10`):

  ```
  poetry run pytest [...] -o log_cli=1 --log-cli-level=10
  ```

  Do not drop collections (valid for core):

  ```
  TEST_SKIP_COLLECTION_DELETE=1 poetry run pytest [...]
  ```






  Client, data and admin abstractions:

  ```python
  from astrapy import (
      DataAPIClient,
      Database,
      AsyncDatabase,
      Collection,
      AsyncCollection,
      AstraDBAdmin,
      AstraDBDatabaseAdmin,
      DataAPIDatabaseAdmin,
  )
  ```

  Constants for data-related use:

  ```python
  from astrapy.constants import (
      ReturnDocument,
      SortDocuments,
      VectorMetric,
      DefaultIdType,
      Environment,
  )
  ```

  ObjectIds and UUIDs:

  ```python
  from astrapy.ids import (
      ObjectId,
      uuid1,
      uuid3,
      uuid4,
      uuid5,
      uuid6,
      uuid7,
      uuid8,
      UUID,
  )
  ```

  Operations (for `bulk_write` collection method):

  ```python
  from astrapy.operations import (
      BaseOperation,
      InsertOne,
      InsertMany,
      UpdateOne,
      UpdateMany,
      ReplaceOne,
      DeleteOne,
      DeleteMany,
      AsyncBaseOperation,
      AsyncInsertOne,
      AsyncInsertMany,
      AsyncUpdateOne,
      AsyncUpdateMany,
      AsyncReplaceOne,
      AsyncDeleteOne,
      AsyncDeleteMany,
  )
  ```

  Result classes:

  ```python
  from astrapy.results import (
      OperationResult,
      DeleteResult,
      InsertOneResult,
      InsertManyResult,
      UpdateResult,
      BulkWriteResult,
  )
  ```

  Exceptions:

  ```python
  from astrapy.exceptions import (
      BulkWriteException,
      CollectionAlreadyExistsException,
      CollectionNotFoundException,
      CumulativeOperationException,
      CursorIsStartedException,
      DataAPIDetailedErrorDescriptor,
      DataAPIErrorDescriptor,
      DataAPIException,
      DataAPIFaultyResponseException,
      DataAPIHttpException,
      DataAPIResponseException,
      DataAPITimeoutException,
      DeleteManyException,
      DevOpsAPIErrorDescriptor,
      DevOpsAPIException,
      DevOpsAPIFaultyResponseException,
      DevOpsAPIHttpException,
      DevOpsAPIResponseException,
      DevOpsAPITimeoutException,
      InsertManyException,
      TooManyDocumentsToCountException,
      UpdateManyException,
  )
  ```

  Info/metadata classes:

  ```python
  from astrapy.info import (
      AdminDatabaseInfo,
      DatabaseInfo,
      CollectionInfo,
      CollectionVectorServiceOptions,
      CollectionDefaultIDOptions,
      CollectionVectorOptions,
      CollectionOptions,
      CollectionDescriptor,
      EmbeddingProviderParameter,
      EmbeddingProviderModel,
      EmbeddingProviderToken,
      EmbeddingProviderAuthentication,
      EmbeddingProvider,
      FindEmbeddingProvidersResult,
  )
  ```

  Admin-related classes and constants:

  ```python
  from astrapy.admin import (
      ParsedAPIEndpoint,
  )
  ```

  Cursors:

  ```python
  from astrapy.cursors import (
      BaseCursor,
      Cursor,
      AsyncCursor,
      CommandCursor,
      AsyncCommandCursor,
  )
  ```



  If your code still uses the pre-1.0.0 astrapy (i.e. `from astrapy.db import AstraDB, AstraDBCollection` and so on)
  you are strongly advised to migrate to the current API, which has more capabilities and improved interfaces.

  All of the astrapy pre-1.0 API (now dubbed "core") works throughout *astrapy v1*, albeit with a deprecation warning
  on astrapy v. 1.5.

  Version 1.5 (the first to not wrap internally "core" as the engine of its own "idiomatic" API) introduces
  several deprecation notices (nothing is retired yet), including a submodule-wide deprecation of "core".

  **Version 2 of astrapy will finally remove "core" entirely (along with a few other things).**



  That being said, there are no known breakings of backward compatibility:
  **legacy code would run with astrapy v1 just as well**
  Here is a recap of the minor changes that came _to the old API_ with 1.0.0 (and beyond, up to 1.5):

  - added a submodule-wide deprecation warning of the whole "core" library (v 1.5)
  - added 'options' parameter to [Async]AstraDBCollection.update_one (v. 1.4.2+)
  - prefetched find iterators: fix second-thread hangups in some cases (v. 1.4.2+)
  - Added support for null tokens (with the effect of no authentication/token header in requests)
  - Added Content-Type header to all HTTP requests to the API
  - Added methods to `[Async]AstraDBCollection`: `delete_one_filter`,
  - Paginated find methods (sync/async) type change from Iterable to Generator
  - Bugfix: handling of the mutable caller identity in copy and convert (sync/async) methods
  - Default value of `sort` is `None` and not `{}` for `find` (sync/async)
  - Introduction of `[Async]AstraDBCollection.chunked_delete_many` method
  - Added `projection` parameter to `find_one_and[replace/update]` (sync/async)
  - Bugfix: projection was silently ignored in `vector_find_one_and_[replace/update]` (sync/async)
  - Added `options` to `update_many` (sync/async)
  - `[Async]AstraDBDatabase.chunked_insert_many` does not intercept generic exceptions anymore, only `APIRequestError`
  - Bugfix: `AsyncAstraDBCollection.async chunked_insert_many` stops at the first error when `ordered=True`
  - Added payload info to `DataAPIException`
  - Added `find_one_and_delete` method (sync/async)
  - Added `skip_error_check` parameter to `delete_many` (sync/async)
  - Timeout support throughout the library
  - Added `sort` to `update_one`, `delete_one` and `delete_one_by_predicate` methods (sync/async)
  - Full support for UUID v1,3,4,5,6,7,8 and ObjectID at the collection data I/O level
  - `AstraDBOps.create_database` raises errors in case of failures
  - `AstraDBOps.create_database`, return type corrected
  - Fixed behaviour and return type of `AstraDBOps.create_keyspace` and `AstraDBOps.terminate_db`
  - Added `AstraDBOps.delete_keyspace` method
  - Method `create_collection` of `AstraDB` relaxes checks on passing `dimensions` for vector collections
  - AstraDBOps core class acquired async methods: `async_get_databases`, `async_get_database`, `async_create_database`, `async_terminate_database`, `async_create_keyspace`, `async_delete_keyspace`


pkgId: d2d2689751f48e90bd505a9811a0c47cb8ab2f2c1273745d1ae4fbb04574324a
name: python-astro
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: A package of astrodynamic functions
url: https://github.com/skulumani/astro
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-0.2.7-1.src.rpm
checksum_type: sha256
description:
  ``astro`` is Python package to perform basic astrodynamics.
  +-------------------------+---------------------+--------------------------+------------+-----------------------+
  | Build Status            | Code Coverage       | Docs                     | Citation   | PyPi                  |
  +=========================+=====================+==========================+============+=======================+
  | |Travis Build Status|   | |Coverage Status|   | |Documentation Status|   | |Citation| | |PyPi|                |
  +-------------------------+---------------------+--------------------------+------------+-----------------------+


pkgId: 18a7f0161f409d7fb3f6d028096f98e0b40811c14dde53432ac11063051fee58
name: python-astro-constants
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A Python library for common astronomical and physical constants
url: https://github.com/RedGloveProductions/Astronomy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-constants-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Astro Constants is a Python library that provides a comprehensive collection of commonly used **astronomical** and **physical constants**. This library is designed for developers, researchers, educators, and astronomy enthusiasts to simplify calculations and projects related to astrophysics, cosmology, and space science.

  - **Predefined Constants**:
    - Speed of Light (`SPEED_OF_LIGHT`)
    - Gravitational Constant (`GRAVITATIONAL_CONSTANT`)
    - Planck's Constant (`PLANCK_CONSTANT`)
    - Astronomical Unit (AU) (`ASTRONOMICAL_UNIT`)
    - Light Year (`LIGHT_YEAR`)
    - Parsec (`PARSEC`)
    - Masses and Radii of Celestial Bodies (Sun, Earth, Moon, Jupiter, etc.)
    - Surface Temperature of the Sun
    - Cosmic Microwave Background (CMB) Temperature
    - Orbital Periods (Earth, Moon)
    - Solar Luminosity
    - And many more!
  - **Easy-to-Use**:
    - Access constants with simple Python imports for quick implementation.
  - **Well-Documented**:
    - Full descriptions of all constants are provided to ensure clarity and usability.

  You can install the library directly from [PyPI](https://pypi.org/project/astro-constants/):
  ```bash
  pip install astro-constants
  ```

  Import the library into your Python project and access constants:
  ```python
  from astro_constants import SPEED_OF_LIGHT, MASS_OF_SUN
  print(f"The speed of light is {SPEED_OF_LIGHT} m/s.")
  print(f"The mass of the Sun is {MASS_OF_SUN} kg.")
  ```

  Here is a partial list of constants available in this library:

  - **Speed of Light**: `299792458 m/s`
  - **Gravitational Constant**: `6.67430e-11 m^3/kg/s^2`
  - **Planck's Constant**: `6.62607015e-34 J·s`
  - **Boltzmann Constant**: `1.380649e-23 J/K`

  - **Astronomical Unit (AU)**: `1.496e11 meters`
  - **Light Year**: `9.461e15 meters`
  - **Parsec**: `3.0857e16 meters`

  - **Mass of the Sun**: `1.989e30 kg`
  - **Mass of the Earth**: `5.972e24 kg`
  - **Mass of the Moon**: `7.348e22 kg`
  - **Radius of the Sun**: `6.9634e8 meters`
  - **Radius of the Earth**: `6.371e6 meters`

  - **Earth Orbital Period**: `365.25 days`
  - **Moon Orbital Period**: `27.322 days`
  - **Solar Luminosity**: `3.828e26 watts`

  We welcome contributions! If you'd like to contribute to this project, please:
  1. Fork the repository on GitHub.
  2. Make your changes.
  3. Submit a pull request with a clear description of the changes.

  This project is licensed under the MIT License.


pkgId: 1569571b04fb8698a490ee95bb75d2e671e071659ceee44f6123001b067bd72e
name: python-astro-elk
arch: src
version: 1.0
epoch: 0
release: 1
url: https://github.com/tobin-wainer/TESS_Cluster_Project/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-elk-1.0-1.src.rpm
checksum_type: sha256
summary:
  This python package computes, and corrects ensemble light curves for TESS pixels within a specified aperature, from TESS FFI data.

description:
  <p align="center">
      <img width="500", src="https://raw.githubusercontent.com/tobin-wainer/elk/main/docs/_static/main-logo.png">
  </p>

  <h2 align="center">
      Welcome to the int<b>E</b>grated <b>L</b>ight<b>K</b>urve (a.k.a. elk) Python package!
      <br>
      <a href='https://elk.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/elk/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="mailto:tobinw@uw.edu?cc=tomwagg@uw.edu">
          <img src="https://img.shields.io/badge/contact-authors-blueviolet.svg?style=flat" alt="Email the authors"/>
      </a>
  </h2>

  <p align="center">
      This package allows you to download, correct, analyze and visualize <i>integrated</i> light curves from TESS FFI data using the methods outlined in <a href="https://ui.adsabs.harvard.edu/abs/2023arXiv230709510W/abstract">Wainer+2023</a>. While originally designed for analysis of star clusters, it can be used to create integrated light curves for any given aperture.
  </p>


  Put simply? `pip install astro-elk`! But we recommend creating a conda environment first to ensure everything goes smoothly! Check out the installation instructions [here](https://elk.readthedocs.io/en/latest/pages/install.html) to learn exactly how to install `elk`


  All documentation for `elk` can be found <a href="https://elk.readthedocs.io/en/latest/">here!</a>


  This work is based on work originally supported by the Heising Simons Foundation. We'd also like to acknowledge the absolutely splendid work of <a href="https://www.samanthalynnmartinez.com">Samantha-Lynn Martinez</a> in designing the `elk` logo. You can find more of her portfolio <a href="https://www.samanthalynnmartinez.com/illustrationdesign">here</a> and we encourage you to reach out to her for any design needs you have!


pkgId: 989280709c6dc33eba93a5737278e47bcf2d0c496a6f396f2228f90b601a1567
name: python-astro-extras
arch: src
version: 0.1.10.1
epoch: 0
release: 1
summary: Additional Astro SDK operators
url: https://github.com/skolchin/astro-extras
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-extras-0.1.10.1-1.src.rpm
checksum_type: sha256
description:
  We've been using [Apache Airflow](https://airflow.apache.org/docs/apache-airflow/stable/)
  as ETL tool for quite some time. Recently I came across
  [Astronomer's Astro SDK](https://docs.astronomer.io/astro)
  which simplifies data processig with Airflow very much by providing
  functionality to easily load or save data,
  define custom transformations, adding transparent support of newest
  [Dataset](https://airflow.apache.org/docs/apache-airflow/stable/authoring-and-scheduling/datasets.html)
  concept, automatic lineage and so on.

  The goal of this project is to add some usefull features to these great products, such as:

  * ETL session concept
  * SQL file-based templates support
  * Simplified table processing routines
  * Heterogenios data transfer
  * and more

  Please note that this project is in the very early stage of development
  so anything could change in the future.





  ETL session is a logical group of data transfers united by single identifier (`session_id`).
  Sessions store information about data transfer source, target, data loading period
  and completion state thus providing all necessary information about the data flow.

  ETL session object defines its own data loading interval and allows
  to override automatic interval boundaries calculation using parameters when a DAG is started.

  Sessions are stored in a database in `sessions` table. Entries to that table are created
  when a new session is instantiated withing a DAG run and closed when DAG
  is finished.

  ETL session instance is pushed to XCom under `session` key
  and becomes available to all operators within the data pipeline (see query example below).



  SQL template is a file, which contains instructions and Jinja-macros substituted at runtime.
  For example, this template could be created in order to load data from `data_table` table
  within the limited date range:

  ``` sql
  select * from data_table
  where some_date between '{{ ti.xcom_pull(key="session").period_start }}'::timestamp
                  and '{{ ti.xcom_pull(key="session").period_end }}'::timestamp
  ```

  In order to be used, template file must be named after target object name
  and placed in a `templates\<dag_id>` folder under DAGS_ROOT. In given case,
  assuming it will be used in `test-data-load` DAG,
  template file name must be `./dags/templates/data_table.sql`.

  Note that it uses an `ETLSession` object from XCom to filter only actual data.



  Original Astro-SDK misses functionality to transfer data between different
  database systems (for example, from Oracle to PostgreSQL or vise versa).

  However, there is a [GenericTransfer](https://airflow.apache.org/docs/apache-airflow/stable/_api/airflow/operators/generic_transfer/index.html)
  operator available in original Airflow code, so this package adopts it to
  Astro-SDK style providing some easy-to-user `transfer_table` and `transfer_tables` functions.
  They are highly customizable and fully support SQL templates.



  Timed dictionaries are special kind of tables used mostly in Data Warehousing.
  They are designed in such a way that they keep multiple values of the same
  attribute for given key, and have a timestamp on what attribute value was
  at particular time moment.

  For example, this is a time dictionary table (PostgreSQL notation is used):

  ```sql
  create table dict_values(
      record_id serial primary key,
      effective_from timestamp not null,
      effective_to timestamp,
      src_id int not null,
      some_value text not null
  );
  ```
  Here, `src_id` is an ID of a record on a source, and `some_value` is
  time-dependent attribute of that ID.
  And, `effective_from` / `effective_to` pair of columns denotes
  what period the particular value of `some_value` was assigned to
  particular `src_id` value.

  If we have this table filled like this:


  | record_id | effective_from | effective_to | src_id | some_value |
  | --------- | -------------- | ---------    | ------ | ---------- |
  | 1         | 2023-01-11 00:00:00 | null | 10 | Some value |


  and then `some_value` property of record with `id = 10` on source changes to `Some other value``,
  then, after updating at 2023-11-02 00:01:00, this timed dictionary should look like this:

  | record_id | effective_from | effective_to | src_id | some_value |
  | --------- | -------------- | ---------    | ------ | ---------- |
  | 1         | 2023-11-01 00:00:01 | 2023-11-02 00:00:59 | 10 | Some value |
  | 2         | 2023-11-02 00:01:00 | null | 10 | Some other value |


  As you see, record with `record_id = 1` is now "closed", meaning that it
  has `effective_to` attribute set, and new record with `record_id = 2` was
  added and have `effective_to` set to null.

  Any query on this timed dictionarty should include `effective_from` / `effective_to`
  columns check, for example like this:

  ```sql
  select src_id as id, some_value from dict_values
  where date_of_interest between effective_from and coalesce(effective_to, '2099-12-31')
  ```

  where date_of_interest is some date when this query is running for.

  To update timed dictionaries, one should use `update_timed_table` / `update_timed_tables`
  functions.



  Create a DAG which opens a session, outputs session info to log and closes it:

  ``` python
  with DAG(...) as dag, ETLSession('source', 'target') as session:
      @dag.task
      def print_session(session: ETLSession):
          print(session)
      print_session(session)
  ```

  Create a DAG with `open-session -> transfer-data_table -> close_session`
  task sequence:

  ``` python
  with DAG(...) as dag:
      session = open_session('source', 'target')
      transfer_table('data_table', session=session)
      close_session(session)
  ```

  Upon execution, this DAG will transfer data of `data_table` from source to target
  database wrapping this in a session. This would help to easily identify when particular record
  was loaded or clean up after unsuccessfull attempts.

  The same, but using a context manager:

  ``` python
  with DAG(...) as dag, ETLSession('source', 'target') as session:
      transfer_table('test_table', session=session)
  ```



  To build a package from source, run Python build command and then install the package:

  ``` console
  python -m build .
  pip install ./dist/astro_extras-xxxx-py3-none-any.whl
  ```

  Airflow could be used directly under Unix environment, but this is not possible in Windows.
  Anyway, using a docker is much easier in all cases.

  A `docker-compose.yml` file should be used to start Airflow in a docker
  environment. After building the package, run this command at the top directory:

  ``` console
  docker compose -p astro-extras up -d --build
  ```

  To shutdown the docker, run:

  ``` console
  docker compose -p astro-extras down -v
  ```



  To setup testing evironment, install pytest with:

  ``` console
  pip install -r ./tests/requirements.txt
  ```

  Then, jump to `/tests` directory and run pytest:

  ``` console
  cd ./tests
  pytest -s -v
  ```

  This will build docker image and start `astro-extras-test` stack using `docker-compose-test.yml` file.
  The packaget must be built beforehand.

  After the tests complete, test stack will be shot down, but you may add `--keep` option
  in order to keep it running.


pkgId: 897187aa0c8257e27ec3205565ffd6bad8ee925e742911ecf853543969675649
name: python-astro-ghost
arch: src
version: 2.1.5
epoch: 0
release: 1
url: https://github.com/pypa/sampleproject
rpm_license: GNU GPL v3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-ghost-2.1.5-1.src.rpm
checksum_type: sha256
summary:
  A package to associate transients with host galaxies, and a database of 16k SNe-host galaxies in PS1.

description:
  "At the last dim horizon, we search among ghostly errors of observations for
  landmarks that are scarcely more substantial. The search will continue. The
  urge is older than history. It is not satisfied and it will not be oppressed."
  --Edwin Hubble
  Welcome to GHOST, the database for supernovae and their host galaxies. This
  database contains ~16k sources in PS1, which were used to predict supernova
  classes in Gagliano et al. (2020). Installation instructions for the analysis
  tools are below.


pkgId: e20fe482ef1188d474cd20697aa6e226e5add7c0e310e7f2089ec959b6a549e3
name: python-astro-p3
arch: src
version: 1.2.14
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/astro-p3/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-p3-1.2.14-1.src.rpm
checksum_type: sha256
description:
  P3 is a collection of libraries for Adaptive Optics (AO) Point Spread Function (PSF) modeling, simulation, fitting and reconstruction.

  The list of libraries is:

  * [aoSystem](https://github.com/astro-tiptop/P3/tree/main/p3/aoSystem) --> The main purpose of this library is to model an AO PSF. It is an analytical simulator based on a Fourier appoach.
  Supported wavefront sensors are Shack-Hartmann and Pyramid.
  Several kind of AO are supported: single conjugate AO (SCAO), single laser AO (SLAO), laser tomography AO (LTAO), ground layer AO (GLAO), multi conjugate AO (MCAO), but only one kind of guide star can be used (natural or laser).
  In [TIPTOP](https://github.com/astro-tiptop/TIPTOP) it is used to compute the so-called high order PSF.
  Examples and tests can be found in [p3/aoSystem/testing](https://github.com/astro-tiptop/P3/tree/main/p3/aoSystem/testing).
  Examples of parameters file can be found in [p3/aoSystem/parFiles](https://github.com/astro-tiptop/P3/tree/main/p3/aoSystem/parFiles).
  * [deepLoop](https://github.com/astro-tiptop/P3/tree/main/p3/deepLoop)
  * [psfFitting](https://github.com/astro-tiptop/P3/tree/main/p3/psfFitting) --> This library can be used to fit parameters on a PSF model (aoSystem/fourierModel or psfao21).
  Examples and tests can be found in [p3/testing](https://github.com/astro-tiptop/P3/tree/main/p3/testing).
  * [psfao21](https://github.com/astro-tiptop/P3/tree/main/p3/psfao21) --> This library can be used to model with a small number of parameters the AO PSF. Its main purpose is PSF fitting.
  Examples and tests can be found in [p3/testing](https://github.com/astro-tiptop/P3/tree/main/p3/testing).
  * [psfr](https://github.com/astro-tiptop/P3/tree/main/p3/psfr) --> The main purpose of this library is to reconstruct PSF from telemetry data or from image fitting.
  Examples and tests can be found in [p3/testing](https://github.com/astro-tiptop/P3/tree/main/p3/testing).
  * [telemetry](https://github.com/astro-tiptop/P3/tree/main/p3/telemetry) --> This library is used to manage telemetry data for PSFR.
  Examples and tests can be found in [p3/testing](https://github.com/astro-tiptop/P3/tree/main/p3/testing).


pkgId: 4d9c08b04b8b46332f8a1eb6c070aea4569613b8922842dfa416a7d11492ed36
name: python-astro-pi-replay
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A CLI to replay historic data from previous ISS missions.
url: https://github.com/astro-pi/Astro-Pi-Replay
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-pi-replay-1.1.1-1.src.rpm
checksum_type: sha256
description:
  ![Build and test workflow](https://github.com/astro-pi/Astro-Pi-Replay/actions/workflows/build_and_test_scheduler.yml/badge.svg?branch=main)
  ![Build and test workflow](https://github.com/astro-pi/Astro-Pi-Replay/actions/workflows/build_and_test_worker.yml/badge.svg?branch=main)



  A CLI to replay historic data from previous ISS missions.

  All function calls from the `picamera`, `picamera2`, `sense_hat`, `skyfield`, and `orbit` libraries
  will be mocked to return data from an historic run from the ISS, rather than from attached hardware.
  This allows teams to test their code with representative data and provide a confidence boost that
  their code will work



  Change to your project directory (`cd my-project`), install `Astro-Pi-Replay` using `pip`, and then run your program with `Astro-Pi-Replay run main.py`.

  For more detailed installation instructions, checkout the docs site.

  This will prepare a sequence of near-infrared images (NIR) images, together with the corresponding
  data collected from the Sense Hat, to be returned by all calls to `picamera`, `sense_hat`, etc.
  The CLI allows for some configuration of this behaviour - see the [Documentation](#documentation) for more details.



  See the [docs](../docs) page.

rpm_license:
  Copyright 2023- Raspberry Pi Foundation  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the copyright 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: c1a6cae0752b37bee28a6bd2259a55c454b429a6316d512a35f39b8cece3847e
name: python-astro-projects
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: A decorator that allows users to run SQL queries natively in Airflow.
url: https://pypi.org/project/astro-projects/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-projects-0.8.3-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    astro
  </h1>
    <h3 align="center">
    workflows made easy<br><br>
  </h3>

  [![Python versions](https://img.shields.io/pypi/pyversions/astro-projects.svg)](https://pypi.org/pypi/astro-projects)
  [![License](https://img.shields.io/pypi/l/astro-projects.svg)](https://pypi.org/pypi/astro-projects)
  [![Development Status](https://img.shields.io/pypi/status/astro-projects.svg)](https://pypi.org/pypi/astro-projects)
  [![PyPI downloads](https://img.shields.io/pypi/dm/astro-projects.svg)](https://pypistats.org/packages/astro-projects)
  [![Contributors](https://img.shields.io/github/contributors/astro-projects/astro)](https://github.com/astro-projects/astro)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/astro-projects/astro)](https://github.com/astro-projects/astro)
  [![CI](https://github.com/astro-projects/astro/actions/workflows/ci.yaml/badge.svg)](https://github.com/astro-projects/astro)
  [![codecov](https://codecov.io/gh/astro-projects/astro/branch/main/graph/badge.svg?token=MI4SSE50Q6)](https://codecov.io/gh/astro-projects/astro)

  **astro** allows rapid and clean development of {Extract, Load, Transform} workflows using Python.
  It helps DAG authors to achieve more with less code.
  It is powered by [Apache Airflow](https://airflow.apache.org) and maintained by [Astronomer](https://astronomer.io).

  > :warning: **Disclaimer** This project's development status is alpha. In other words, it is not production-ready yet.
  The interfaces may change. We welcome alpha users and brave souls to test it - any feedback is welcome.



  **Astro** is available at [PyPI](https://pypi.org/project/astro-projects/). Use the standard Python
  [installation tools](https://packaging.python.org/en/latest/tutorials/installing-packages/).

  To install a cloud-agnostic version of **Astro**, run:

  ```
  pip install astro-projects
  ```

  If using cloud providers, install using the optional dependencies of interest:

  ```commandline
  pip install astro-projects[amazon,google,snowflake,postgres]
  ```



  After installing Astro, copy the following example dag `calculate_popular_movies.py` to a local directory named `dags`:

  ```Python
  from datetime import datetime
  from airflow import DAG
  from astro import sql as aql
  from astro.sql.table import Table


  @aql.transform()
  def top_five_animations(input_table: Table):
      return """
          SELECT Title, Rating
          FROM {{input_table}}
          WHERE Genre1=='Animation'
          ORDER BY Rating desc
          LIMIT 5;
      """


  with DAG(
      "calculate_popular_movies",
      schedule_interval=None,
      start_date=datetime(2000, 1, 1),
      catchup=False,
  ) as dag:
      imdb_movies = aql.load_file(
          path="https://raw.githubusercontent.com/astro-projects/astro/main/tests/data/imdb.csv",
          task_id="load_csv",
          output_table=Table(
              table_name="imdb_movies", database="sqlite", conn_id="sqlite_default"
          ),
      )

      top_five_animations(
          input_table=imdb_movies,
          output_table=Table(
              table_name="top_animation", database="sqlite", conn_id="sqlite_default"
          ),
      )
  ```

  Set up a local instance of Airflow by running:

  ```shell
  export AIRFLOW_HOME=`pwd`
  export AIRFLOW__CORE__ENABLE_XCOM_PICKLING=True

  airflow db init
  ```

  Create an SQLite database for the example to run with and run the DAG:

  ```shell

  export SQL_TABLE_NAME=`airflow connections get sqlite_default -o yaml | grep host | awk '{print $2}'`

  sqlite3 "$SQL_TABLE_NAME" "VACUUM;"
  airflow dags test calculate_popular_movies `date -Iseconds`
  ```

  Check the top five animations calculated by your first Astro DAG by running:

  ```shell
  sqlite3 "$SQL_TABLE_NAME" "select * from top_animation;" ".exit"
  ```

  You should see the following output:

  ```console
  $ sqlite3 "$SQL_TABLE_NAME" "select * from top_animation;" ".exit"
  Toy Story 3 (2010)|8.3
  Inside Out (2015)|8.2
  How to Train Your Dragon (2010)|8.1
  Zootopia (2016)|8.1
  How to Train Your Dragon 2 (2014)|7.9
  ```



  Because **astro** relies on the [Task Flow API](https://airflow.apache.org/docs/apache-airflow/stable/concepts/taskflow.html) and
  it depends on Apache Airflow >= 2.1.0.



  | Databases       | File types | File locations |
  |-----------------|------------|----------------|
  | Google BigQuery | CSV        | Amazon S3      |
  | Postgres        | JSON       | Filesystem     |
  | Snowflake       | NDJSON     | Google GCS     |
  | SQLite          | Parquet    |                |




  A summary of the currently available operations in **astro**. More details are available in the [reference guide](docs/OLD_README.md).
  * `load_file`: load a given file into a SQL table
  * `transform`: applies a SQL select statement to a source table and saves the result to a destination table
  * `truncate`: remove all records from a SQL table
  * `run_raw_sql`: run any SQL statement without handling its output
  * `append`: insert rows from the source SQL table into the destination SQL table, if there are no conflicts
  * `merge`: insert rows from the source SQL table into the destination SQL table, depending on conflicts:
    * ignore: do not add rows that already exist
    * update: replace existing rows with new ones
  * `save_file`: export SQL table rows into a destination file
  * `dataframe`: export given SQL table into in-memory Pandas data-frame
  * `render`: given a directory containing SQL statements, dynamically create transform tasks within a DAG



  The documentation is a work in progress, and we aim to follow the [Diátaxis](https://diataxis.fr/) system:
  * **Tutorial**: a hands-on introduction to **astro**
  * **How-to guides**: simple step-by-step user guides to accomplish specific tasks
  * **[Reference guide](docs/OLD_README.md)**: commands, modules, classes and methods
  * **Explanation**: Clarification and discussion of key decisions when designing the project.



  We follow Semantic Versioning for releases. Check the [changelog](docs/CHANGELOG.md) for the latest changes.



  To learn more about our release philosophy and steps, check [here](docs/RELEASE.md)



  All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.

  Read the [Contribution Guideline](docs/CONTRIBUTING.md) for a detailed overview on how to contribute.

  As contributors and maintainers to this project, you should abide by the [Contributor Code of Conduct](docs/CODE_OF_CONDUCT.md).



  [Apache Licence 2.0](LICENSE)


pkgId: 653ccf0770a36610c491b12f8f781fa45f675a11d26b80d8f24a3f223860b464
name: python-astro-prospector
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Stellar Population Inference from Spectra and SEDs
url: https://prospect.readthedocs.io/en/latest/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-prospector-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![Docs](https://readthedocs.org/projects/prospect/badge/?version=latest)](https://readthedocs.org/projects/prospect/badge/?version=latest)
  [![Tests](https://github.com/bd-j/prospector/workflows/Tests/badge.svg)](https://github.com/bd-j/prospector/actions?query=workflow%3ATests)
  [![arXiv](https://img.shields.io/badge/arXiv-2012.01426-b31b1b.svg)](https://arxiv.org/abs/2012.01426)
  [![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/bd-j/prospector/blob/main/LICENSE)


pkgId: 209c03a53642acc82fb7dbed82dd2e6c2a39df78a2aeba43666b73ce4389621c
name: python-astro-provider-ray
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: An Apache Airflow provider package built by Astronomer to integrate with Ray.
url: https://astronomer.io
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-provider-ray-0.2.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    Ray provider
  </h1>

  <div align="center">

  :books: [Docs](https://astronomer.github.io/astro-provider-ray/) &nbsp; | &nbsp; :rocket: [Getting Started](https://astronomer.github.io/astro-provider-ray/getting_started/setup.html) &nbsp; | &nbsp; :speech_balloon: [Slack](https://join.slack.com/t/apache-airflow/shared_invite/zt-2nsw28cw1-Lw4qCS0fgme4UI_vWRrwEQ) (``#airflow-ray``)&nbsp; | &nbsp; :fire: [Contribute](https://astronomer.github.io/astro-provider-ray/CONTRIBUTING.html) &nbsp;

  </div>

  Orchestrate your Ray jobs using [Apache Airflow®](https://airflow.apache.org/) combining Airflow's workflow management with Ray's distributed computing capabilities.

  Benefits of using this provider include:
  - **Integration**: Incorporate Ray jobs into Airflow DAGs for unified workflow management.
  - **Distributed computing**: Use Ray's distributed capabilities within Airflow pipelines for scalable ETL, LLM fine-tuning etc.
  - **Monitoring**: Track Ray job progress through Airflow's user interface.
  - **Dependency management**: Define and manage dependencies between Ray jobs and other tasks in DAGs.
  - **Resource allocation**: Run Ray jobs alongside other task types within a single pipeline.



  - [Quickstart](#quickstart)
  - [Sample DAGs](#sample-dags)
  - [Getting Involved](#getting-involved)
  - [Changelog](#changelog)
  - [Contributing Guide](#contributing-guide)


  Check out the Getting Started guide in our [docs](https://astronomer.github.io/astro-provider-ray/getting_started/setup.html). Sample DAGs are available at [example_dags/](https://github.com/astronomer/astro-provider-ray/tree/main/example_dags).




  The below example showcases how to use the ``@ray.task`` decorator to manage the full lifecycle of a Ray cluster: setup, job execution, and teardown.

  This approach is ideal for jobs that require a dedicated, short-lived cluster, optimizing resource usage by cleaning up after task completion

  https://github.com/astronomer/astro-provider-ray/blob/bd6d847818be08fae78bc1e4c9bf3334adb1d2ee/example_dags/ray_taskflow_example.py#L1-L57


  This example shows how to use separate operators for cluster setup, job submission, and teardown, providing more granular control over the process.

  This approach allows for more complex workflows involving Ray clusters.

  Key Points:

  - Uses SetupRayCluster, SubmitRayJob, and DeleteRayCluster operators separately.
  - Allows for multiple jobs to be submitted to the same cluster before deletion.
  - Demonstrates how to pass cluster information between tasks using XCom.

  This method is ideal for scenarios where you need fine-grained control over the cluster lifecycle, such as running multiple jobs on the same cluster or keeping the cluster alive for a certain period.

  https://github.com/astronomer/astro-provider-ray/blob/bd6d847818be08fae78bc1e4c9bf3334adb1d2ee/example_dags/setup-teardown.py#L1-L44



  | Platform | Purpose | Est. Response time |
  |:---:|:---:|:---:|
  | [Discussion Forum](https://github.com/astronomer/astro-provider-ray/discussions) | General inquiries and discussions | < 3 days |
  | [GitHub Issues](https://github.com/astronomer/astro-provider-ray/issues) | Bug reports and feature requests | < 1-2 days |
  | [Slack](https://join.slack.com/t/apache-airflow/shared_invite/zt-2nsw28cw1-Lw4qCS0fgme4UI_vWRrwEQ) | Quick questions and real-time chat | 12 hrs |


  We follow [Semantic Versioning](https://semver.org/) for releases. Check [CHANGELOG.rst](https://github.com/astronomer/astro-provider-ray/blob/main/CHANGELOG.rst) for the latest changes.


  All contributions, bug reports, bug fixes, documentation improvements, enhancements are welcome.

  A detailed overview on how to contribute can be found in the [Contributing Guide](https://github.com/astronomer/astro-provider-ray/blob/main/docs/CONTRIBUTING.rst).


  [Apache 2.0 License](https://github.com/astronomer/astro-provider-ray/blob/main/LICENSE)


pkgId: a4ab2a33b1e6e438fea940413fd406ce2912fa6cfbfe55891f193068bcfaa544
name: python-astro-pyvista
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Astronomical image processing
url: https://github.com/holtzmanjon/pyvista
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-pyvista-0.4.0-1.src.rpm
checksum_type: sha256
description:
  pyvista is a package for the inspection, reduction, and analysis
  of astronomical data. It includes a native Python display tool, tv,
  that is modeled after the original xvista display tool.

  Much of the package is under some level of development, but includes
  modules for:

  - image display (tv)
  - image reduction (imred)
  - spectral analysis (spectra) : tracing, wavelength calibration, fluxing
  - observation planning (skycalc) : wrappers around astroplan
  - exposure time calculation tools (etc)
  - stellar photometry (stars) : wrappers around photutils)
  - image manipulation (image) : functions for basic image manipulation, including boxes
  - image simulation (simulate)

  Help can be found at https://pyvista.readthedocs.org

  Some examples, in the form of jupyter notebooks, can be found
  in the docs/notebooks subdirectory of the distribution, see
  https://github.com/holtzmanjon/pyvista/tree/main/doc/notebooks

  Questions, requests, etc. can  be directed to Jon Holtzman at
  holtz@nmsu.edu


pkgId: 3816559ed52701661f0648d8df95e1386145ca498c63b1bc7386cd64fe70877e
name: python-astro-sdk-python
arch: src
version: 1.8.1
epoch: 0
release: 1
url: https://pypi.org/project/astro-sdk-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-sdk-python-1.8.1-1.src.rpm
checksum_type: sha256
summary:
  Astro SDK allows rapid and clean development of {Extract, Load, Transform} workflows using Python and SQL, powered by Apache Airflow.

description:
  <h1 align="center">
    astro
  </h1>
    <h3 align="center">
    workflows made easy<br><br>
  </h3>

  [![Python versions](https://img.shields.io/pypi/pyversions/astro-sdk-python.svg)](https://pypi.org/pypi/astro-sdk-python)
  [![License](https://img.shields.io/pypi/l/astro-sdk-python.svg)](https://pypi.org/pypi/astro-sdk-python)
  [![Development Status](https://img.shields.io/pypi/status/astro-sdk-python.svg)](https://pypi.org/pypi/astro-sdk-python)
  [![PyPI downloads](https://img.shields.io/pypi/dm/astro-sdk-python.svg)](https://pypistats.org/packages/astro-sdk-python)
  [![Contributors](https://img.shields.io/github/contributors/astronomer/astro-sdk)](https://github.com/astronomer/astro-sdk)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/astronomer/astro-sdk)](https://github.com/astronomer/astro-sdk)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/astronomer/astro-sdk/main.svg)](https://results.pre-commit.ci/latest/github/astronomer/astro-sdk/main)
  [![CI](https://github.com/astronomer/astro-sdk/actions/workflows/ci-python-sdk.yaml/badge.svg)](https://github.com/astronomer/astro-sdk)
  [![codecov](https://codecov.io/gh/astronomer/astro-sdk/branch/main/graph/badge.svg?token=MI4SSE50Q6)](https://codecov.io/gh/astronomer/astro-sdk)

  **Astro Python SDK** is a Python SDK for rapid development of extract, transform, and load workflows in [Apache Airflow](https://airflow.apache.org/). It allows you to express your workflows as a set of data dependencies without having to worry about ordering and tasks. The Astro Python SDK is maintained by [Astronomer](https://astronomer.io).



  - Apache Airflow >= 2.1.0.



  The Astro Python SDK is available at [PyPI](https://pypi.org/project/astro-sdk-python/). Use the standard Python
  [installation tools](https://packaging.python.org/en/latest/tutorials/installing-packages/).

  To install a cloud-agnostic version of the SDK, run:

  ```shell
  pip install astro-sdk-python
  ```

  You can also install dependencies for using the SDK with popular cloud providers:

  ```shell
  pip install astro-sdk-python[amazon,google,snowflake,postgres]
  ```



  1. Ensure that your Airflow environment is set up correctly by running the following commands:

      ```shell
      export AIRFLOW_HOME=`pwd`
      export AIRFLOW__CORE__XCOM_BACKEND=astro.custom_backend.astro_custom_backend.AstroCustomXcomBackend
      export AIRFLOW__ASTRO_SDK__STORE_DATA_LOCAL_DEV=true
      airflow db init
      ```
     > **Note:** `AIRFLOW__CORE__ENABLE_XCOM_PICKLING` no longer needs to be enabled for `astro-sdk-python`. This functionality is now deprecated as our custom xcom backend handles serialization.

      The `AIRFLOW__ASTRO_SDK__STORE_DATA_LOCAL_DEV` should only be used for local development. The [XCom backend docs](https://astro-sdk-python.readthedocs.io/en/latest/guides/xcom_backend.html#airflow_xcom_backend) give further details about how to set this up in non-local environments.

      Currently, custom XCom backends are limited to data types that are json serializable. Since Dataframes are not json serializable, we need to enable XCom pickling to store dataframes.

      The data format used by pickle is Python-specific. This has the advantage that there are no restrictions imposed by external standards such as JSON or XDR (which can’t represent pointer sharing); however it means that non-Python programs may not be able to reconstruct pickled Python objects.

      Read more: [enable_xcom_pickling](https://airflow.apache.org/docs/apache-airflow/stable/configurations-ref.html#enable-xcom-pickling) and [pickle](https://docs.python.org/3/library/pickle.html#comparison-with-json):


  2. Create a SQLite database for the example to run with:

      ```shell
      
      export SQL_TABLE_NAME=`airflow connections get sqlite_default -o yaml | grep host | awk '{print $2}'`
      sqlite3 "$SQL_TABLE_NAME" "VACUUM;"
      ```

  3. Copy the following workflow into a file named `calculate_popular_movies.py` and add it to the `dags` directory of your Airflow project:

     https://github.com/astronomer/astro-sdk/blob/d5aa768b2d4bca72ef98f8d533fe3f99624b172f/example_dags/calculate_popular_movies.py#L1-L37

     Alternatively, you can download `calculate_popular_movies.py`
     ```shell
      curl -O https://raw.githubusercontent.com/astronomer/astro-sdk/main/python-sdk/example_dags/calculate_popular_movies.py
     ```

  4. Run the example DAG:

      ```sh
      airflow dags test calculate_popular_movies `date -Iseconds`
      ```

  5. Check the result of your DAG by running:

      ```shell
      sqlite3 "$SQL_TABLE_NAME" "select * from top_animation;" ".exit"
      ```

      You should see the following output:

      ```shell
      $ sqlite3 "$SQL_TABLE_NAME" "select * from top_animation;" ".exit"
      Toy Story 3 (2010)|8.3
      Inside Out (2015)|8.2
      How to Train Your Dragon (2010)|8.1
      Zootopia (2016)|8.1
      How to Train Your Dragon 2 (2014)|7.9
      ```



  | Databases        |
  |------------------|
  | Databricks Delta |
  | Google BigQuery  |
  | Postgres         |
  | Snowflake        |
  | SQLite           |
  | Amazon Redshift  |
  | Microsoft SQL    |
  | DuckDB           |

  | File types |
  |------------|
  | CSV        |
  | JSON       |
  | NDJSON     |
  | Parquet    |

  | File stores  |
  |--------------|
  | Amazon S3    |
  | Filesystem   |
  | Google GCS   |
  | Google Drive |
  | SFTP         |
  | FTP          |
  | Azure WASB   |
  | Azure WASBS  |



  The following are some key functions available in the SDK:

  - [`load_file`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/load_file.html): Load a given file into a SQL table
  - [`transform`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/transform.html): Applies a SQL select statement to a source table and saves the result to a destination table
  - [`drop_table`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/drop_table.html): Drops a SQL table
  - [`run_raw_sql`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/raw_sql.html): Run any SQL statement without handling its output
  - [`append`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/append.html): Insert rows from the source SQL table into the destination SQL table, if there are no conflicts
  - [`merge`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/merge.html): Insert rows from the source SQL table into the destination SQL table, depending on conflicts:
    - `ignore`: Do not add rows that already exist
    - `update`: Replace existing rows with new ones
  - [`export_file`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/export.html): Export SQL table rows into a destination file
  - [`dataframe`](https://astro-sdk-python.readthedocs.io/en/stable/astro/sql/operators/dataframe.html): Export given SQL table into in-memory Pandas data-frame

  For a full list of available operators, see the [SDK reference documentation](https://astro-sdk-python.readthedocs.io/en/stable/operators.html).



  The documentation is a work in progress--we aim to follow the [Diátaxis](https://diataxis.fr/) system:

  - **[Getting Started Tutorial](https://docs.astronomer.io/learn/astro-python-sdk)**: A hands-on introduction to the Astro Python SDK
  - **How-to guides**: Simple step-by-step user guides to accomplish specific tasks
  - **[Reference guide](https://astro-sdk-python.readthedocs.io/)**: Commands, modules, classes and methods
  - **Explanation**: Clarification and discussion of key decisions when designing the project



  The Astro Python SDK follows semantic versioning for releases. Check the [changelog](docs/CHANGELOG.md) for the latest changes.



  To learn more about our release philosophy and steps, see [Managing Releases](docs/development/RELEASE.md).



  All contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome.

  Read the [Contribution Guideline](./docs/development/CONTRIBUTING.md) for a detailed overview on how to contribute.

  Contributors and maintainers should abide by the [Contributor Code of Conduct](CODE_OF_CONDUCT.md).



  [Apache Licence 2.0](LICENSE)


pkgId: 5dfbeeb2b3e4cdc58661ea7a74c761cd24d3a2b7ab4f8c9fae637a4fa4e67bef
name: python-astro-tiptop
arch: src
version: 1.3.13
epoch: 0
release: 1
summary: Analytical simulator for astronomical adaptive optics systems
url: https://pypi.org/project/astro-tiptop/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-tiptop-1.3.13-1.src.rpm
checksum_type: sha256
description:
  In order to be able to easily predict the AO performance, we have developed
  this fast algorithm producing the expected Adaptive Optics (AO see
  https://en.wikipedia.org/wiki/Adaptive_optics) Point Spread Function (PSF) for
  any of the existing AO observing modes (Single-Conjugate-AO,
  Laser-Tomographic-AO, Multi-Conjugate-AO, Ground-Layer-AO), and any atmospheric
  conditions. This TIPTOP tool takes its roots in an analytical approach, where
  the simulations are done in the Fourier domain. This allows to reach a very
  fast computation time (few seconds per PSF with GPU acceleration), and
  efficiently explore the wide parameter space.

  See the documentation here: https://tiptop.readthedocs.io


pkgId: 078dd82c97ef6537ef9fa242489fdc17509c89c910aab582514767f4497817d1
name: python-astro-trigger-filter
arch: src
version: 0.1.21
epoch: 0
release: 1
summary: A package for filtering triggers from radio astronomical matched template pulse searches.
url: https://github.com/sitmo/astro-trigger-filter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astro-trigger-filter-0.1.21-1.src.rpm
checksum_type: sha256
description:
  A Python package for filtering radio astronomical pulse matched template searches.




  ```
  pip install astro-trigger-filter
  ```




  ```
  shell> ambertf -i CM??.trigger -o output.txt -v
  ```



  <https://astro-trigger-filter.readthedocs.io/>


pkgId: eaed3834eeed805957268621dccee25ccc3e3629c22eead952b44b952f701369
name: python-astroalign
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: Astrometric Alignment of Images
url: https://pypi.org/project/astroalign/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroalign-2.6.0-1.src.rpm
checksum_type: sha256
description:
  ![logo](docs/images/logo-inline-dark-light.png)

  ***

  [![QuatroPe](https://img.shields.io/badge/QuatroPe-Applications-1c5896)](https://quatrope.github.io/)
  [![unit tests](https://github.com/quatrope/astroalign/actions/workflows/aa-ci.yml/badge.svg?branch=master)](https://github.com/quatrope/astroalign/actions/workflows/aa-ci.yml)
  [![Coverage](https://codecov.io/github/quatrope/astroalign/coverage.svg?branch=master)](https://codecov.io/github/quatrope/astroalign)
  [![Documentation Status](https://readthedocs.org/projects/astroalign/badge/?version=latest)](http://astroalign.readthedocs.org/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/astroalign)](https://pypi.org/project/astroalign/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/astroalign)
  [![ascl:1906.001](https://img.shields.io/badge/ascl-1906.001-blue.svg?colorB=262255)](http://ascl.net/1906.001)


  **ASTROALIGN** is a python module that will try to align two stellar astronomical images, especially when there is no WCS information available.

  It does so by finding similar 3-point asterisms (triangles) in both images and deducing the affine transformation between them.

  Generic registration routines try to match feature points, using corner
  detection routines to make the point correspondence.
  These generally fail for stellar astronomical images, since stars have very
  little stable structure and so, in general, indistinguishable from each other.
  Asterism matching is more robust, and closer to the human way of matching stellar images.

  Astroalign can match images of very different field of view, point-spread function, seeing and atmospheric conditions.

  It may not work, or work with special care, on images of extended objects with few point-like sources or in very crowded fields.

  You can find a Jupyter notebook example with the main features at [http://quatrope.github.io/astroalign/](http://quatrope.github.io/astroalign/).

  **Full documentation:** https://astroalign.readthedocs.io/



  Using setuptools:

  ```bash
  $ pip install astroalign
  ```

  or from this distribution with

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



  This library is optionally compatible with [bottleneck](https://github.com/pydata/bottleneck) and may offer performance improvements in some cases.
  Install bottleneck in your project as a peer to astroalign using:

  ```bash
  pip install bottleneck
  ```

  `Astroalign` will pick this optional dependency up and use it's performance improved functions for computing transforms.



  ```bash
  python tests/test_align.py
  ```



  ```
  >>> import astroalign as aa
  >>> aligned_image, footprint = aa.register(source_image, target_image)
  ```

  In this example `source_image` will be interpolated by a transformation to coincide pixel to pixel with `target_image` and stored in `aligned_image`.

  If we are only interested in knowing the transformation and the correspondence of control points in both images, use `find_transform` will return the transformation in a [Scikit-Image](https://scikit-image.org/) `SimilarityTransform` object and a list of stars in source with the corresponding stars in target.

  ```
  >>> transf, (s_list, t_list) = aa.find_transform(source, target)
  ```

  `source` and `target` can each either be the numpy array of the image (grayscale or color),
  or an iterable of (x, y) pairs of star positions on the image.

  The returned `transf` object is a scikit-image [`SimilarityTranform`](http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.SimilarityTransform) object that contains the transformation matrix along with the scale, rotation and translation parameters.

  `s_list` and `t_list` are numpy arrays of (x, y) point correspondence between `source` and `target`. `transf` applied to `s_list` will approximately render `t_list`.



  There are other related software that may offer similar functionality as astroalign.
  This list is not exhaustive and may be others.

  * [astrometry.net](https://github.com/dstndstn/astrometry.net)
  * [reproject](https://github.com/astropy/reproject)
  * [Watney Astrometry Engine](https://github.com/Jusas/WatneyAstrometry)
  * [Stellar Solver](https://github.com/rlancaste/stellarsolver)
  * [THRASTRO](https://github.com/THRASTRO/astrometrylib)
  * [Montage](https://github.com/Caltech-IPAC/Montage)
  * [Aafitrans](https://github.com/prajwel/aafitrans)
  * [astrometry](https://github.com/neuromorphicsystems/astrometry)



  If you use astroalign in a scientific publication, we would appreciate citations to the following [paper](https://www.sciencedirect.com/science/article/pii/S221313372030038X):

      Astroalign: A Python module for astronomical image registration.
      Beroiz, M., Cabral, J. B., & Sanchez, B.
      Astronomy & Computing, Volume 32, July 2020, 100384.

  ***

  TOROS Dev Team

  <martinberoiz@gmail.com>

rpm_license:
  MIT License  Copyright (c) 2016-2019 Martin Beroiz  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: a236dcec087c2cdd988cdadcbe6e9fe33470d159539ad516e0066dceb574d974
name: python-astroalign
arch: src
version: 2.6.1
epoch: 0
release: 1
summary: Astrometric Alignment of Images
url: https://pypi.org/project/astroalign/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroalign-2.6.1-1.src.rpm
checksum_type: sha256
description:
  ![logo](docs/images/logo-inline-dark-light.png)

  ***

  [![QuatroPe](https://img.shields.io/badge/QuatroPe-Applications-1c5896)](https://quatrope.github.io/)
  [![unit tests](https://github.com/quatrope/astroalign/actions/workflows/aa-ci.yml/badge.svg?branch=master)](https://github.com/quatrope/astroalign/actions/workflows/aa-ci.yml)
  [![Coverage](https://codecov.io/github/quatrope/astroalign/coverage.svg?branch=master)](https://codecov.io/github/quatrope/astroalign)
  [![Documentation Status](https://readthedocs.org/projects/astroalign/badge/?version=latest)](http://astroalign.readthedocs.org/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/astroalign)](https://pypi.org/project/astroalign/)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/astroalign)
  [![ascl:1906.001](https://img.shields.io/badge/ascl-1906.001-blue.svg?colorB=262255)](http://ascl.net/1906.001)


  **ASTROALIGN** is a python module that will try to align two stellar astronomical images, especially when there is no WCS information available.

  It does so by finding similar 3-point asterisms (triangles) in both images and deducing the affine transformation between them.

  Generic registration routines try to match feature points, using corner
  detection routines to make the point correspondence.
  These generally fail for stellar astronomical images, since stars have very
  little stable structure and so, in general, indistinguishable from each other.
  Asterism matching is more robust, and closer to the human way of matching stellar images.

  Astroalign can match images of very different field of view, point-spread function, seeing and atmospheric conditions.

  It may not work, or work with special care, on images of extended objects with few point-like sources or in very crowded fields.

  You can find a Jupyter notebook example with the main features at [http://quatrope.github.io/astroalign/](http://quatrope.github.io/astroalign/).

  **Full documentation:** https://astroalign.readthedocs.io/



  Install from PyPI

  ```bash
  $ pip install astroalign
  ```



  ```bash
  python tests/test_align.py
  ```

  or using pytest:

  ```bash
  pytest -v
  ```



  ```
  >>> import astroalign as aa
  >>> aligned_image, footprint = aa.register(source_image, target_image)
  ```

  In this example `source_image` will be interpolated by a transformation to coincide pixel to pixel with `target_image` and stored in `aligned_image`.

  If we are only interested in knowing the transformation and the correspondence of control points in both images, use `find_transform` will return the transformation in a [Scikit-Image](https://scikit-image.org/) `SimilarityTransform` object and a list of stars in source with the corresponding stars in target.

  ```
  >>> transf, (s_list, t_list) = aa.find_transform(source, target)
  ```

  `source` and `target` can each either be the numpy array of the image (grayscale or color),
  or an iterable of (x, y) pairs of star positions on the image.

  The returned `transf` object is a scikit-image [`SimilarityTranform`](http://scikit-image.org/docs/dev/api/skimage.transform.html#skimage.transform.SimilarityTransform) object that contains the transformation matrix along with the scale, rotation and translation parameters.

  `s_list` and `t_list` are numpy arrays of (x, y) point correspondence between `source` and `target`. `transf` applied to `s_list` will approximately render `t_list`.



  There are other related software that may offer similar functionality as astroalign.
  This list is not exhaustive and may be others.

  * [astrometry.net](https://github.com/dstndstn/astrometry.net)
  * [reproject](https://github.com/astropy/reproject)
  * [Watney Astrometry Engine](https://github.com/Jusas/WatneyAstrometry)
  * [Stellar Solver](https://github.com/rlancaste/stellarsolver)
  * [THRASTRO](https://github.com/THRASTRO/astrometrylib)
  * [Montage](https://github.com/Caltech-IPAC/Montage)
  * [Aafitrans](https://github.com/prajwel/aafitrans)
  * [astrometry](https://github.com/neuromorphicsystems/astrometry)



  If you use astroalign in a scientific publication, we would appreciate citations to the following [paper](https://www.sciencedirect.com/science/article/pii/S221313372030038X):

      Astroalign: A Python module for astronomical image registration.
      Beroiz, M., Cabral, J. B., & Sanchez, B.
      Astronomy & Computing, Volume 32, July 2020, 100384.

  ***

  <martinberoiz@gmail.com>

rpm_license:
  MIT License  Copyright (c) 2016-2019 Martin Beroiz  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: 955bdac641ee3ca3e6e506e52c415bf2e9db289e923fe8a48f34e1d80094b75f
name: python-astrobase
arch: src
version: 0.5.3
epoch: 0
release: 1
summary: Python modules and scripts useful for variable star work in astronomy.
url: https://github.com/waqasbhatti/astrobase
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrobase-0.5.3-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/75150575.svg)](https://zenodo.org/badge/latestdoi/75150575) [![Documentation Status](https://readthedocs.org/projects/astrobase/badge/?version=latest)](https://astrobase.readthedocs.io/en/latest/?badge=latest)

  Astrobase is a Python package for analyzing light curves and finding variable
  stars. It includes implementations of several period-finding algorithms, batch
  work drivers for working on large collections of light curves, and a small
  web-app useful for reviewing and classifying light curves by stellar variability
  type.

  Most functions in this package that deal with light curves usually require three
  Numpy ndarrays as input: `times`, `mags`, and `errs`, so they should work with
  any time-series data that can be represented in this form. If you have flux time
  series measurements, most functions also take a `magsarefluxes` keyword argument
  that makes them handle flux light curves correctly.

  - Read the docs: https://astrobase.readthedocs.io/en/latest/
  - Jupyter notebooks that demonstrate some of the functionality are available in
    the [astrobase-notebooks](https://github.com/waqasbhatti/astrobase-notebooks)
    repository.
  - A [overview](#contents) of the modules and subpackages is provided below.

  Install **[astrobase](https://pypi.org/project/astrobase/)** from the
  Python Package Index (PyPI):

  ```bash
  $ pip install numpy # needed to set up Fortran wrappers
  $ pip install astrobase
  ```

  See the [installation instructions](#installation) below for details. This
  package requires Python >= 3.5 as of version 0.5.0. Use `pip install
  astrobase<0.5.0` for older Python versions.

  Python 3.6: [![Python
  3.6](https://ci.wbhatti.org/buildStatus/icon?job=astrobase-py3)](https://ci.wbhatti.org/job/astrobase-py3)
  Python 3.7: [![Python
  3.7](https://ci.wbhatti.org/buildStatus/icon?job=astrobase-py37)](https://ci.wbhatti.org/job/astrobase-py37)
  Python 3.8: [![Python 3.8](https://ci.wbhatti.org/buildStatus/icon?job=astrobase-py38)](https://ci.wbhatti.org/job/astrobase-py38)
  Python 3.9: [![Python 3.9](https://ci.wbhatti.org/buildStatus/icon?job=astrobase-py39)](https://ci.wbhatti.org/job/astrobase-py39)



  - **[astrokep](https://astrobase.readthedocs.io/en/latest/astrobase.astrokep.html)**:
    contains functions for dealing with Kepler and K2 Mission light curves from
    STScI MAST (reading the FITS files, consolidating light curves for objects
    over quarters), and some basic operations (converting fluxes to mags,
    decorrelation of light curves, filtering light curves, and fitting object
    centroids for eclipse analysis, etc.)

  - **[astrotess](https://astrobase.readthedocs.io/en/latest/astrobase.astrotess.html)**:
    contains functions for dealing with TESS 2-minute cadence light curves from
    STScI MAST (reading the FITS files, consolidating light curves for objects
    over sectors), and some basic operations (converting fluxes to mags, filtering
    light curves, etc.)

  - **[checkplot](https://astrobase.readthedocs.io/en/latest/astrobase.checkplot.html)**:
    contains functions to make checkplots: a grid of plots used to quickly decide
    if a period search for a possibly variable object was successful. Checkplots
    come in two forms:

    Python pickles: If you want to interactively browse through large numbers of
    checkplots (e.g., as part of a large variable star classification project),
    you can use the `checkplotserver` webapp that works on checkplot pickle
    files. This interface allows you to review all phased light curves from all
    period-finder methods applied, set and save variability tags, object type
    tags, best periods and epochs, and comments for each object using a
    browser-based UI (see below). The information entered can then be exported as
    CSV or JSON for the next stage of a variable star classification pipeline.

    The
    [lightcurves-and-checkplots](https://nbviewer.jupyter.org/github/waqasbhatti/astrobase-notebooks/blob/master/lightcurves-and-checkplots.ipynb)
    Jupyter notebook outlines how to do this. A more detailed example using light
    curves of an arbitrary format is available in the
    [lc-collection-work](https://nbviewer.jupyter.org/github/waqasbhatti/astrobase-notebooks/blob/master/lc-collection-work.ipynb)
    notebook, which shows how to add in support for a custom LC format, add
    neighbor, cross-match, and color-mag diagram info to checkplots, and visualize
    these with the checkplotserver.

    ![Checkplot Server](https://raw.githubusercontent.com/waqasbhatti/astrobase/master/astrobase/data/checkplotserver.png)

    PNG images: Alternatively, if you want to simply glance through lots of
    checkplots (e.g. for an initial look at a collection of light curves), there's
    a `checkplot-viewer` webapp available that operates on checkplot PNG
    images. The
    [lightcurve-work](https://nbviewer.jupyter.org/github/waqasbhatti/astrobase-notebooks/blob/master/lightcurve-work.ipynb)
    Jupyter notebook goes through an example of generating these checkplot PNGs
    for light curves. See the
    [checkplot-viewer.js](https://github.com/waqasbhatti/astrobase/blob/master/astrobase/cpserver/checkplot-viewer.js) file for more
    instructions and [checkplot-viewer.png](https://raw.githubusercontent.com/waqasbhatti/astrobase/master/astrobase/data/checkplot-viewer.png)
    for a screenshot.

  - **[coordutils](https://astrobase.readthedocs.io/en/latest/astrobase.coordutils.html)**:
    functions for dealing with coordinates (conversions, distances, proper motion)

  - **[fakelcs](https://astrobase.readthedocs.io/en/latest/astrobase.fakelcs.html)**:
    modules and functions to conduct an end-to-end variable star recovery
    simulation.

  - **[hatsurveys](https://astrobase.readthedocs.io/en/latest/astrobase.hatsurveys.html)**:
    modules to read, filter, and normalize light curves from various HAT surveys.

  - **[lcfit](https://astrobase.readthedocs.io/en/latest/astrobase.lcfit.html)**:
    functions for fitting light curve models to observations, including
    sinusoidal, trapezoidal and full Mandel-Agol planet transits, eclipses, and
    splines.

  - **[lcmath](https://astrobase.readthedocs.io/en/latest/astrobase.lcmath.html)**: functions for light curve operations such
    as phasing, normalization, binning (in time and phase), sigma-clipping,
    external parameter decorrelation (EPD), etc.

  - **[lcmodels](https://astrobase.readthedocs.io/en/latest/astrobase.lcmodels.html)**:
    first order models for fast fitting (for the purposes of variable
    classification) to various periodic variable types, including sinusoidal
    variables, eclipsing binaries, transiting planets, and flares.

  - **[lcproc](https://astrobase.readthedocs.io/en/latest/astrobase.lcproc.html)**:
      driver functions for running an end-to-end pipeline including: (i) object
      selection from a collection of light curves by position, cross-matching to
      external catalogs, or light curve objectinfo keys, (ii) running variability
      feature calculation and detection, (iii) running period-finding, and (iv)
      object review using the checkplotserver webapp for variability
      classification.

  - **[periodbase](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.html)**: parallelized functions (using
    `multiprocessing.map`) to run fast period searches on light curves, including:
    the generalized Lomb-Scargle algorithm from Zechmeister & Kurster
    ([2008](http://adsabs.harvard.edu/abs/2009A%26A...496..577Z);
    **[periodbase.zgls](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.zgls.html)**), the phase dispersion
    minimization algorithm from Stellingwerf
    ([1978](http://adsabs.harvard.edu/abs/1978ApJ...224..953S),
    [2011](http://adsabs.harvard.edu/abs/2011rrls.conf...47S);
    **[periodbase.spdm](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.spdm.html)**), the AoV and
    AoV-multiharmonic algorithms from Schwarzenberg-Czerny
    ([1989](http://adsabs.harvard.edu/abs/1989MNRAS.241..153S),
    [1996](http://adsabs.harvard.edu/abs/1996ApJ...460L.107S);
    **[periodbase.saov](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.saov.html)**,
    **[periodbase.smav](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.smav.html)**), the BLS algorithm from
    Kovacs et al. ([2002](http://adsabs.harvard.edu/abs/2002A%26A...391..369K);
    **[periodbase.kbls](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.kbls.html)**
    and **[periodbase.abls](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.abls.html)**),
    the similar TLS algorithm from Hippke & Heller
    ([2019](https://ui.adsabs.harvard.edu/abs/2019A%26A...623A..39H/abstract);
    **[periodbase.htls](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.htls.html)**),
    and the ACF period-finding algorithm from McQuillan et al.
    ([2013a](http://adsabs.harvard.edu/abs/2013MNRAS.432.1203M),
    [2014](http://adsabs.harvard.edu/abs/2014ApJS..211...24M);
    **[periodbase.macf](https://astrobase.readthedocs.io/en/latest/astrobase.periodbase.macf.html)**).

  - **[plotbase](https://astrobase.readthedocs.io/en/latest/astrobase.plotbase.html)**: functions to plot light curves, phased
    light curves, periodograms, and download Digitized Sky Survey cutouts from the
    NASA SkyView service.

  - **[services](https://astrobase.readthedocs.io/en/latest/astrobase.services.html)**: modules and functions to query various
    astronomical catalogs and data services, including GAIA, SIMBAD, TRILEGAL,
    NASA SkyView, and 2MASS DUST.

  - **[timeutils](https://astrobase.readthedocs.io/en/latest/astrobase.timeutils.html)**: functions for converting from
    Julian dates to Baryocentric Julian dates, and precessing coordinates between
    equinoxes and due to proper motion; this will automatically download and save
    the JPL ephemerides **de430.bsp** from JPL upon first import.

  - **[varbase](https://astrobase.readthedocs.io/en/latest/astrobase.varbase.html)**:
    functions for calculating auto-correlation features, masking and pre-whitening
    periodic signals in light curves, and planet transit specific tools.

  - **[varclass](https://astrobase.readthedocs.io/en/latest/astrobase.varclass.html)**: functions for calculating various
    variability, stellar color and motion, and neighbor proximity features, along
    with a Random Forest based classifier.




  Please see https://github.com/waqasbhatti/astrobase/blob/master/CHANGELOG.md for
  a list of changes applicable to tagged release versions.






  This package requires the following other packages:

  - numpy
  - scipy
  - astropy
  - matplotlib
  - Pillow
  - jplephem
  - requests
  - tornado
  - pyeebls
  - tqdm
  - scikit-learn

  For optional functionality, some additional packages are required:

  - for `astrobase.lcdb` to work, you'll need `psycopg2-binary`.
  - for `lcfit.transits.mandelagol_fit_magseries`, you'll need `batman-package`,
    `emcee`, `corner`, and `h5py`.
  - for `lcproc.awsrun`, you'll need `paramiko`, `boto3`, and `awscli`.
  - for `periodbase.tls`, you'll need `transitleastsquares`



  If you're using:

  - 64-bit Linux and Python 2.7, 3.4, 3.5, 3.6, 3.7
  - 64-bit Mac OSX 10.12+ with Python 2.7 or 3.6
  - 64-bit Windows with Python 2.7 and 3.6

  You can simply install astrobase with:

  ```bash

  (venv)$ pip install astrobase
  ```

  Otherwise, you'll need to make sure that a Fortran compiler and numpy are
  installed beforehand to compile the pyeebls package that astrobase depends on:

  ```bash







  (venv)$ pip install numpy # in a virtualenv

  ```

  Once that's done, install astrobase.

  ```bash
  (venv)$ pip install astrobase
  ```



  Install all the optional dependencies as well:

  ```bash
  (venv)$ pip install astrobase[all]
  ```

  Install the latest version (may be unstable at times):

  ```bash
  $ git clone https://github.com/waqasbhatti/astrobase
  $ cd astrobase
  $ python setup.py install
  $ # or use pip install . to install requirements automatically
  $ # or use pip install -e . to install in develop mode along with requirements
  $ # or use pip install -e .[all] to install in develop mode along with all requirements
  ```



  `astrobase` is provided under the MIT License. See the LICENSE file for the full
  text.


pkgId: 6ef9674648d0e4521e36a470f4b661e13fe08a3bfb1d5d9b41533510116300d9
name: python-astrobasecloud
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: astrobase
url: https://pypi.org/project/astrobasecloud/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrobasecloud-0.2.4-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://docs.astrobase.cloud" target="_blank">https://docs.astrobase.cloud</a>


pkgId: ffe4286858a57a5f1dd76e4a97fceb07a02a1cb946ea309dde2bb670f3a08800
name: python-astrobox
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: The package allows you to create Astro Robo Game for programmers.
url: https://github.com/suguby/astrobox
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrobox-1.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/suguby/astrobox.svg?branch=master)](https://travis-ci.org/suguby/astrobox)
  [![PyPi version](https://pypip.in/version/astrobox/badge.png)](https://pypi.python.org/pypi/astrobox/)



  AstroBox game for programmers.

  ![screenshot one](screenshots/game_begin.png "Game Begin")​


pkgId: a95c04c0280a1de98bf5669ada5764876996d0cd3e14b3d64d6f333051670a96
name: python-astrocalc
arch: src
version: 0.4.2
epoch: 0
release: 1
url: https://github.com/thespacedoctor/astrocalc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrocalc-0.4.2-1.src.rpm
checksum_type: sha256
summary:
  perform common astronomy-related calculations, conversions and measurements within python scripts or from the command-line

description:
  <!-- INFO BADGES -->

  [![](https://img.shields.io/pypi/pyversions/astrocalc)](https://pypi.org/project/astrocalc/)
  [![](https://img.shields.io/pypi/v/astrocalc)](https://pypi.org/project/astrocalc/)
  [![](https://img.shields.io/github/license/thespacedoctor/astrocalc)](https://github.com/thespacedoctor/astrocalc)
  [![](https://img.shields.io/pypi/dm/astrocalc)](https://pypi.org/project/astrocalc/)

  <!-- STATUS BADGES -->

  [![](http://157.245.42.153:8080/buildStatus/icon?job=astrocalc%2Fmaster&subject=build%20master)](http://157.245.42.153:8080/blue/organizations/jenkins/astrocalc/activity?branch=master)
  [![](http://157.245.42.153:8080/buildStatus/icon?job=astrocalc%2Fdevelop&subject=build%20dev)](http://157.245.42.153:8080/blue/organizations/jenkins/astrocalc/activity?branch=develop)
  [![](https://cdn.jsdelivr.net/gh/thespacedoctor/astrocalc@master/coverage.svg)](https://raw.githack.com/thespacedoctor/astrocalc/master/htmlcov/index.html)
  [![](https://readthedocs.org/projects/astrocalc/badge/?version=master)](https://astrocalc.readthedocs.io/en/master/)
  [![](https://img.shields.io/github/issues/thespacedoctor/astrocalc/type:%20bug?label=bug%20issues)](https://github.com/thespacedoctor/astrocalc/issues?q=is%3Aissue+is%3Aopen+label%3A%22type%3A+bug%22+)

  *perform common astronomy-related calculations, conversions and measurements within python scripts or from the command-line*.

  Documentation for astrocalc is hosted by [Read the Docs](https://astrocalc.readthedocs.io/en/master/) (
  [development version](https://astrocalc.readthedocs.io/en/develop/) and [master version](https://astrocalc.readthedocs.io/en/master/)). The code lives on [github](https://github.com/thespacedoctor/astrocalc). Please report any issues you find [here](https://github.com/thespacedoctor/astrocalc/issues).



  *


pkgId: 39b61a0993fa982537d85ec61ed46f4201178294d8988e8ff69b77a177275f89
name: python-astroconst
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: A Python package that provides astronomical constants.
url: https://pypi.org/project/astroconst/
rpm_license: EUPL 1.2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroconst-0.0.12-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/astroconst?color=%230A0) ![PyPI -
  Downloads](https://img.shields.io/pypi/dm/astroconst) [![Documentation
  Status](https://readthedocs.org/projects/astroconst/badge/?version=latest)](https://astroconst.readthedocs.io/en/latest/?badge=latest)
  ![PyPI - License](https://img.shields.io/pypi/l/astroconst?color=%230A0)

  A Python package that provides astronomical constants.
  The code is being developed by [Marc van der Sluys](http://marc.vandersluys.nl) of the department of
  Astrophysics at the Radboud University Nijmegen, the Institute of Nuclear and High-Energy Physics (Nikhef),
  and the Institute for Gravitational and Subatomic Physics (GRASP) at Utrecht University, all in The
  Netherlands.  The AstroConst package can be used under the conditions of the
  [EUPL 1.2](https://www.eupl.eu/1.2/en/) licence.

  Note that the package is currently is its alpha stage, and things may still change as I start using this.




  This package can be installed using `pip install astroconst`.  This should automatically install the
  dependency package `numpy`, if it has't been installed already.  If you are installing by hand, ensure that
  this package is installed as well.




  SI units should be used everywhere - no ergs, dyn or cm (sorry!).  Values include mathematical constants (like
  &pi;), angle-conversion factors (from/to radians, degrees, hours, arcseconds, ...), calendar stuff (names of
  weekdays and months, JDs, lengths of days, months and years), solar-system objects (Sun, Moon, planet
  names diameters, orbital separations, etc. - note that Moon = planet #0), and some basic physical constants
  ((Stefan-)Bolzmann, Planck, speed of light, etc.).

  The submodule `aa` contains constants published by the Astronomical Almanac, converted to Python.


  ```python
  """Example Python script using the AstroConst package."""

  import astroconst as ac

  print(ac.c)     # 299792458 (speed of light, quick access)
  print(ac.aa.c)  # Access constants from Astronomical Almanac

  print(ac.jd2000)  # 2451545
  print(ac.m_sun)  # 1.9891e+30 (kg)
  print(ac.sol_const)  # 1361.5 (W/m2)

  print(ac.year_jul)  # 31557600.0 (s)
  print(ac.year_jul/ac.day)  # 365.25 (days)
  print(ac.month_syn/ac.day)  # 29.530588853 (days)

  print('The diameter of '+ac.plname_en[5]+' is '+str(ac.pl_d[5]/ac.km)+' km')


  print('a_'+ac.plname_en[0]+' = '+str(ac.pl_a[0]/ac.km)+' km')


  print(ac.dow_en_abr[0])  # Sun
  print(ac.months_en[3])  # March
  ```




  * [Pypi](https://pypi.org/project/astroconst/): AstroConst Python package
  * [GitHub](https://github.com/MarcvdSluys/AstroConst/): AstroConst source code
  * [ReadTheDocs](https://astroconst.readthedocs.io/): AstroConst documentation




  * Author: Marc van der Sluys
  * Contact: http://marc.vandersluys.nl
  * Licence: [EUPL 1.2](https://www.eupl.eu/1.2/en/)




  * [The Astronomical Almanac Online!](http://asa.hmnao.com/SecK/Constants.html)


  <sub>Copyright (c) 2022 Marc van der Sluys</sub>


pkgId: 7aa1cf583a3dd4050737c6e04c1b7c6c71051363a71bda9bd23fbbde6511f427
name: python-astrocut
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Cutout tools for astronomical images
url: https://astrocut.readthedocs.io
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrocut-0.11.1-1.src.rpm
checksum_type: sha256
description:
  Astrocut provides tools for making cutouts from sets of astronomical images with shared footprints. It is under active development.
  Three main areas of functionality are included:
  - Solving the specific problem of creating image cutouts from sectors of Transiting Exoplanet Survey Satellite (TESS) full-frame images.
  - General fits file cutouts including from single images and sets of images with the shared WCS/pixel scale.
  - Cutout post-processing functionality, including centering cutouts along a path (for moving targets) and combining cutouts.
  Documentation is at https://astrocut.readthedocs.io.


pkgId: 4512ddec1477e1c9481330328448e59e396f51e7c1babdf1ff88e5b529ed2bcc
name: python-astrodata
arch: src
version: 2.10.0
epoch: 0
release: 1
summary: A package for managing astronomical data through a uniform interface
url: https://github.com/GeminiDRSoftware/astrodata/
rpm_license: BSD3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrodata-2.10.0-1.src.rpm
checksum_type: sha256
description:
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="docs/static/logo.svg">
    <img
    alt="A logo of a stylized blue dragon inside a similarly blue shell. A yellow star lies at the center, together with the dragon shape forming a stylized letter A."
    src="docs/static/logo_dark.svg"
    align="left"
    height=200
    style="padding-right: 10; padding-bottom: 10; border: none;"
    >
  </picture>
  [![Project Status: Active – The project has reached a stable, usable state and is being actively developed.](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
  ![Supported python versions -- 3.10, 3.11, and 3.12](https://img.shields.io/badge/3.10|3.11|3.12-%234b8bbe?logo=Python&logoColor=%234b8bbe&label=For%20Python%3A)
  [![PyPI version badge][pypi package version badge]](https://badge.fury.io/py/astrodata)

  ![A badge displaying the testing coverage percentage of this repository.][coverage badge]
  ![Source test status badge][source test status badge]
  ![Build/Release test status badge][build test status badge]

  ![Documentation build status badge][docs build badge]
  ![pypi packaging status badge][pypi packaging badge]
  <!-- Clearing the logo for the next header -->
  <br clear="left">


pkgId: 428517e3ac477d0274409c93de84551f05f801462dd17caa4d45ab1fddc2ba6b
name: python-astrodbkit2
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Astronomical database handler code
url: https://pypi.org/project/astrodbkit2/
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrodbkit2-0.6.0-1.src.rpm
checksum_type: sha256
description:
  AstrodbKit2 is an astronomical database handler code built on top of SQLAlchemy.
  This is built to work with the `SIMPLE database <https://github.com/SIMPLE-AstroDB/SIMPLE-db>`_, though
  similarly constructed databases will work.
  Documentation is available at `https://astrodbkit2.readthedocs.io/en/latest/ <https://astrodbkit2.readthedocs.io/en/latest/>`_


pkgId: a2979440f7b95a67d77ddf5a18919ba5d7b440ccba5954a70a010b5ca213823e
name: python-astrodendro
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Python package for computation of astronomical dendrograms
url: https://pypi.org/project/astrodendro/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrodendro-0.3.1-1.src.rpm
checksum_type: sha256
description:
  The aim of this module is to provide an easy way to compute dendrograms of observed or simulated Astronomical data in Python


pkgId: 66767be06a7976fd8c892ffdd1517261064c356ba27493e014d57e8ddf6d4b88
name: python-astrodown
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: A framework for creating shareable data science websites
url: https://pypi.org/project/astrodown/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrodown-0.1.16-1.src.rpm
checksum_type: sha256
description:
  [bold blue]Astrodown[/bold blue] is a toolkit to build interactive websites for data science projects.

  See a live example at https://astrodown-playground.qiushiyan.dev :sparkles:

  **Usage**:

  ```console
  $ astrodown [OPTIONS] COMMAND [ARGS]...
  ```

  **Options**:

  * `--install-completion`: Install completion for the current shell.
  * `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
  * `--help`: Show this message and exit.


      Report [bold red]bugs[/bold red] on [link=https://github.com/astrodown/astrodown-web/]Github[/link]


  **Commands**:

  * `check`: Check for availabilities of programs...
  * `dev`: [bold blue]Preivew[/bold blue] the website
  * `docs`: [bold blue]Open[/bold blue] documentation...
  * `init`: [bold blue]Create[/bold blue] an astrodown...
  * `install`: [bold blue]Install[/bold blue] JavaScript...
  * `new`: [bold blue]Create[/bold blue] the folder...
  * `render`: [bold blue]Render[/bold blue] all Quarto...



  Check for availabilities of programs required by astrodown

  **Usage**:

  ```console
  $ astrodown check [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  [bold blue]Preivew[/bold blue] the website

  **Usage**:

  ```console
  $ astrodown dev [OPTIONS]
  ```

  **Options**:

  * `--package-manager [npm|yarn|pnpm]`: package manager to use  [default: PackageManager.npm]
  * `--port INTEGER`: port to run the website  [default: 3000]
  * `--render-quarto / --no-render-quarto`: rerender quarto documents first  [default: no-render-quarto]
  * `--help`: Show this message and exit.



  [bold blue]Open[/bold blue] documentation websites for relevant tools, e.g. Quarto, Python, etc.

  **Usage**:

  ```console
  $ astrodown docs [OPTIONS]
  ```

  **Options**:

  * `--help`: Show this message and exit.



  [bold blue]Create[/bold blue] an astrodown project.

  Must have Quarto Node.js installed and avaiable in PATH variables, use `astrodown check` for health checks.

  **Usage**:

  ```console
  $ astrodown init [OPTIONS]
  ```

  **Options**:

  * `-p, --path TEXT`: path to create the project, default to the current working directory  [default: /Users/qiushi/workspace/astrodown/astrodown-python]
  * `-n, --name TEXT`: name of the project
  * `-pm, --package-manager [npm|yarn|pnpm]`: package manager to use, default to npm  [default: npm]
  * `-t, --template [basic|full]`: template to use, default to basic  [default: basic]
  * `--help`: Show this message and exit.



  [bold blue]Install[/bold blue] JavaScript dependencies.

  Only need to be run once per project.

  **Usage**:

  ```console
  $ astrodown install [OPTIONS]
  ```

  **Options**:

  * `--package-manager [npm|yarn|pnpm]`: package manager to use  [default: PackageManager.npm]
  * `--help`: Show this message and exit.



  [bold blue]Create[/bold blue] the folder structure for a new analysis, dataset, model, api, etc.

  **Usage**:

  ```console
  $ astrodown new [OPTIONS] COMPONENT_TYPE:{analysis|dataset|model|shinyapp|api}
  ```

  **Arguments**:

  * `COMPONENT_TYPE:{analysis|dataset|model|shinyapp|api}`: the type of the component to be created  [required]

  **Options**:

  * `--help`: Show this message and exit.



  [bold blue]Render[/bold blue] all Quarto documents.

  Should be run every time a Quarto document has changed. Edit _quarto.yml to include/exclude files.

  **Usage**:

  ```console
  $ astrodown render [OPTIONS]
  ```

  **Options**:

  * `--package-manager [npm|yarn|pnpm]`: package manager to use  [default: PackageManager.npm]
  * `--help`: Show this message and exit.


pkgId: fdc359949708c65051036e79383fcfb3611b5b4157468d7694d36e9e51e24fde
name: python-astroemperor
arch: src
version: 0.8.7
epoch: 0
release: 1
summary: PTMCMC sampler for exoplanet search
url: https://pypi.org/project/astroemperor/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroemperor-0.8.7-1.src.rpm
checksum_type: sha256
description:
  This is ReddTea's small package compiling useful self-made functions for an astrophysical context.


  Reddutils contains many functions and classes for personal use.
  Some of them may be of use for the community.



  This code makes use of:
    - Numpy
    - pandas
    - Scipy
    - PyAstronomy (http://www.hs.uni-hamburg.de/DE/Ins/Per/Czesla/PyA/PyA/index.html)
    - tqdm (https://pypi.python.org/pypi/tqdm)
    - tabulate
    - matplotlib.pyplot
    - ipywidgets
    - IPython.display

  Most of them come with conda, if some are missing they can be easily installed with pip.



  In the console type in your work folder
  ```sh
  pip install reddutils
  ```




  For a pandas dataframe or three-column table:
  ```sh
  from reddutils import correlator as rc
  import pandas as pd

  df = pd.read_csv('data.csv')

  cor = rc.correlator()
  cor.display(df)
  ```
  ![correlator](https://user-images.githubusercontent.com/14165443/185804943-5011ccb0-2dff-4d20-a443-8407518b96e5.png)



  Use for visualising the NASA Exoplanet Archive:

  ```sh
  from reddutils import exodus


  exopop = exodus.Exoplanet_Archive('NasaExoplanetArchive')



  exopop.display()
  ```
  ![exodus](https://user-images.githubusercontent.com/14165443/185804945-e6753a05-5750-4d00-96fe-657825c39fa1.png)

  Try out the histogram mode:

  ```sh
  exopop.display_hist()
  ```


  For visualising fourier transforms and the nyquist limit.

  ```sh
  from reddutils import fourier

  fou = fourier.fourier()
  fou.display()
  ```
  ![fourier](https://user-images.githubusercontent.com/14165443/185804946-50b5661a-3a1e-46b7-92a6-a2dcf0d489cd.png)



  For a pandas dataframe:
  ```sh
  from reddutils import periodogram as rp
  import pandas as pd

  df = pd.read_csv('data.csv')

  per = rp.LSP()
  per.display(df)
  ```
  ![periodogram](https://user-images.githubusercontent.com/14165443/185804947-ce3b2e0e-2019-424d-9f17-bcb3a3ad144d.png)


pkgId: 36b3a261880ec0d11e35f5f2007af1037a8e045bd8fbe28007ec0d9e93da5730
name: python-astrohack
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Holography Antenna Commissioning Kit
url: https://pypi.org/project/astrohack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrohack-0.5.5-1.src.rpm
checksum_type: sha256
description:
  ![astrohack](docs/_media/astrohack_logo.png)

  [![Python 3.9 3.10 3.11](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11-blue)](https://www.python.org/downloads/release/python-380/)
  ![Linux Tests](https://github.com/casangi/astrohack/actions/workflows/python-testing-linux.yml/badge.svg)
  ![macOS Tests](https://github.com/casangi/astrohack/actions/workflows/python-testing-macos.yml/badge.svg)
  ![Published](https://github.com/casangi/astrohack/actions/workflows/pythonpublish.yml/badge.svg)
  [![Documentation Status](https://readthedocs.org/projects/astrohack/badge/?version=stable)](https://astrohack.readthedocs.io/en/stable/?badge=stable)

  astroHack (Holography Antenna Commissioning Kit) is a Python package under development by NRAO's [CASA](https://casa.nrao.edu) team to support holography and antenna position correction measurements. It currently supports pointed and on-the-fly holographies for both ALMA and the VLA as well as antenna position corrections for the VLA. The future goal of astrohack is to support the commissioning of the Next Generation Very Large Array (ngVLA). Much of the core functionality of astroHACK is inspired by the code of the following AIPS tasks: UVHOL, HOLOG and PANEL for holography and LOCIT for the antenna position corrections. AstroHACK enables parallel execution by using Dask and efficient single-threaded performance by making use of Numba.

  > 📝 astroHACK is under active development! Breaking API changes are still happening on a regular basis, so proceed with caution.


  It is recommended to use the [conda](https://docs.conda.io/projects/conda/en/latest/) environment manager to create a clean, self-contained runtime where astrohack and all its dependencies can be installed:
  ```sh
  conda create --name astrohack python=3.11 --no-default-packages
  conda activate astrohack

  ```
  > 📝 On macOS it is required to pre-install `python-casacore` using `conda install -c conda-forge python-casacore`.

  Making astroHACK available for download from conda-forge directly is pending, so until then the current recommendation is to sully that pristine environment by calling pip [from within conda](https://www.anaconda.com/blog/using-pip-in-a-conda-environment), like this:
  ```sh
  pip install astrohack
  ```



  Besides the API for the user facing functions there are three tutorials that can be followed that demonstrate the capabilities of astrohack:
  - [VLA Holography tutorial](https://astrohack.readthedocs.io/en/stable/tutorial_vla.html)
  - [Holography visualization tutorial](https://astrohack.readthedocs.io/en/stable/visualization_tutorial.html)
  - [Antenna position correction tutorial](https://astrohack.readthedocs.io/en/stable/locit_tutorial.html)


pkgId: 90d7e62262ef4819a836e39830aa317bb19ef203eefdf95479f8bd068c1d9972
name: python-astroid
arch: src
version: 3.3.2
epoch: 0
release: 1
summary: An abstract syntax tree for Python with inference support.
url: https://pypi.org/project/astroid/
rpm_license: LGPL-2.1-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroid-3.3.2-1.src.rpm
checksum_type: sha256
description:
     * - |tidelift_logo|
       - Professional support for astroid is available as part of the
         `Tidelift Subscription`_.  Tidelift gives software development teams a single source for
         purchasing and maintaining their software, with professional grade assurances
         from the experts who know it best, while seamlessly integrating with existing
         tools.


pkgId: a583204f8b2ab2bc7ac3fa767079f9a4723af5672faa6343f4d5c26eab59c1e2
name: python-astromartini
arch: src
version: 2.1.7
epoch: 0
release: 1
summary: Synthetic datacube creation from simulations.
url: https://github.com/kyleaoman/martini
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astromartini-2.1.7-1.src.rpm
checksum_type: sha256
description:
  MARTINI is a modular package for the creation of synthetic resolved HI line observations (data cubes) of smoothed-particle hydrodynamics simulations of galaxies. The various aspects of the mock-observing process are divided logically into sub-modules handling the data cube, source, beam, noise, spectral model and SPH kernel. MARTINI is object-oriented: each sub-module provides a class (or classes) which can be configured as desired. For most sub-modules, base classes are provided to allow for straightforward customization. Instances of each sub-module class are given as parameters to the Martini class; a mock observation is then constructed by calling a handful of functions to execute the desired steps in the mock-observing process.
  Full documentation_ can be found on ReadTheDocs.


pkgId: 984523c470bcd15206f8a6fab8a3ba26f1b84863fad901d662beeb601cf9d11b
name: python-astromorphlib
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Python scripts to analyze the morphology of isolated/interacting galaxies
url: https://gitlab.com/joseaher/astromorphlib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astromorphlib-1.0.10-1.src.rpm
checksum_type: sha256
description:
  ![alt text](docs/_static/logo.png)



  Python scripts to analyze the morphology of isolated and interacting galaxies.
  The package is designed to download S-PLUS (https://splus.cloud/),
  Legacy (https://www.legacysurvey.org) and SDSS (https://www.sdss4.org/dr17/imaging)
  images automatically. There are functions
  to calculate a 2D sky background of the images and deblended segmentation maps of
  interacting systems with merger isophotes. The non-parametric analysis is
  performed by using `statmorph` package (https://github.com/vrodgom/statmorph).
  The user can study the environment of the object/system by downloading a list of
  the galaxies within Field-of-View of S-PLUS/Legacy images from SIMBAD server
  (http://simbad.u-strasbg.fr/simbad/). In addition, there is a function to
  display DSS2 (http://alasky.u-strasbg.fr/hips-image-services/hips2fits) images
  of any size.

  :sparkles: Website: https://gitlab.com/joseaher/astromorphlib



  The documentation is available at https://astromorphlib.readthedocs.io




  :sparkles: The latest version of `astromorphlib` is [1.0.10](https://pypi.org/project/astromorphlib/)


  **Requirements**

  "astromorphlib" requires to run the following packages:

      * statmorph
      * splusdata
      * astro-datalab
      * astroplotlib
      * astropy
      * astroquery
      * photutils (1.5.0 <)**
      * numpy
      * scipy
      * matplotlib
      * wget

  ** to install this specific version of photutils you can try:

      % pip install photutils==1.5.0


  This version can be easily installed via PyPI (https://pypi.org/project/astromorphlib/):

      % pip install astromorphlib

  If you prefer to install "astromorphlib" manually, you can clone the developing
  version at https://gitlab.com/joseaher/astromorphlib. In the directory this
  README is in, simply type:

      % pip install .

  or,

      % python setup.py install



  To uninstall "astromorphlib", just type:

      % pip uninstall astromorphlib



  - [Krabbe & Hernandez-Jimenez et al. (2024)](https://ui.adsabs.harvard.edu/abs/2024MNRAS.528.1125K/abstract).
       In this paper Astromorphlib was applied to study ram-pressure stripped candidates.



  - Jose Hernandez-Jimenez (joseaher@gmail.com)
  - Angela Krabbe

  **Acknowledgements**

  This software was funded partially by Brazilian agency FAPESP,
  process number 2021/08920-8.



  If you use this code for a scientific publication, please
  cite [Hernandez-Jimenez & Krabbe et al. (2022)](https://zenodo.org/records/6940848) and [Krabbe & Hernandez-Jimenez et al. (2024)](https://ui.adsabs.harvard.edu/abs/2024MNRAS.528.1125K/abstract).
  The BibTeX entries for this package are:

  ```
  @MISC{hernandez_jimenez_2022,
    author       = {Hernandez-Jimenez, J. A. and
                    Krabbe, A. C.},
    title        = {{Astromorphlib: Python scripts to analyze the
                     morphology of isolated and interacting galaxies}},
    month        = jul,
    year         = 2022,
    publisher    = {Zenodo},
    version      = {0.2},
    url          = {https://doi.org/10.5281/zenodo.6940848},
    doi          = {10.5281/zenodo.6940848}
  }

  @ARTICLE{2024MNRAS.528.1125K,
         author = {{Krabbe}, A.~C. and {Hernandez-Jimenez}, J.~A. and {Mendes de Oliveira}, C. and {Jaffe}, Y.~L. and {Oliveira}, C.~B. and {Cardoso}, N.~M. and {Smith Castelli}, A.~V. and {Dors}, O.~L. and {Cortesi}, A. and {Crossett}, J.~P.},
          title = "{Diagnostic diagrams for ram pressure stripped candidates}",
        journal = {\mnras},
       keywords = {galaxies: clusters: general, galaxies: clusters: intracluster medium, galaxies: evolution, galaxies: interactions, galaxies: irregular, galaxies: structure, Astrophysics - Astrophysics of Galaxies},
           year = 2024,
          month = feb,
         volume = {528},
         number = {2},
          pages = {1125-1141},
            doi = {10.1093/mnras/stad3881},
  archivePrefix = {arXiv},
         eprint = {2312.09220},
   primaryClass = {astro-ph.GA},
         adsurl = {https://ui.adsabs.harvard.edu/abs/2024MNRAS.528.1125K},
        adsnote = {Provided by the SAO/NASA Astrophysics Data System}
  }
  ```


pkgId: 1dc7af9c19790ee765b44b577d147c6e86dc83fc0b34072239f186b0e616ed46
name: python-astronomer-cosmos
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Orchestrate your dbt projects in Airflow
url: https://github.com/astronomer/astronomer-cosmos
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astronomer-cosmos-1.6.0-1.src.rpm
checksum_type: sha256
description:
  |fury| |ossrank| |downloads| |pre-commit|
  Run your dbt Core projects as `Apache Airflow® <https://airflow.apache.org/>`_ DAGs and Task Groups with a few lines of code. Benefits include:
  - Run dbt projects against Airflow connections instead of dbt profiles
  - Native support for installing and running dbt in a virtual environment to avoid dependency conflicts with Airflow
  - Run tests immediately after a model is done to catch issues early
  - Utilize Airflow's data-aware scheduling to run models immediately after upstream ingestion
  - Turn each dbt model into a task/task group complete with retries, alerting, etc.
  Quickstart
  __________
  Check out the Getting Started guide on our `docs <https://astronomer.github.io/astronomer-cosmos/getting_started/index.html>`_. See more examples at `/dev/dags <https://github.com/astronomer/astronomer-cosmos/tree/main/dev/dags>`_ and at the `cosmos-demo repo <https://github.com/astronomer/cosmos-demo>`_.
  Example Usage
  ___________________
  You can render a Cosmos Airflow DAG using the ``DbtDag`` class. Here's an example with the `jaffle_shop project <https://github.com/dbt-labs/jaffle_shop>`_:
     This renders on Github but not Sphinx:
  https://github.com/astronomer/astronomer-cosmos/blob/24aa38e528e299ef51ca6baf32f5a6185887d432/dev/dags/basic_cosmos_dag.py#L1-L42
  This will generate an Airflow DAG that looks like this:
  Community
  _________
  - Join us on the Airflow `Slack <https://join.slack.com/t/apache-airflow/shared_invite/zt-1zy8e8h85-es~fn19iMzUmkhPwnyRT6Q>`_ at #airflow-dbt
  Changelog
  _________
  We follow `Semantic Versioning <https://semver.org/>`_ for releases.
  Check `CHANGELOG.rst <https://github.com/astronomer/astronomer-cosmos/blob/main/CHANGELOG.rst>`_
  for the latest changes.
  Contributing Guide
  __________________
  All contributions, bug reports, bug fixes, documentation improvements, enhancements are welcome.
  A detailed overview an how to contribute can be found in the `Contributing Guide <https://astronomer.github.io/astronomer-cosmos/contributing>`_.
  As contributors and maintainers to this project, you are expected to abide by the
  `Contributor Code of Conduct <https://github.com/astronomer/astronomer-cosmos/blob/main/CODE_OF_CONDUCT.md>`_.
  License
  _______
  `Apache License 2.0 <https://github.com/astronomer/astronomer-cosmos/blob/main/LICENSE>`_


pkgId: 818cde3be8c52d043e551563d45cb2a43269a1a44c632ac64a4490b4e9f78c34
name: python-astronomer-cosmos
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Orchestrate your dbt projects in Airflow
url: https://github.com/astronomer/astronomer-cosmos
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astronomer-cosmos-1.7.0-1.src.rpm
checksum_type: sha256
description:
  |fury| |ossrank| |downloads| |pre-commit|
  Run your dbt Core projects as `Apache Airflow® <https://airflow.apache.org/>`_ DAGs and Task Groups with a few lines of code. Benefits include:
  - Run dbt projects against Airflow connections instead of dbt profiles
  - Native support for installing and running dbt in a virtual environment to avoid dependency conflicts with Airflow
  - Run tests immediately after a model is done to catch issues early
  - Utilize Airflow's data-aware scheduling to run models immediately after upstream ingestion
  - Turn each dbt model into a task/task group complete with retries, alerting, etc.
  Quickstart
  __________
  Check out the Getting Started guide on our `docs <https://astronomer.github.io/astronomer-cosmos/getting_started/index.html>`_. See more examples at `/dev/dags <https://github.com/astronomer/astronomer-cosmos/tree/main/dev/dags>`_ and at the `cosmos-demo repo <https://github.com/astronomer/cosmos-demo>`_.
  Example Usage
  ___________________
  You can render a Cosmos Airflow DAG using the ``DbtDag`` class. Here's an example with the `jaffle_shop project <https://github.com/dbt-labs/jaffle_shop>`_:
     This renders on Github but not Sphinx:
  https://github.com/astronomer/astronomer-cosmos/blob/24aa38e528e299ef51ca6baf32f5a6185887d432/dev/dags/basic_cosmos_dag.py#L1-L42
  This will generate an Airflow DAG that looks like this:
  Community
  _________
  - Join us on the Airflow `Slack <https://join.slack.com/t/apache-airflow/shared_invite/zt-1zy8e8h85-es~fn19iMzUmkhPwnyRT6Q>`_ at #airflow-dbt
  Changelog
  _________
  We follow `Semantic Versioning <https://semver.org/>`_ for releases.
  Check `CHANGELOG.rst <https://github.com/astronomer/astronomer-cosmos/blob/main/CHANGELOG.rst>`_
  for the latest changes.
  Contributing Guide
  __________________
  All contributions, bug reports, bug fixes, documentation improvements, enhancements are welcome.
  A detailed overview an how to contribute can be found in the `Contributing Guide <https://astronomer.github.io/astronomer-cosmos/contributing>`_.
  As contributors and maintainers to this project, you are expected to abide by the
  `Contributor Code of Conduct <https://github.com/astronomer/astronomer-cosmos/blob/main/CODE_OF_CONDUCT.md>`_.
  License
  _______
  `Apache License 2.0 <https://github.com/astronomer/astronomer-cosmos/blob/main/LICENSE>`_
  Privacy Notice
  ______________
  This project follows `Astronomer's Privacy Policy <https://www.astronomer.io/privacy/>`_


pkgId: 833ead92366448dbca6b9b805256a12fb6268fee0de133c1d38be8dcee961e7f
name: python-astronomer-orbiter
arch: src
version: 1.3.2
epoch: 0
release: 1
url: https://astronomer.io
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astronomer-orbiter-1.3.2-1.src.rpm
checksum_type: sha256
summary:
  Astronomer Orbiter can take your legacy workloads and land them safely down in a new home on Apache Airflow!

description:
  <!--suppress HtmlDeprecatedAttribute -->
  <p align="center">
    <img
      width="200px" height="200px"
      src="https://raw.githubusercontent.com/astronomer/orbiter/main/docs/orbiter.svg"
      alt="Logo of Spaceship Orbiting a Planet"
    />
  </p>
  <p align="center">
    <b>Astronomer Orbiter</b> can land legacy workloads safely down in a new home on Apache Airflow!
  </p>



  `orbiter` is a framework and CLI that runs on your workstation and converts workflow definitions from other tools to Airflow Projects.

  [Read more at the official documentation!](https://astronomer.github.io/orbiter)


  Orbiter logo [by Ivan Colic](https://thenounproject.com/Ivanisawesome/) used with permission
  from [The Noun Project](https://thenounproject.com/icon/lunar-orbiter-196219/)
  under [Creative Commons](https://creativecommons.org/licenses/by/3.0/us/legalcode).

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


pkgId: 43fda3efc60d5320d7b590f71cbb0a8f2b14e8d501909f4935c6a06ecf759e79
name: python-astronomer-providers
arch: src
version: 1.19.4
epoch: 0
release: 1
summary: Apache Airflow Providers containing Deferrable Operators & Sensors from Astronomer
url: https://astronomer.io/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astronomer-providers-1.19.4-1.src.rpm
checksum_type: sha256
description:
      The majority of operators and sensors within this repository have been deprecated and will not receive further updates.
      Read more about the deprecation in the `Deprecation Notice` section below.


pkgId: af4d8a90930d7b0c365db58c7d4ea09a2fd9b2eeeb3a2661d5661e8fb1a12af6
name: python-astronomer-starship
arch: src
version: 2.0.6
epoch: 0
release: 1
summary: Migrations to Astro
url: https://astronomer.io
rpm_license: PROPRIETARY
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astronomer-starship-2.0.6-1.src.rpm
checksum_type: sha256
description:
  **Artwork**
  Starship logo [by Lorenzo](https://thenounproject.com/lorenzo.verdenelli/) used with permission
  from [The Noun Project](https://thenounproject.com/icon/starship-6088295/)
  under [Creative Commons](https://creativecommons.org/licenses/by/3.0/us/legalcode).


pkgId: d12ceb27f3f79eb28f406e9516026b9789c18de0b26c14b2d364ec46f96e05b7
name: python-astronomia
arch: src
version: 3.0.2
epoch: 0
release: 1
summary: Library for calculation of ephemeris and other astronomical calculations
url: https://pypi.org/project/astronomia/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astronomia-3.0.2-1.src.rpm
checksum_type: sha256
description:
  Astronomia is a collection of subroutines and applications for calculating the
  positions of the sun, moon, planets and other celestial objects. The emphasis
  is on high accuracy over a several thousand year time span. Note that the
  techniques used are overkill for most calendar applications.
  The subroutine library attempts to implement some the techniques described in
  *Astronomical Algorithms*, second edition 1998, by Jean Meeus, `Willmann-Bell,
  Inc. <http://www.willbell.com/">`_
  Currently there are no graphical applications apart from some demo CGI
  interfaces.
  Astronomia will work with Python 2.6+ and 3.0+.
  Documentation
  ~~~~~~~~~~~~~
  Reference documentation is at http://timcera.bitbucket.io/.
  Installation
  ~~~~~~~~~~~~
  At the command line::
      $ pip install astronomia
      
      $ conda install -c conda-forge astronomia
  Usage
  ~~~~~
  To use Astronomia in a project::
  	import astronomia
  Development
  ~~~~~~~~~~~
  Development is managed on bitbucket at
  https://bitbucket.org/timcera/astronomia/overview.
  History
  ~~~~~~~
  Astronomia is a fork of the Astrolabe library created by Bill McClain.  The
  Astrolabe library is no longer available.
  I (Tim Cera) used the Astrolabe library within my tidal analysis package
  `TAPPy <http://tappy.sf.net>`_. In 2013 I pulled Astrolabe out of TAPPy and
  forked Astronomia.  I have since fixed many bugs and added features.  The most
  important added feature is the ability for most functions to work with array
  inputs.  Bill McClain had dual Python and 'C' code, but I focused only on the
  Python code, updating with newer data and equations as I found them.


pkgId: 9b7890e6793ac83970903f1c62c48e89c78e36314985c8a3dd6037c91f22d4fd
name: python-astroplan
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Observation planning package for astronomers
url: https://github.com/astropy/astroplan
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroplan-0.10.1-1.src.rpm
checksum_type: sha256
description:
  Observation planning package for astronomers
  * Code: https://github.com/astropy/astroplan
  * Docs: https://astroplan.readthedocs.io/
  * License: BSD-3
  Attribution
  +++++++++++
  If you use astroplan in your work, please cite `Morris et al. 2018 <https://ui.adsabs.harvard.edu/abs/2018AJ....155..128M/abstract>`_:
    @ARTICLE{2018AJ....155..128M,
           author = {{Morris}, Brett M. and {Tollerud}, Erik and {Sip{\H{o}}cz}, Brigitta and {Deil}, Christoph and {Douglas}, Stephanie T. and {Berlanga Medina}, Jazmin and {Vyhmeister}, Karl and {Smith}, Toby R. and {Littlefair}, Stuart and {Price-Whelan}, Adrian M. and {Gee}, Wilfred T. and {Jeschke}, Eric},
            title = "{astroplan: An Open Source Observation Planning Package in Python}",
          journal = {\aj},
         keywords = {methods: numerical, methods: observational, Astrophysics - Instrumentation and Methods for Astrophysics},
             year = 2018,
            month = mar,
           volume = {155},
           number = {3},
              eid = {128},
            pages = {128},
              doi = {10.3847/1538-3881/aaa47e},
    archivePrefix = {arXiv},
           eprint = {1712.09631},
     primaryClass = {astro-ph.IM},
           adsurl = {https://ui.adsabs.harvard.edu/abs/2018AJ....155..128M},
          adsnote = {Provided by the SAO/NASA Astrophysics Data System}
    }


pkgId: 1339b4971067024c36fc0e58b00da351f875c54d995f4c7094dbd940e67baaff
name: python-astropop
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Astronomical Polarimetry and Photometry Pipeline
url: https://pypi.org/project/astropop/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astropop-0.9.4-1.src.rpm
checksum_type: sha256
description:
  |GHAction Status| |Codecov Status| |RTD Status| |CODACY|
  The ASTROnomical POlarimetry and Photometry pipeline. Developed for work with IAGPOL and SPARC4 polarimeters at Observatório Pico dos Dias (Brazil), but suitable to be used in other image polarimeters around the world.
  Features
  ^^^^^^^^
  This software is intended to provide a full pipeline to reduce raw polarimetry and photometry data taken with common CCD telescope cameras. It can do:
  - Create calibrate frames;
  - Calibrate images using bias/flat/dark frames;
  - Gain correction and in-processing image binnig;
  - Cosmic ray extraction (astroscrappy);
  - Align image sets;
  - Aperture and (planned) PSF photometry;
  - Calcite polarimeters;
    - Automatic pairs of stars identification;
  - Automatic photometry calibration using online catalogs.
  Support and Community
  ^^^^^^^^^^^^^^^^^^^^^
  We have a community of people using astropop to perform data reduction. Also, we use this community to offer support for astropop users. Join the community at `astropop-users Google-Groups <https://groups.google.com/g/astropop-users>`_
  Dependencies
  ^^^^^^^^^^^^
  Some of astropop dependencies (numpy, astropy, scipy, astroscrappy) need gcc to get build. Make sure gcc is installed properly in your system.
  There is nothing that prevent astropop itself to run on Windows. However, due to problems that comes from dependencies, mainly numpy and astrometry.net, astropop is currently supported only on Linux and Mac.
  Bellow we list all the necessary dependencies for the good working of the code. Note that this can be changed with the time.
  - astroalign;
  - astropy >= 4.3;
  - astroquery;
  - astroscrappy;
  - numpy >= 1.17;
  - scikit-image;
  - scikit-learn;
  - scipy;
  - sep.
  Installation
  ^^^^^^^^^^^^
  Astropop can be downloaded from `gh/sparc4-dev/astropop <https://github.com/sparc4-dev/astropop>`_. It follows the stadard python package install procedure. All requirements can be installed with `pip` or `conda`.


pkgId: 2462f54d79d1fe4a6e368948f0d487d37ae36e841b4e23190368860f26211caf
name: python-astropy-helpers
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Utilities for building and installing packages in the Astropy ecosystem
url: https://github.com/astropy/astropy-helpers
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astropy-helpers-4.0.1-1.src.rpm
checksum_type: sha256
description:
  The **astropy-helpers** package includes many build, installation, and
  documentation-related tools used by the Astropy project, but packaged separately
  for use by other projects that wish to leverage this work. The motivation behind
  this package and details of its implementation are in the accepted
  `Astropy Proposal for Enhancement (APE) 4 <https://github.com/astropy/astropy-APEs/blob/master/APE4.rst>`_.
  Astropy-helpers is not a traditional package in the sense that it is not
  intended to be installed directly by users or developers. Instead, it is meant
  to be accessed when the ``setup.py`` command is run - see the
  "`Using astropy-helpers in a package <https://astropy-helpers.readthedocs.io/en/stable/using.html>`_"
  section in the documentation for how to do this.
  For a real-life example of how to implement astropy-helpers in a
  project, see the ``setup.py`` and ``setup.cfg`` files of the
  `Affiliated package template <https://github.com/astropy/package-template>`_.
  For more information, see the documentation at http://astropy-helpers.readthedocs.io


pkgId: b120c350a0e4a4ecafb974a4cf68e8b5333f8cedd5a7a31b10311a7b97d0b713
name: python-astropy-iers-data
arch: src
version: 0.2024.10.7.0.32.46
epoch: 0
release: 1
summary: IERS Earth Rotation and Leap Second tables for the astropy core package
url: https://pypi.org/project/astropy-iers-data/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astropy-iers-data-0.2024.10.7.0.32.46-1.src.rpm
checksum_type: sha256
description:
  **Note:** This package is not currently meant to be used directly by users, and only
  meant to be used from the core astropy package.
  https://docs.astropy.org/en/latest/utils/iers.html

rpm_license:
  Copyright (c) 2023, 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: 5815ece11d7e541d09f67bffcf1caf4a6170dd96a16b9189e17bb87fde397003
name: python-astropy-sphinx-theme
arch: src
version: 1.1
epoch: 0
release: 1
summary: The sphinx theme for Astropy and affiliated packages.
url: https://github.com/astropy/astropy-sphinx-theme
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astropy-sphinx-theme-1.1-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the default Astropy project documentation
  theme(s). To use this theme, simply install this package then add the
  following line to your documentation's ``conf.py`` file:
      html_theme = 'bootstrap-astropy'
  This requires Sphinx 1.6 or later to work properly. For older versions
  of Sphinx, you will need to do:
      import astropy_sphinx_theme
      html_theme_path = astropy_sphinx_theme.get_html_theme_path()
      html_theme = 'bootstrap-astropy'
  ``bootstrap-astropy`` is the only theme that is currently available, but
  the structure of the package allows more themes to be added in future if
  needed.
  Several options for the theme can be set in the ``conf.py`` file:
    html_theme_options = {
        'logotext1': 'packagename',  # white,  semi-bold
        'logotext2': '',  # orange, light
        'logotext3': ':docs',   # white,  light
        'astropy_project_menubar': True
        }
  The ``logotext?`` options can be used to customize the top left logo, while
  the ``astropy_project_menubar`` option can be set to ``True`` for packages
  that are managed by the project itself (this will add links to find out more
  about the Astropy project, about the team, and so on).


pkgId: df3d09d5767937a2b576d3c57fc88baf6e8e01a7e357adf2ad2d667b7ca4cf24
name: python-astroslam
arch: src
version: 1.2022.1228.1
epoch: 0
release: 1
summary: A forward model using SVR to estimate stellar parameters from spectra.
url: http://github.com/hypergravity/astroslam
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroslam-1.2022.1228.1-1.src.rpm
checksum_type: sha256
description:
  Stellar LAbel Machine (SLAM) is a forward model to estimate stellar labels (e.g., Teff, logg and chemical abundances).
  It is based on Support Vector Regression (SVR) which is a non-parametric regression method.

  For details of **SLAM**, see [Deriving the stellar labels of LAMOST spectra with Stellar LAbel Machine (SLAM)](https://ui.adsabs.harvard.edu/abs/2020ApJS..246....9Z/abstract).
  Related projects: click [here](https://ui.adsabs.harvard.edu/abs/2020ApJS..246....9Z/citations).



  Bo Zhang (bozhang@nao.cas.cn)



  - [https://github.com/hypergravity/astroslam](https://github.com/hypergravity/astroslam)
  - [https://pypi.org/project/astroslam/](https://pypi.org/project/astroslam/)


  - for the latest **stable** version:
    - `pip install -U astroslam`
  - for the latest **github** version:
    - `pip install -U git+git://github.com/hypergravity/astroslam`
  - for Zenodo version
    - [https://zenodo.org/record/3461504](https://zenodo.org/record/3461504)


  [updated on 2020-12-02]
  - A new SLAM tutorial can be found [here](https://nbviewer.jupyter.org/github/hypergravity/spectroscopy/blob/main/stellar_parameters/demo_slam/demo_slam.ipynb)
  - If you are interested in SLAM or have any related questions, do not hesitate to contact me.


  - numpy
  - scipy
  - matplotlib
  - astropy
  - scikit-learn
  - joblib
  - pandas
  - emcee


  Paper:
  ```
  @ARTICLE{2020ApJS..246....9Z,
         author = {{Zhang}, Bo and {Liu}, Chao and {Deng}, Li-Cai},
          title = "{Deriving the Stellar Labels of LAMOST Spectra with the Stellar LAbel Machine (SLAM)}",
        journal = {\apjs},
       keywords = {Astronomical methods, Astronomy data analysis, Bayesian statistics, Stellar abundances, Chemical abundances, Fundamental parameters of stars, Catalogs, Surveys, Astrophysics - Solar and Stellar Astrophysics, Astrophysics - Astrophysics of Galaxies, Astrophysics - Instrumentation and Methods for Astrophysics},
           year = 2020,
          month = jan,
         volume = {246},
         number = {1},
            eid = {9},
          pages = {9},
            doi = {10.3847/1538-4365/ab55ef},
  archivePrefix = {arXiv},
         eprint = {1908.08677},
   primaryClass = {astro-ph.SR},
         adsurl = {https://ui.adsabs.harvard.edu/abs/2020ApJS..246....9Z},
        adsnote = {Provided by the SAO/NASA Astrophysics Data System}
  }
  ```
  Code:
  ```
  @misc{https://doi.org/10.5281/zenodo.3461504,
      author = {Zhang, Bo},
      title = {hypergravity/astroslam: Stellar LAbel Machine},
      doi = {10.5281/zenodo.3461504},
      url = {https://zenodo.org/record/3461504},
      publisher = {Zenodo},
      year = {2019}
  }
  ```

  For other formats, please go to [https://search.datacite.org/works/10.5281/zenodo.3461504](https://search.datacite.org/works/10.5281/zenodo.3461504).


pkgId: 06b4f43f10161000b6db1370947a5efdcc019fdfff21b0d150ba6ca24aa290e8
name: python-astrostreampy
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: Package to model stellar tidal streams.
url: https://github.com/jnpippert/streamPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrostreampy-1.9.0-1.src.rpm
checksum_type: sha256
description:
  To create a stream model you need the following files:
    - the **IMAGE** file
    - a **MASK** of all neabry, and overlapping sources
    - if other stars or galaxies contaminate the stream's central region, create an additional **INTERPOLATION MASK** for sources to interpolate over

  All have to be the same size, otherwise an error is raised. RGB *.TIF*, *.jpg* or *.png* does not work, they need to be in gray scale *.fits* format.
  The **IMAGE** header must contain the following keys:
    - 'FILTER'  : char, the band in which the image was taken.
    - 'PSF'     : float, the mean FWHM of the sources across the image in arc seconds. If there is no interest in the true intrinsic shape parameters of the stream set it to **1**.
    - 'PXSCALE' : float, the pixel scale of the image in arc seconds/pixel.
    - 'ZP'      : float, the photometric zero point.


  First import all necessary classes and methods and define the files as variables.
  ```
  from astrostreampy.Image.stream import Stream
  from astrostreampy.Image.point import Point
  from astrostreampy.BuilModel.autobuild import Model
  from astrostreampy.BuildModel.modify import Modifier
  from astrostreampy.BuildModel.aperture import fwhm_mask_from_paramtab

  image = "image.fits"
  mask = "mask.fits"
  intmask = "interpolationmask.fits"
  ```
  Start by applying the masks using the ```Stream``` class. Note that the masks are parsed as a list. This allows for multiple masks of the same type to apply simultaneously.
  ```
  stream = Stream(image,[mask],[intmask])
  stream.apply_masks()
  ```
  Then the initial box position and dimensions can be set with the ```Point``` class. It opens a figure where the point can be set with left mouse click and the box dimensions are chosen with the sliders on the left.
  When satisfied close the plot by closing the window. ```stream.data()``` is the masked image.
  ```
  init_box = Point(stream.data)
  ```
  The modeling is setup and started with the ```Model``` class. The example presents its shortest and simplest form.
  ```
  model = Model(stream.original_data, stream.data, stream.header,
                    init_box.x, init_box.y, init_box.width, init_box.height, output="model")
  model.build() # for further access get full model with .data
  model.show() # for quality checks
  ```
  If ```model.show()``` reveals that the algorithm went beyond the stream call the ````Modifier``` class to cut those regions off. A window opens displaying the image, model and residual. Type in the terminal the lower and upper indices sperated by "," and press *ENTER*. The model and residual changes based on the input. Repeat it as often as desired. When finished leave the line empty and press *ENTER* again. It saves the modified files with prefix "mod_".
  ```
  Modifier("model_multifits.fits","model_paramtab.fits")
  ```
  If you are interested in photometric measurements use
  ```
  aperture = fwhm_mask_from_paramtab("mod_model_multifits.fits","mod_model_paramtab.fits"
  ```
  to create an aperture mask, which is a ```numpy.ndarray```.


pkgId: 634a27edf65e1ff070cd94e3adfb6f04364f55b75c07061c48e91dbfba11f980
name: python-astrosurveyutils
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Astronomical survey utilities
url: https://github.com/virajkaram/astrosurveyutils
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrosurveyutils-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Install with  `pip install -e .` in the cloned directory.
  <br>
  <br>
  Example/ documentation in `astrosurveyutils/notebooks/example.ipynb `


pkgId: 1f77e5b644a8620ec33be7f59fbdc4defb8e42496502c7f0ecc629c98ffce01c
name: python-astrotool
arch: src
version: 0.0.16
epoch: 0
release: 1
summary: A Python package for astronomical calculations in Python or on the command line
url: http://astro.ru.nl/~sluys/AstroTool
rpm_license: EUPL 1.2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrotool-0.0.16-1.src.rpm
checksum_type: sha256
description:
  A Python package for astronomical calculations in Python or on the command line.




  This package can be installed using `pip install astrotool`.  This should automatically install the dependency
  packages `astroconst`, `colored_traceback` and `numpy` if they haven't been installed already.  If you are
  installing by hand, you have to ensure these packages are installed as well.




  * [Pypi](https://pypi.org/project/astrotool/): AstroTool Python package
  * [GitHub](https://github.com/MarcvdSluys/AstroTool): AstroTool source code
  * [Read the Docs](https://astrotool.readthedocs.io): AstroTool documentation




  * Author: Marc van der Sluys
  * Contact: http://astro.ru.nl/~sluys/
  * Licence: [EUPL 1.2](https://www.eupl.eu/1.2/en/)




  * [AstroConst](https://pypi.org/project/astroconst/): a Python package that provides astronomical constants.
  * [SolTrack](https://pypi.org/project/soltrack/): a free, fast and accurate
    [Python](https://pypi.org/project/soltrack/) or [C/C++](http://soltrack.sourceforge.net/) routine to compute
    the position of the Sun.
  * [elp-mpp02](https://pypi.org/project/elp-mpp02/): accurate Moon positions using the lunar solution ELP/MPP02
    in Python.
  * [libTheSky](http://libthesky.sourceforge.net/): a Fortran library to compute the positions of celestial
    bodies (Sun, Moon, planets, stars, asteroids, comets) and events (e.g. lunar phases) with great accuracy.




  * Meeus, [Astronomical algorithms](https://www.willbell.com/math/MC1.HTM), 2nd Ed.
  * [Celestial mechanics in a nutshell (CMiaNS)](https://cmians.sourceforge.io/): online living document.
  * This Python code is being adapted from the Fortran implementation in
    [libTheSky](http://libthesky.sourceforge.net/)


  <sub>Copyright (c) 2021-2022 Marc van der Sluys</sub>


pkgId: 979b5005076b1558a8e20938428fb3f5a17899e461ccc9180967cfe56ab9f576
name: python-astroviper
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: Astro Visibility and Image Parallel Execution Reduction
url: https://pypi.org/project/astroviper/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astroviper-0.0.14-1.src.rpm
checksum_type: sha256
description:
  [![Python 3.8 3.9 3.10 3.11](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)](https://www.python.org/downloads/release/python-380/)
  ![Linux Tests](https://github.com/casangi/astrohack/actions/workflows/python-testing-linux.yml/badge.svg)
  ![macOS Tests](https://github.com/casangi/astrohack/actions/workflows/python-testing-macos.yml/badge.svg)

  AstroVIPER (Visibility and Image Parallel Execution Reduction) is in development.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Associated Universities, Inc.  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: b6ecfa6f538681e941cfb818096f4f9f3bed18fb745a5bdbdbdd328fdccc7d1b
name: python-astrovision
arch: src
version: 0.13.2
epoch: 0
release: 1
summary: The compulsory Python library to work with satellite imagery.
url: https://github.com/InseeFrLab/astrovision
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrovision-0.13.2-1.src.rpm
checksum_type: sha256
description:
  The compulsory Python library to work with satellite imagery.



  `GDAL` must be installed (`source install_gdal.sh`).



  ```bash
  pip install astrovision
  ```



  Documentation can be found here: https://inseefrlab.github.io/astrovision/.



  To contribute, refer to `CONTRIBUTING.md`. Astrovision is a poetry built project, to develop install the package with

  ```
  pip install -e .
  ```


pkgId: 0504bbd06560e4939b595600b1cfb59627a5116bc5f93178e1d5aba4cfd261a0
name: python-astrowidgets
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Widgets for the Jupyter notebook and JupyterLab
url: https://astrowidgets.readthedocs.io
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrowidgets-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ``astrowidgets`` aims to be a set of astronomy widgets for Jupyter Lab or Notebook,
  leveraging the Astropy ecosystem. The ``ImageWidget`` implements the API documented at
  `https://github.com/eteq/nb-astroimage-api <https://github.com/eteq/nb-astroimage-api>`_
  **Warning**
  ``astrowidgets`` is currently in *very* early development.  Nothing is guaranteed to work or do anything in particular
  at this stage.


pkgId: 501c494ce1074b46c2ba6bd0a94c0da070660a2994a39ef2a44a9e2c4a552887
name: python-astrun
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: A safe eval using Abstract Syntax Tree
url: https://github.com/XiaoMutt/astrun
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astrun-1.0.8-1.src.rpm
checksum_type: sha256
description:
  The astrun package is to provide a "relative" secure way to evaluate Python expressions similar to Python's `eval`,
  as the builtin `eval` and `exec` are insecure and can be exploited in many ways.

  This package is very small and need no dependencies. You can just copy, modify and use. Happy Programming.



  - you want to build a web calculator do simple math calculations or string operations.
  - you want to give certain users high flexibility to configure some conditions. E.g.
      - to determine if a file path is good for further process.
      - to customize string transformations.



  ```python
  from astrun import Astrun

  Astrun.eval("1 in {i for i in range(10) if i % 2 == 1}")  # return True

  Astrun.eval("__import__('os')")  # will throw PermissionError
  Astrun.eval("open('file', 'w')")  # will throw PermissionError
  ```

  For more examples, see the test code in `test` and the source code in `src`.

  NOTICE: this library can only be used in Python >= 3.11 because it used * unpacking in subscription which is a
  feature introduced in Python 3.11. If you would like to use it in earlier Python versions, change the code in
  Astrun.visit_Subscript to other ways of unpacking.



  `Astrun` evaluates the given code text as instructions only, and the execution is done by `Astrun`'s own code:

  - `Astrun` uses the ast library to parse the code text to an Abstract Syntax Tree (AST).
  - The tree is then executed by translating each node back to `Astrun`'s own Python code.
      - The execution is within a namespace that excludes the dangerous builtins functions such as
        `eval`, `exec`,`globals`, `__import__`, etc.
        - see the Astrun's namespace attribute. Common built-ins are included and the "re" package is included.
      - Advanced AST nodes, such as function and class definition, are blocked.
      - Private or dunder attributes' access of any object is prohibited.

  However, using `Astrun` alone is still not secure for a server to execute arbitrary code texts, because a user
  can still provide code that

  - overloads the CPU. e.g. `1024**1024**1024**1024`
  - causes memory overflow. e.g. `[0] * (1024*1024*1024*1024)`
  - exploits other ways to access system IO or network

  Therefore, `IsolatedEnv` is provided (**ATTENTION: Linux Only, not even Mac OS**) to isolate any code execution in a
  separated constraint Python Process:

  - the total memory is limited.
  - the total CPU time is limited.
  - file descriptor creation is blocked.
  - subprocess creation is blocked.
  - the response time of a single execution is timed.
  - if any restriction violated the Process is terminated.

  E.g.

  ```python
  from astrun import Astrun, IsolatedEnv


  class AstrunIsolatedEnv(IsolatedEnv):
      @staticmethod
      def _run(*args):
          return Astrun.eval(*args)


  with AstrunIsolatedEnv() as env:
      assert env("1+1") == 2
  ```



  It is NOT guaranteed that arbitrary code can be executed harmlessly by using `Astrun` inside a `IsolatedEnv` . Since
  users provided the code text, they may find loopholes to bypass the restrictions and Python is nothing short of
  convenient loopholes.

  Therefore, if you use `astrun` to run arbitrary users code text, make sure the OS account to run the process is
  restricted (no sudo, no access to important files, etc.).

  It is better to only expose `astrun` to the responsible users, such as the admins of your webapp, and log the users and
  the code text they provide.



  I searched the web for a long time for a package like `astrun` but cannot find one, so I made my own. If you find a
  loophole of `astrun`, please open an issue and submit it, so that it can be blocked.

  Or maybe it cannot be blocked. Then, it explains why no such package exists. An alternative way is to run JavaScript in
  Python, since JavaScript has no IO access, so it is IO safe. However, import a JavaScript engine into a Python
  program is likely an overkill.



  Can you believe it is "MIT"!


pkgId: 3b8a9813746d3e8837b1f159409e558163906c3d586156e2ec55ff56b97a78d1
name: python-astsearch
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Intelligently search Python source code
url: https://github.com/takluyver/astsearch
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astsearch-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ASTsearch is an intelligent search tool for Python code.

  To get it::

      pip install astsearch

  To use it::

      
      astsearch "?/?"  # Division operations in all files in the current directory

  For more details, see `the documentation <http://astsearch.readthedocs.org/en/latest/>`_.


pkgId: 72c89c56de31c835d8068c98d6f7e86a7473c7d46ee050d6922c44d9787dc2b2
name: python-asttokens
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Annotate AST trees with source code positions
url: https://github.com/gristlabs/asttokens
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asttokens-3.0.0-1.src.rpm
checksum_type: sha256
description:
  The ``asttokens`` module annotates Python abstract syntax trees (ASTs) with the positions of tokens
  and text in the source code that generated them.
  It makes it possible for tools that work with logical AST nodes to find the particular text that
  resulted in those nodes, for example for automated refactoring or highlighting.


pkgId: 8a25e5d3a69d0ff502aad71e50d9e27ce93d20c74ba2fbe4b7b8c35bd407fdd5
name: python-asttrs
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A attrs-style wrapper for python ast
url: https://pypi.org/project/asttrs/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asttrs-1.3.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://github.com/ryanchao2012/asttrs/actions/workflows/asttrs-run-unittests.yml/badge.svg)
  ![](https://img.shields.io/pypi/v/asttrs.svg)
  ![](https://img.shields.io/pypi/pyversions/asttrs)
  ![](https://img.shields.io/github/license/ryanchao2012/asttrs)


  A attrs-style wrapper for python ast





  1. easier to access docstring.
  2. easier to do codegen.

  ```python
  from ast import FunctionDef

  help(FunctionDef)














  ```

  vs

  ```python
  from asttrs import FunctionDef

  help(FunctionDef)




















  from asttrs import arguments, Return, Constant

  func = FunctionDef(name="foo", args=arguments(), body=[Return(value=Constant(value="Hello World"))])

  print(func.to_source())




  ```



  ```python
  from asttrs import Comment


  comment = Comment(body="This is a comment,\nsecond line,\nthird line.")
  print(comment.to_souce())



  ```




  ```

  $ (cd cpython; git checkout v3.11.7)
  $ ln -vsfT .venv311 .venv


  $ pdm run inv build | pdm run black - >! src/asttrs/_py3_11.py


  $ pdm run pytest --doctest-modules --cov=asttrs._py3_11 --cov-report=term-missing src/asttrs/_py3_11.py tests
  ```


pkgId: 43ba78308ae2fd553eb57b8b4d61e3044dbf7b3042e333b0cdc7450a2130ba13
name: python-astutils
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Utilities for abstract syntax trees and parsing with PLY.
url: https://github.com/johnyf/astutils
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astutils-0.0.6-1.src.rpm
checksum_type: sha256
description:
  Bare essentials for building abstract syntax trees (AST) and Python
  `lex`-`yacc` ([PLY](https://github.com/dabeaz/ply)) parsers.
  The package includes:
  - two classes for tree nodes: `Terminal`, `Operator`
  - a `Lexer` and `Parser` class, and a helper function to erase and
    rewrite the table files.
  The examples under `examples/` demonstrate how to use these classes to create
  a richer AST, a parser, and different backends that use the same parser.
  These classes provide the boilerplate for parsing with PLY, and are based on
  code that was developed in [`tulip`](
      https://github.com/tulip-control/tulip-control)
  and [`promela`](https://github.com/johnyf/promela).


pkgId: b4a673d3613768e81214e82a1172076976e61fbde76a14872536a2f2ef2f702e
name: python-astx
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: ASTx is an agnostic expression structure for AST.
url: https://pypi.org/project/astx/
rpm_license: BSD 3 Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-astx-0.16.0-1.src.rpm
checksum_type: sha256
description:
  ASTx is a groundbreaking library designed to encapsulate language components in
  an agnostic and pythonic way. It provides a comprehensive set of classes and
  functionalities, allowing developers to articulate the core elements of any
  programming language.

  - License: BSD 3 Clause
  - Documentation: https://astx.arxlang.org





  ASTx offers a rich suite of classes to describe essential language constructs
  such as:

  - `If` statements
  - `For` loops
  - `Function` declarations and usages
  - Variables
  - Data Types
  - Operations
  - And more

  These classes enable a concise and clear representation, providing an intuitive
  way to model various programming constructs.



  An integral part of ASTx, the Symbol Table class facilitates the translation of
  ASTx expressions to other languages like LLVM-IR. This class acts as a mapping
  layer, allowing a seamless connection between ASTx expressions and target
  language representations.



  Uniquely tailored to be independent of specific programming languages, ASTx
  offers a flexible foundation. It strives to provide initial components that can
  describe any programming language, giving users the freedom to work with
  multiple languages effortlessly.



  ASTx has proven to be a vital tool in projects like ARX-IR, where it's leveraged
  to translate Abstract Syntax Trees (AST) into LLVM-IR. This showcases the
  library's adaptability and potential to serve as a foundational layer in various
  applications.



  ASTx is not just a library; it's a robust framework that fosters creativity and
  efficiency in language processing. Its pythonic design, combined with the power
  to handle different language constructs, positions ASTx as an invaluable
  resource for developers and researchers alike.

  Whether you're building a compiler, working on language translation, or
  exploring new frontiers in programming language design, ASTx offers a reliable
  and extensible toolkit to support your endeavors.



  You can explore the ASTx library and dive into its capabilities by accessing the
  official documentation. For those interested in contributing or seeking further
  insights, the ASTx community provides extensive support and collaboration
  opportunities.

  Unlock the potential of language representation with ASTx, and join us in
  shaping the future of programming languages.


pkgId: fdf81d048a8fa718ba565f3646437efd523e161aed7318e1049457b7b84a8a8e
name: python-asu
arch: src
version: 0.7.20
epoch: 0
release: 1
summary: An image on demand server for OpenWrt based distributions
url: https://pypi.org/project/asu/
rpm_license: GPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asu-0.7.20-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/aparcar/asu/branch/master/graph/badge.svg)](https://codecov.io/gh/aparcar/asu)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPi](https://badge.fury.io/py/asu.svg)](https://badge.fury.io/py/asu)

  This project simplifies the sysupgrade process for upgrading the firmware of
  devices running OpenWrt or distributions based on it. These tools offer an easy
  way to reflash the router with a new firmware version
  (including all packages) without the need to use `opkg`.

  It's called Attended SysUpgrade (ASU) because the upgrade process is not started
  automatically, but is initiated by a user who waits until it's done.

  ASU is based on an API (described below) to request custom firmware images with
  any selection of packages pre-installed. This avoids the need to set up a build
  environment, and makes it possible to create a custom firmware image even using
  a mobile device.





  Simple web interface using vanilla JavaScript currently developed by @mwarning.
  It offers a device search based on model names and show links either to
  [official images](https://downloads.openwrt.org/) or requests images via the
  _asu_ API. Please join in the development at
  [GitLab repository](https://gitlab.com/openwrt/web/firmware-selector-openwrt-org)

  ![ofs](misc/ofs.png)



  The package
  [`luci-app-attendedsysupgrade`](https://github.com/openwrt/luci/tree/master/applications/luci-app-attendedsysupgrade)
  offers a simple tool under `System > Attended Sysupgrade`. It requests a new
  firmware image that includes the current set of packages, waits until it's built
  and flashes it. If "Keep Configuration" is checked in the GUI, the device
  upgrades to the new firmware without any need to re-enter any configuration or
  re-install any packages.

  ![luci](misc/luci.png)



  The [`auc`](https://github.com/openwrt/packages/tree/master/utils/auc) package
  performs the same process as the `luci-app-attendedsysupgrade`
  from SSH/the command line.

  ![auc](misc/auc.png)



  The server listens for image requests and, if valid, automatically generates
  them. It coordinates several OpenWrt ImageBuilders and caches the resulting
  images in a Redis database. If an image is cached, the server can provide it
  immediately without rebuilding.



  - [sysupgrade.openwrt.org](https://sysupgrade.openwrt.org)
  - [asu.aparcar.org](https://asu.aparcar.org)
  - ~~[chef.libremesh.org](https://chef.libremesh.org)~~ (`CNAME` to
    asu.aparcar.org)



  Redis is required to store image requests:

      sudo apt install redis-server tar

  Install _asu_:

      pip install asu

  Create a `config.py`.
  You can use `misc/config.py` as an example.

  Start the server via the following commands:

      export FLASK_APP=asu.asu  # set Flask app to asu
      flask janitor update      # download upstream profiles/packages - this runs forever
      flask run                 # run development server - this runs forever

  Start the worker via the following comand:

      rq worker                 # this runs forever



  Run the service inside multiple Docker containers. The services include the _
  ASU_ server itself, a _janitor_ service which fills the Redis database with
  known packages and profiles as well as a `rqworker` which actually builds
  images.

  Currently all services share the same folder and therefore a very "open" access
  is required. Suggestions on how to improve this setup are welcome.

      mkdir -p ./asu-service/public/
      chmod -R 777 ./asu-service/
      cp ./misc/config.py ./asu-service/
      docker-compose up

  A webserver should proxy API calls to port 8000 of the `server` service while
  the `asu/` folder should be file hosted as-is.



  It is recommended to run _ASU_ via `gunicorn` proxied by `nginx` or
  `caddyserver`. Find a possible server configurations in the `misc/` folder.

  The _ASU_ server will try `$PWD/config.py` and `/etc/asu/config.py` to find a
  configuration. Find an example configuration in the `misc/` folder.

      pip install gunicorn
      gunicorn "asu.asu:create_app()"

  Ideally use the tool `squid` to cache package indexes, which are reloaded every
  time an image is built. Find a basic configuration in at `misc/squid.conf`
  which should be copied to `/etc/squid/squid.conf`.

  If you want to use `systemd` find the service files `asu.service` and
  `worker@.service` in the `misc` folder as well.



  After cloning this repository, create a Python virtual environment and install
  the dependencies:

      python3 -m venv .direnv
      source .direnv/bin/activate
      pip install -r requirements.txt
      export FLASK_APP=asu.asu  # set Flask app to asu
      export FLASK_APP=tests.conftest:mock_app FLASK_DEBUG=1 # run Flask in debug mode with mock data
      flask run



  The API is documented via _OpenAPI_ and can be viewed interactively on the
  server:

  [https://sysupgrade.openwrt.org/ui/](https://sysupgrade.openwrt.org/ui/)


pkgId: e4ff4d301bbccb4ff99a2d415b59f4f8d23ff7362501987a2b361631bdbc81c4
name: python-asuna-api
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: An async python wrapper for the asuna api
url: https://pypi.org/project/asuna-api/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asuna-api-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for asuna.ga
  I'm not the creator of asuna api, and some of the code came from the [iDutchy some-random-api project](https://github.com/iDutchy/sr_api) so credits to them.
  Credits to iDutchy for the Original source and Thank You for letting me use your code.

  For any questions and support for the wrapper, you can visit the [Discord support server](https://discord.gg/eVQH2ZRYpz "JDJG3493's Server") or DM me on Discord at jdjg.

  [Alternative Discord Server](https://discord.gg/fVTguWrhxY)


  To begin with, you'll have to install the package by doing one of the following commands:
  ```shell
  pip install -U asuna-api
  ```
  ```shell
  python -m pip -U install asuna-api
  ```

  Or you can install directly from source by doing one of the following commands:
  ```shell
  pip install -U git+https://github.com/Senarc-Studios/asuna_api
  ```
  ```shell
  python -m pip install -U git+https://github.com/Senarc-Studios/asuna_api
  ```

  After that, you will have to create the client:
  ```python
  import asuna_api

  client = asuna_api.Client()
  ```

  For full usage, please read the [documentation](https://github.com/Senarc-Studios/asuna_api/blob/main/DOCUMENTATION.md)


pkgId: 09902f0aea40e4d1c85fbbc54b7067f287c599359f47ddb9e025688c252a0b41
name: python-asusrouter
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: API wrapper for communication with ASUSWRT-powered routers using HTTP protocol
url: https://github.com/Vaskivskyi/asusrouter
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asusrouter-1.13.0-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Release](https://img.shields.io/github/release/Vaskivskyi/asusrouter.svg?style=for-the-badge&color=blue)](https://github.com/Vaskivskyi/asusrouter/releases) [![License](https://img.shields.io/github/license/Vaskivskyi/asusrouter.svg?style=for-the-badge&color=yellow)](LICENSE)<br/>
  ![Downloads](https://img.shields.io/pypi/dm/asusrouter?style=for-the-badge&color=blue) ![Commit activity](https://img.shields.io/github/commit-activity/m/vaskivskyi/asusrouter.svg?style=for-the-badge&color=yellow)<a href="https://www.buymeacoffee.com/vaskivskyi" target="_blank"><img src="https://asusrouter.vaskivskyi.com/BuyMeACoffee.png" alt="Buy Me A Coffee" style="height: 28px !important;" align="right" /></a>

  <div align=center><img src="https://asusrouter.vaskivskyi.com/logo.svg" width="300px"></div>



  **AsusRouter** is an API wrapper for communication with ASUSWRT-powered routers using HTTP(S) protocols. The library supports both the stock AsusWRT firmware and AsusWRT-Merlin.

  Up till now, it is mostly used for the [custom AsusRouter Home Assistant integration](https://github.com/Vaskivskyi/ha-asusrouter). But I am always open to making it suitable for any other use.



  Installation of the latest release is available from PyPI:

  ```
  pip install asusrouter
  ```



  Once installed, you can import the `AsusRouter` class from the module. Example shows the default parameters except for `host`, `username` and `password`.

  ```python
  import aiohttp
  import asyncio
  from asusrouter import AsusRouter, AsusData


  loop = asyncio.new_event_loop()


  session = aiohttp.ClientSession(loop=loop)

  router = AsusRouter(                #required - both IP and URL supported
      hostname="router.my.address",   #required
      username="admin",               #required
      password="password",            #required
      use_ssl=True,                   #optional
      session=session,                #optional
  )


  loop.run_until_complete(router.async_connect())


  data = loop.run_until_complete(router.async_get_data(AsusData.NETWORK))
  print(data)


  loop.run_until_complete(router.async_disconnect())
  loop.run_until_complete(session.close())
  ```



  AsusRouter supports virtually every AsusWRT-powered device.



  | Model                                                                           | Status              | Tested firmware            | Find it on Amazon[^amazon]                                                             |
  | ------------------------------------------------------------------------------- | ------------------- | -------------------------- | -------------------------------------------------------------------------------------- |
  | [GT-BE19000](https://asusrouter.vaskivskyi.com/devices/GT-BE19000.md)           | 💛 Expected to work |                            | <a href="https://amzn.to/3yGFU7U" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT-BE98](https://asusrouter.vaskivskyi.com/devices/GT-BE98.md)                 | 💚 Confirmed        | Stock:<li>`102_34372`</li> | <a href="https://amzn.to/3vGztgz" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT-BE98 Pro](https://asusrouter.vaskivskyi.com/devices/GT-BE98Pro.md)          | 💛 Expected to work |                            | <a href="https://amzn.to/3uoSjeR" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-BE58U](https://asusrouter.vaskivskyi.com/devices/RT-BE58U.md)               | 💛 Expected to work |                            | <a href="https://amzn.to/4bHsdo4" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-BE88U](https://asusrouter.vaskivskyi.com/devices/RT-BE88U.md)               | 💛 Expected to work |                            | <a href="https://amzn.to/3TAGCKY" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-BE92U](https://asusrouter.vaskivskyi.com/devices/RT-BE92U.md)               | 💛 Expected to work |                            | <a href="https://amzn.to/4c1E8gg" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-BE96U](https://asusrouter.vaskivskyi.com/devices/RT-BE96U.md)               | 💛 Expected to work |                            | <a href="https://amzn.to/3vJu8oD" rel="nofollow sponsored" target="_blank">find it</a> |
  | [TUF-BE3600](https://asusrouter.vaskivskyi.com/devices/TUF-BE3600.md)           | 💛 Expected to work |                            | <a href="https://amzn.to/3VhHoyt" rel="nofollow sponsored" target="_blank">find it</a> |
  | [TUF-BE6500](https://asusrouter.vaskivskyi.com/devices/TUF-BE6500.md)           | 💛 Expected to work |                            | <a href="https://amzn.to/3X3Xltv" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi BD4](https://asusrouter.vaskivskyi.com/devices/ZenWiFiBD4.md)          | 💛 Expected to work |                            | <a href="https://amzn.to/3Kfulr1" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi BQ16](https://asusrouter.vaskivskyi.com/devices/ZenWiFiBQ16.md)        | 💛 Expected to work |                            | <a href="https://amzn.to/4bgVvdo" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi BQ16 Pro](https://asusrouter.vaskivskyi.com/devices/ZenWiFiBQ16Pro.md) | 💛 Expected to work |                            | <a href="https://amzn.to/3MNcw48" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi BT10](https://asusrouter.vaskivskyi.com/devices/ZenWiFiBT10.md)        | 💛 Expected to work |                            | <a href="https://amzn.to/48F5wiB" rel="nofollow sponsored" target="_blank">find it</a> |



  | Model                                                                           | Status              | Tested firmware                                                                   | Find it on Amazon[^amazon]                                                             |
  | ------------------------------------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
  | [GT-AXE11000](https://asusrouter.vaskivskyi.com/devices/GT-AXE11000.md)         | 💛 Expected to work |                                                                                   | <a href="https://amzn.to/3Gotj9R" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT-AXE16000](https://asusrouter.vaskivskyi.com/devices/GT-AXE16000.md)         | 💚 Confirmed        | Stock:<li>`388.21617`</li>Merlin:<li>`388.7_beta1_rog`</li><li>`388.7_0_rog`</li> | <a href="https://amzn.to/3vObLyZ" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AXE7800](https://asusrouter.vaskivskyi.com/devices/RT-AXE7800.md)           | 💚 Confirmed        | Stock:<li>`388_22068`</li>                                                        | <a href="https://amzn.to/3jUr2LU" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi ET8](https://asusrouter.vaskivskyi.com/devices/ZenWiFiET8.md)          | 💚 Confirmed        | Stock:<li>`388.23759`</li>                                                        | <a href="https://amzn.to/3Iks0La" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi ET9](https://asusrouter.vaskivskyi.com/devices/ZenWiFiET9.md)          | 💛 Expected to work |                                                                                   | <a href="https://amzn.to/3RbMKJa" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi Pro ET12](https://asusrouter.vaskivskyi.com/devices/ZenWiFiProET12.md) | 💚 Confirmed        | Stock:<li>`388.23013`</li>                                                        | <a href="https://amzn.to/3GTz68P" rel="nofollow sponsored" target="_blank">find it</a> |



  | Model                                                                                          | Status              | Tested firmware                                                                                                                                                                       | Find it on Amazon[^amazon]                                                             |
  | ---------------------------------------------------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
  | [DSL-AX82U](https://asusrouter.vaskivskyi.com/devices/DSL-AX82U.md)                            | 💚 Confirmed        | Merlin:<li>`386.07_0-gnuton0_beta2`</li>                                                                                                                                              | <a href="https://amzn.to/3G87vyR" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT-AX11000](https://asusrouter.vaskivskyi.com/devices/GT-AX11000.md)                          | 💚 Confirmed        | Merlin:<li>`386.7_2`</li><li>`388.1_0`</li><li>`388.4_0`</li><li>`388.7_0_rog`</li>                                                                                                   | <a href="https://amzn.to/3WDzOMT" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT-AX11000 Pro](https://asusrouter.vaskivskyi.com/devices/GT-AX11000Pro.md)                   | 💚 Confirmed        | Stock:<li>`388.24198`</li>Merlin:<li>`388.7_0_rog`</li>                                                                                                                               | <a href="https://amzn.to/3VUNbHl" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT-AX6000](https://asusrouter.vaskivskyi.com/devices/GT-AX6000.md)                            | 💛 Expected to work | Merlin:<li>`388.7_beta1`</li>                                                                                                                                                         | <a href="https://amzn.to/3GrKHKG" rel="nofollow sponsored" target="_blank">find it</a> |
  | [GT6](https://asusrouter.vaskivskyi.com/devices/GT6.md)                                        | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3GmPCfR" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RP-AX56](https://asusrouter.vaskivskyi.com/devices/RP-AX56.md)                                | 💚 Confirmed        |                                                                                                                                                                                       | <a href="https://amzn.to/3MpZSY8" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX3000P](https://asusrouter.vaskivskyi.com/devices/RT-AX3000P.md)                          | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3RPa2UO" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX52](https://asusrouter.vaskivskyi.com/devices/RT-AX52.md)                                | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/40Ph3sO" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX53U](https://asusrouter.vaskivskyi.com/devices/RT-AX53U.md)                              | 💚 Confirmed        | Stock:<li>`386.69061`</li>                                                                                                                                                            | <a href="https://amzn.to/49jEgqO" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX5400](https://asusrouter.vaskivskyi.com/devices/RT-AX5400.md)                            | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/4aCdvyu" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX55](https://asusrouter.vaskivskyi.com/devices/RT-AX55.md)                                | 💚 Confirmed        | Stock:<li>`386.50410`</li><li>`386.52041`</li>                                                                                                                                        | <a href="https://amzn.to/3Z2ath5" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX56U](https://asusrouter.vaskivskyi.com/devices/RT-AX56U.md)                              | 💚 Confirmed        | Merlin:<li>`386.7_2`</li><li>`388.1_0`</li><li>`388.2_2`</li>                                                                                                                         | <a href="https://amzn.to/3vrIeuz" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX57](https://asusrouter.vaskivskyi.com/devices/RT-AX57.md)                                | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3IWnZNx" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX57 Go](https://asusrouter.vaskivskyi.com/devices/RT-AX57Go.md)                           | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/47kE9db" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX57M](https://asusrouter.vaskivskyi.com/devices/RT-AX57M.md)                              | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3vbVl6k" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX58U](https://asusrouter.vaskivskyi.com/devices/RT-AX58U.md)                              | 💚 Confirmed        | Stock:<li>`386.49674`</li><li>`388.22237`</li>Merlin:<li>`386.7_2`</li><li>`388.1_0`</li><li>`388.4_0`</li><li>`388.7.0`</li>                                                         | <a href="https://amzn.to/3jHri0L" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX59U](https://asusrouter.vaskivskyi.com/devices/RT-AX59U.md)                              | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3CVCVYO" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX68U](https://asusrouter.vaskivskyi.com/devices/RT-AX68U.md)                              | 💚 Confirmed        | Stock:<li>`388.21732`</li>                                                                                                                                                            | <a href="https://amzn.to/3WzRwk5" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX82U](https://asusrouter.vaskivskyi.com/devices/RT-AX82U.md)                              | 💚 Confirmed        | Stock:<li>`386.48664`</li><li>`386.49674`</li>                                                                                                                                        | <a href="https://amzn.to/3Gv2Bxi" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX86S](https://asusrouter.vaskivskyi.com/devices/RT-AX86S.md)                              | 💚 Confirmed        | Stock:<li>`386.46061`</li><li>`386.48260`</li><li>`386.49447`</li><li>`388.22525`</li>Merlin:<li>`386.7_2`</li>                                                                       | <a href="https://amzn.to/3GuKac5" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX86U](https://asusrouter.vaskivskyi.com/devices/RT-AX86U.md)                              | 💚 Confirmed        | Stock:<li>`386.46061`</li><li>`386.48260`</li><li>`386.49447`</li><li>`388.22525`</li>Merlin:<li>`386.7_2`</li><li>`388.4_0`</li><li>`388.7_beta1`</li>                               | <a href="https://amzn.to/3WCBcPO" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX86U Pro](https://asusrouter.vaskivskyi.com/devices/RT-AX86UPro.md)                       | 💚 Confirmed        | Stock:<li>`388.23565`</li>                                                                                                                                                            | <a href="https://amzn.to/3ZDM41T" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX88U](https://asusrouter.vaskivskyi.com/devices/RT-AX88U.md)                              | 💚 Confirmed        | Stock:<li>`386.45934`</li><li>`386.48631`</li><li>`388.24198`</li>Merlin:<li>`386.5_2`</li><li>`386.8_0`</li><li>`388.1_0`</li><li>`388.2_0`</li><li>`388.4_0`</li><li>`388.7_0`</li> | <a href="https://amzn.to/3i2VfYu" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX88U Pro](https://asusrouter.vaskivskyi.com/devices/RT-AX88UPro.md)                       | 💚 Confirmed        | Merlin:<li>`388.4_0`</li>                                                                                                                                                             | <a href="https://amzn.to/3QNDpFZ" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX89X](https://asusrouter.vaskivskyi.com/devices/RT-AX89X.md)                              | 💚 Confirmed        |                                                                                                                                                                                       | <a href="https://amzn.to/3i55b3S" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AX92U](https://asusrouter.vaskivskyi.com/devices/RT-AX92U.md)                              | 💚 Confirmed        | Stock:<li>`386.46061`</li>                                                                                                                                                            | <a href="https://amzn.to/3jJJgzt" rel="nofollow sponsored" target="_blank">find it</a> |
  | [TUF-AX3000 V2](https://asusrouter.vaskivskyi.com/devices/TUF-AX3000V2.md)                     | 💚 Confirmed        | Stock:<li>`388.23785`</li>                                                                                                                                                            | <a href="https://amzn.to/3QzzD4C" rel="nofollow sponsored" target="_blank">find it</a> |
  | [TUF-AX4200](https://asusrouter.vaskivskyi.com/devices/TUF-AX4200.md)                          | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3kexPjC" rel="nofollow sponsored" target="_blank">find it</a> |
  | [TUF-AX5400](https://asusrouter.vaskivskyi.com/devices/TUF-AX5400.md)                          | 💚 Confirmed        | Stock:<li>`386.50224`</li><li>`388.21224`</li><li>`388.22525`</li><li>`388.23285`</li><li>`388.24121`</li>Merlin:<li>`388.4_0`</li>                                                   | <a href="https://amzn.to/3hXgzyQ" rel="nofollow sponsored" target="_blank">find it</a> |
  | [TUF-AX6000](https://asusrouter.vaskivskyi.com/devices/TUF-AX6000.md)                          | 💚 Confirmed        | Stock:<li>`388.32432`</li>                                                                                                                                                            | <a href="https://amzn.to/3CXqxaG" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi AX (XT8)](<https://asusrouter.vaskivskyi.com/devices/ZenWiFiAX(XT8).md>)              | 💚 Confirmed        | Stock:<li>`386.48706`</li><li>`388.23285`</li>Merlin:<li>`386.7_2-gnuton1`</li>                                                                                                       | <a href="https://amzn.to/3GuvY2L" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi AX Hybrid (XP4)](<https://asusrouter.vaskivskyi.com/devices/ZenWiFiAXHybrid(XP4).md>) | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3Itxnbb" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi AX Mini (XD4)](<https://asusrouter.vaskivskyi.com/devices/ZenWiFiAXMini(XD4).md>)     | 💚 Confirmed        | Stock:<li>`386.48790`</li><li>`386.49599`</li>                                                                                                                                        | <a href="https://amzn.to/3hYGuGl" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi Pro XT12](https://asusrouter.vaskivskyi.com/devices/ZenWiFiProXT12.md)                | 💚 Confirmed        | Stock:<li>`388.22127`</li>                                                                                                                                                            | <a href="https://amzn.to/3im6UC5" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi XD4 Plus](https://asusrouter.vaskivskyi.com/devices/ZenWiFiXD4Plus.md)                | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3XtYOWp" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi XD4S](https://asusrouter.vaskivskyi.com/devices/ZenWiFiXD4S.md)                       | 💛 Expected to work |                                                                                                                                                                                       | <a href="https://amzn.to/3E341xI" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi XD5](https://asusrouter.vaskivskyi.com/devices/ZenWiFiXD5.md)                         | 💚 Confirmed        | Stock:<li>`388.23949`</li>                                                                                                                                                            | <a href="https://amzn.to/3YrhgjM" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi XD6](https://asusrouter.vaskivskyi.com/devices/ZenWiFiXD6.md)                         | 💚 Confirmed        | Stock:<li>`388.21380`</li>                                                                                                                                                            | <a href="https://amzn.to/3jW23s4" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi XD6S](https://asusrouter.vaskivskyi.com/devices/ZenWiFiXD6S.md)                       | 💚 Confirmed        | Stock:<li>`388.21380`</li>                                                                                                                                                            | <a href="https://amzn.to/3YMbyIZ" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi XT9](https://asusrouter.vaskivskyi.com/devices/ZenWiFiXT9.md)                         | 💚 Confirmed        | Stock:<li>`388_23285`</li>                                                                                                                                                            | <a href="https://amzn.to/3JZOgLF" rel="nofollow sponsored" target="_blank">find it</a> |



  | Model                                                                                     | Status              | Tested firmware                                                                                             | Find it on Amazon[^amazon]                                                             |
  | ----------------------------------------------------------------------------------------- | ------------------- | ----------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
  | [4G-AC55U](https://asusrouter.vaskivskyi.com/devices/4G-AC55U.md)                         | 💚 Confirmed        | Stock:<li>`380.8102`</li>                                                                                   | <a href="https://amzn.to/3jIWQDu" rel="nofollow sponsored" target="_blank">find it</a> |
  | [BRT-AC828](https://asusrouter.vaskivskyi.com/devices/BRT-AC828.md)                       | 💚 Confirmed        | Stock:<li>`382_70348`</li>                                                                                  | <a href="https://amzn.to/3X2wSL5" rel="nofollow sponsored" target="_blank">find it</a> |
  | [DSL-AC68U](https://asusrouter.vaskivskyi.com/devices/DSL-AC68U.md)                       | 💚 Confirmed        | Stock:<li>`386.47534`</li><li>`386.50117`</li>Merlin:<li>`386.4-gnuton2`</li><li>`386.7_2-gnuton1`</li>     | <a href="https://amzn.to/3Z5k32H" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC51U](https://asusrouter.vaskivskyi.com/devices/RT-AC51U.md)                         | 💚 Confirmed        | Stock:<li>`380.8591`</li>                                                                                   | <a href="https://amzn.to/3WMy2sq" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC52U B1](https://asusrouter.vaskivskyi.com/devices/RT-AC52UB1.md)                    | 💚 Confirmed        |                                                                                                             | <a href="https://amzn.to/3QcrCkk" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC5300](https://asusrouter.vaskivskyi.com/devices/RT-AC5300.md)                       | 💚 Confirmed        | Merlin:<li>`386.7_2`</li>                                                                                   | <a href="https://amzn.to/3ZcJQpY" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC57U V3](https://asusrouter.vaskivskyi.com/devices/RT-AC57UV3.md)                    | 💚 Confirmed        | Stock:<li>`386.21649`</li>                                                                                  | <a href="https://amzn.to/3VAxDbx" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC58U](https://asusrouter.vaskivskyi.com/devices/RT-AC58U.md)                         | 💚 Confirmed        |                                                                                                             | <a href="https://amzn.to/3G98Mpl" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC66U](https://asusrouter.vaskivskyi.com/devices/RT-AC66U.md)                         | 💚 Confirmed        | Merlin:<li>`380.70_0`</li>                                                                                  | <a href="https://amzn.to/3WTtTD8" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC66U B1](https://asusrouter.vaskivskyi.com/devices/RT-AC66UB1.md)                    | 💚 Confirmed        | Stock:<li>`386.51255`</li>                                                                                  | <a href="https://amzn.to/3vtZ4Jm" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC68U](https://asusrouter.vaskivskyi.com/devices/RT-AC68U.md)                         | 💚 Confirmed        | Stock:<li>`386.49703`</li>Merlin:<li>`386.5_2`</li><li>`386.7_0`</li>                                       | <a href="https://amzn.to/3i6dQTE" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC85P](https://asusrouter.vaskivskyi.com/devices/RT-AC85P.md)                         | 💚 Confirmed        | Stock:<li>`382.52516`</li>                                                                                  | <a href="https://amzn.to/3kMiDdU" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC86U](https://asusrouter.vaskivskyi.com/devices/RT-AC86U.md)                         | 💚 Confirmed        | Stock:<li>`386.48260`</li><li>`386.49709`</li>Merlin:<li>`386.7_0`</li><li>`386.7_2`</li><li>`386.9_0`</li> | <a href="https://amzn.to/3CbRarK" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC87U](https://asusrouter.vaskivskyi.com/devices/RT-AC87U.md)                         | 💚 Confirmed        | Merlin:<li>`384.13_10`</li>                                                                                 | <a href="https://amzn.to/3i4sUkE" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-AC88U](https://asusrouter.vaskivskyi.com/devices/RT-AC88U.md)                         | 💚 Confirmed        | Stock:<li>`386.48260`</li>Merlin:<li>`386.5_0`</li><li>`386.7_beta1`</li><li>`386.12_2`</li>                | <a href="https://amzn.to/3FYRYBy" rel="nofollow sponsored" target="_blank">find it</a> |
  | [RT-ACRH17](https://asusrouter.vaskivskyi.com/devices/RT-ACRH17.md)                       | 💚 Confirmed        | Stock:<li>`382.52517`</li>                                                                                  | <a href="https://amzn.to/3i6dWL0" rel="nofollow sponsored" target="_blank">find it</a> |
  | [ZenWiFi AC Mini(CD6)](<https://asusrouter.vaskivskyi.com/devices/ZenWiFiACMini(CD6).md>) | 💛 Expected to work |                                                                                                             | <a href="https://amzn.to/3RU7vrL" rel="nofollow sponsored" target="_blank">find it</a> |



  | Model                                                           | Status       | Tested firmware | Find it on Amazon[^amazon]                                                             |
  | --------------------------------------------------------------- | ------------ | --------------- | -------------------------------------------------------------------------------------- |
  | [RT-N66U](https://asusrouter.vaskivskyi.com/devices/RT-N66U.md) | 💚 Confirmed |                 | <a href="https://amzn.to/3i7eP5Z" rel="nofollow sponsored" target="_blank">find it</a> |





  If you have found an issue working with the library or just want to ask for a new feature, please fill in a new [issue](https://github.com/Vaskivskyi/asusrouter/issues).

  You are also welcome to submit [pull requests](https://github.com/Vaskivskyi/asusrouter/pulls) to the repository!



  Testing the library with different devices would help a lot in the development process. Unfortunately, currently, I have only one device available, so your help would be much appreciated.



  This library is a free-time project. If you like it, you can support me by buying a coffee.

  <a href="https://www.buymeacoffee.com/vaskivskyi" target="_blank"><img src="https://asusrouter.vaskivskyi.com/BuyMeACoffee.png" alt="Buy Me A Coffee" style="height: 60px !important;"></a>

  [^amazon]: As an Amazon Associate I earn from qualifying purchases. Not like I ever got anything yet (:


pkgId: d43c0aa768e58e6c1a248fc0d1bf934eed80f485efdfec4e9d13dae3bf2d5909
name: python-asv
arch: src
version: 0.6.4
epoch: 0
release: 1
summary: Airspeed Velocity: A simple Python history benchmarking tool
url: https://pypi.org/project/asv/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asv-0.6.4-1.src.rpm
checksum_type: sha256
description:
  **airspeed velocity** (``asv``) is a tool for benchmarking Python
  packages over their lifetime.
  It is primarily designed to benchmark a single project over its
  lifetime using a given suite of benchmarks.  The results are displayed
  in an interactive web frontend that requires only a basic static
  webserver to host.
  See an `example airspeed velocity site <https://pv.github.io/numpy-bench/>`__.
  See the `full documentation <https://asv.readthedocs.io/>`__
  for more information.
  The latest release can be installed from PyPI using::
      pip install asv
  Are you using ``asv``?  Consider adding a badge to your project's
  README like this:
  By using the following markdown::
    [![asv](http://img.shields.io/badge/benchmarked%20by-asv-blue.svg?style=flat)](http://your-url-here/)
  License: `BSD three-clause license
  <http://opensource.org/licenses/BSD-3-Clause>`__.
  Authors: Michael Droettboom, Pauli Virtanen, asv Developers


pkgId: a623c839f83674820af518d9f6fed6152ddfde7253bb05ea57cfeda0212741ab
name: python-aswan
arch: src
version: 0.5.15
epoch: 0
release: 1
summary: Data collection manager
url: https://github.com/endremborza/aswan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aswan-0.5.15-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/aswan/badge/?version=latest)](https://aswan.readthedocs.io/en/latest)
  [![codeclimate](https://img.shields.io/codeclimate/maintainability/endremborza/aswan.svg)](https://codeclimate.com/github/endremborza/aswan)
  [![codecov](https://img.shields.io/codecov/c/github/endremborza/aswan)](https://codecov.io/gh/endremborza/aswan)
  [![pypi](https://img.shields.io/pypi/v/aswan.svg)](https://pypi.org/project/aswan/)
  [![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.7477587.svg)](https://doi.org/10.5281/zenodo.7477587)

  collect and organize data into a T1 data depot
  named after the [Aswan Dam](https://en.wikipedia.org/wiki/Aswan_Dam)

  Collect and compress data from the internet for later parsing

  - quick, parallel, customizable to collect
  - compressed to store
  - quick to sync with a remote store
    - sync to continue collecting
    - sync to parse
  - immutable collection



  set the environment variables `ASWAN_AUTH_HEX` and `ASWAN_AUTH_PASS` according to the [zimmauth](https://github.com/endremborza/zimmauth) package, and `ASWAN_REMOTE` with the name of the default remote.



  - objects
    - saved by collection events
  - events
    - collection
    - registration (v2: registration for parsing)
    - (v2) parsing
  - runs
    - manual run vs automated run
      - makes manual adding of urls easy but revertible
    - has unique id
    - generates events
    - linked to a specific version of the code
      - ideally commit hash + pip freeze
  - statuses
    - determined by base status + runs integrated
    - contains
      - what urls need to be collected
      - (v2) what collected objects need to be parsed
    - sqlite file, constantly trimmed



  - objects
    - 00, 01, ...
  - runs
    - run-hash
        - context.yaml
          - commit-hash, pip-freeze, ...
        - events.zip
  - statuses
    - status-hash
      - context.yaml
        - parent-status, integrated
      - db.sqlite.zip
  - current-run
    - context.yaml
    - events
      - these to be compressed into ../runs
    - status.sqlite

  - there is a 'TEST' status
    - cannot be integrated whatever is based on it
    - a test run can be made on it...


  when starting a run:
    - check if current-run is empty
      - if not, fail with
    - find latest status
      - if it has not integrated all past runs, create a new status that has
    - start collection (+ registration)
    - either stops or breaks, all events and objects are saved to disk
    - if properly stops, move and compress stuff
      - based on one that was the starter, and current run id




  - parallelize push / pull
  - parsing/connection/broken session error docs
  - transferring / ignoring cookies


  - template projects
    - oddsportal
      - updating thingy, based on latest match in season
    - footy
    - rotten
    - boxoffice


pkgId: 914bafd8477df5f8aea670257c9489e84f6e1af525701c903909eefa987b1a89
name: python-asymintervals
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Python Library for Asymmetric Interval Numbers
url: https://github.com/wsalabun/asymintervals
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asymintervals-1.1.1-1.src.rpm
checksum_type: sha256
description:
  The `asymintervals` library introduces a novel and unique approach with **Asymmetric Interval Numbers (AINs)**, combining the simplicity of classical interval numbers with advanced capabilities for modeling uncertainty.

  AINs integrate the expected value with the interval, offering a more accurate representation of data uncertainty compared to traditional interval numbers. This library provides a complete toolkit, including basic arithmetic operations. The theoretical foundations of AINs, along with detailed discussions on properties, rigorous mathematical proofs, and theorems on symmetry and asymmetry for both binary and unary operations, are introduced in [1], further enhancing the mathematical framework of AINs. Practical examples illustrate the versatility of AINs in various scientific and technical applications. AINs represent a significant advancement in interval arithmetic, paving the way for further research and applications across diverse fields.

  Documentation is avaliable on [readthedocs](https://asymintervals.readthedocs.io/en/latest/).




  You can download and install `asymintervals` library using pip:

  ```Bash
  pip install asymintervals
  ```

  You can run all tests with following command from the root of the project:

  ```Bash
  python -m doctest -v asymintervals\asymintervals.py
  ```



  A simple example demonstrating how to use the library.

  ```python

  from asymintervals import AIN
  import matplotlib.pyplot as plt


  a = AIN(0, 10, 2)  # Interval 'a' with lower=0, upper=10, expected=2
  b = AIN(2, 8, 3)   # Interval 'b' with lower=2, upper=8, expected=3


  c = a + b          # Addition of intervals 'a' and 'b'
  d = a * b          # Multiplication of intervals 'a' and 'b'
  e = a / b          # Division of interval 'c' by interval 'd'


  c.plot()           # Plot interval 'c' resulting from addition
  d.plot()           # Plot interval 'd' resulting from multiplication
  e.plot()           # Plot interval 'e' resulting from division


  print(c)           # Output the details of interval 'c'
  print(d)           # Output the details of interval 'd'
  print(e)           # Output the details of interval 'e'


  print("Summary for interval 'a':")
  a.summary()
  print("Summary for interval 'b':")
  b.summary()
  print("Summary for interval 'c':")
  c.summary()
  print("Summary for interval 'd':")
  d.summary()
  print("Summary for interval 'e':")
  e.summary()
  ```




  If the `asymintervals` library has contributed to a scientific publication, we kindly request acknowledgment by citing it.

  ```plaintext
  [1] Sałabun, W. (2024). Asymmetric Interval Numbers: a new approach to modeling uncertainty.
      Fuzzy Sets and Systems, (in press).
  ```

  ```bibtex
  @article{salabun2024,
     title={Asymmetric Interval Numbers: a new approach to modeling uncertainty},
     author={Sałabun, Wojciech},
     journal={Fuzzy Sets and Systems},
     volume={in press},
     number={in press},
     pages={in press},
     year={2024},
     publisher={Elsevier}
  }
  ```


pkgId: 9fc172853a5548ae78277db30b7695d80eeafd09cd30d48913d032b8d86be937
name: python-asymmetree
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Simulation of phylogenetic trees, sequences and genomes
url: https://github.com/david-schaller/AsymmeTree
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asymmetree-2.2.1-1.src.rpm
checksum_type: sha256
description:
  ![Logo](resources/images/logo.png)

  [![license: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  [![pypi version](https://img.shields.io/badge/pypi-v2.2.1-blue.svg)](https://pypi.org/project/asymmetree/)

  AsymmeTree is an open-source Python library for the simulation and analysis of phylogenetic scenarios.
  It includes a simulator for species and gene trees with heterogeneous evolution rates, nucleotide and amino acid sequences with or without indels, as well as whole genomes/proteomes.

  Moreover, it includes a matplotlib-based visualization of the simulated trees as well as tools for the extraction of information from the simulated scenarios such as orthology, best matches, and xenology.

  The library is primarily designed to explore and validate mathematical concepts, and to test inference methods for various steps on the way to more realistically-available data, i.e., dated gene trees, additive distances of gene sets, noisy distances and finally sequences.




  AsymmeTree requires Python 3.7 or higher.



  The `asymmetree` package is available on PyPI:

      pip install asymmetree

  For details about how to install Python packages see [here](https://packaging.python.org/tutorials/installing-packages/).



  Alternatively, you can download or clone the repo, go to the root folder of package and install it using the command:

      python setup.py install



  AsymmeTree has several dependencies (which are installed automatically when using `pip`):
  * [NetworkX](https://networkx.github.io/)
  * [Scipy and Numpy](http://www.scipy.org/install.html)
  * [Matplotlib](https://matplotlib.org/)
  * [tralda](https://github.com/david-schaller/tralda)



  A user manual with example code can be found in the [Wiki](https://github.com/david-schaller/AsymmeTree/wiki/Manual).
  AsymmeTree is divided into several subpackages and modules, see also the following [documentation](https://david-schaller.github.io/docs/asymmetree/) generated from the source code.



  If you use AsymmeTree in your project or code from it, please consider citing:

  * **David Schaller, Marc Hellmuth, and Peter F. Stadler. AsymmeTree: A Flexible Python Package for the Simulation of Complex Gene Family Histories. Software 2022, 1(3), 276-298; doi: 10.3390/software1030013**

  Please report any bugs and questions in the [Issues](https://github.com/david-schaller/AsymmeTree/issues) section.
  Also, feel free to make suggestions for improvement and/or new functionalities.


pkgId: 41b9c5621fcf6a7470cf8cfb2b302cb36eeed06801b0534b003fe5a4f965875e
name: python-asynapplicationinsights
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Azure Application Insights client using asyncio
url: https://github.com/RobertoPrevato/asynapplicationinsights
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-asynapplicationinsights-0.0.4-1.src.rpm
checksum_type: sha256
description:
  `Azure Application Insights <https://azure.microsoft.com/en-us/services/application-insights/>`_ Python SDK using asyncio, including a middleware for *aiohttp* web framework.
  Why
  ````````````````````````````````````````````````````````````````
  The official `Python SDK for Application Insights <https://github.com/Microsoft/ApplicationInsights-Python>`_ from Microsoft is designed to work with both 2.x and 3.x versions of Python language.
  This repository contains an alternative Python SDK for Application Insights with support for ``asyncio`` and ``async/await`` syntax, targeting Python >=3.6 and also taking advantage of support for type hinting, available since recent versions of Python language.
  To install:
      >>> pip install asynapplicationinsights


pkgId: 25e7788f65fe6aa405f0db73e9b7e7fe1afd486930a56a2390626bf23373d284
name: python-async-VKsher
arch: src
version: 2.2.5
epoch: 0
release: 1
summary: asyncVK is asynchronous library for creating a bot in VK
url: https://github.com/Ekventor/asyncVK
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-VKsher-2.2.5-1.src.rpm
checksum_type: sha256
description:
  asyncVK – асинхронный фреймворк для создания ботов ВК. Преимущества: удобство, скорость выигрываемая за счёт асинхронности.
  =

  Бот создаётся за счёт пяти основных структурных единиц:
  1) Bot – это самая главная структурная единица. Это собственно сам бот, который подаёт ивенты     обработчикам.
  2) Handler – эта структурная единица отвечает за обработку ивентов.
  3) Dispatcher – эта структурная единица отвечает за взаимодействие с ВК (ответы на сообщения, добавление комментариев). Она автоматически настраивается хандлерами.
  4) Condition (Condition, And, Or) – эта структурная единица отвечает за условия. С помощью неё можно строить сложные условия для хандлеров.
  5) Chain - эта структурная единица позволяет создавать цепочки команд.

  Также есть такие второстепенные структурные единицы как:
  1) Keyboard – это второстепенная структурная единица. Она отвечает за создание кнопок в ВК.
  2) Message - структура сообщения для облегчения работы с сообщениями.

  Как работать с библиотекой? Легко и интуитивно понятно! Для начала нужно импортировать саму библиотеку и создать бота:
  ```python
  from asyncVK import Handler, Bot, run_polling
  from asyncVK.dispatcher import Dispatcher
  from asyncVK.condition import Condition, And, Or


  TOKEN = "access_token"
  GROUP_ID = 182801600

  bot = Bot(TOKEN, GROUP_ID)
  ```

  Теперь мы можем запустить бота на `LongPoll API`:
  ```python
  if __name__ == "__main__":
      run_polling(bot)
  ```

  Сейчас бот запущен, но ни на что не реагирует. Чтобы это исправить нам нужно создать обработчик и добавить его в бота. Как это сделать? Вот так:
  ```python
  @bot.handle
  @Handler.on.message_new(Condition(command="привет!"), is_lower=True)
  async def handler(dispatcher: Dispatcher):
      await dispatcher.send_message("Hi!")
  ```

  В примере выше мы создали обработчик новых сообщений с помощью декоратора `@Handler.on.message_new` и добавили его в бота с помощью декоратора `@bot.handle`.
  Вместо декоратора `@bot.handle` можно конечно прописать `bot.handle(handler)`

  Как работают хандлеры (обработчики)? Когда мы засовываем экземпляр класса Bot в функцию `run_polling`, мы как бы активируем метод `bot.run_polling`. `bot.run_polling` это бесконечный цикл. В экземпляре класса Bot есть список всех хандлеров, которые мы создали и добавили в него. И когда приходит какой-то ивент (событие), то этот цикл пересылает это событие всем хандлерам. И потом если условие истинно, то активируется функция, из которой мы сделали хандлер.

  Что делает эта асинхронная функция? Она на сообщение "привет!" (в любом регистре) будет отвечать в тот же чат сообщением "Hi!". Как сделать чтобы она ответила не в тот же чат, а в ЛС? Легко! Заменить
  ```python
  await dispatcher.send_message("Hi!")
  ```
  на
  ```python
  await dispatcher.answer("Hi!")
  ```

  Как строить условия? Какие условия можно построить? Строить условия легко, и можно построить абсолютно любые условия! Например мы хотим, чтобы бот отвечал на привет. В таком случае мы пишем:
  ```python
  Condition(command="привет")
  ```
  Или мы хотим, чтобы бот отвечал на привет или если `peer_id` равен 2000000001. В таком случае мы пишем:
  ```python
  Condition(command="привет", peer_id=2000000001)
  ```
  То есть прописывая дополнительные условия в Condition, мы как бы делаем `if command == "привет" or peer_id == 2000000001`. Также можно аналогично прописать вот так:
  ```python
  Or(Condition(command="привет"), Condition(peer_id=2000000001))
  ```
  Но лучше так не делать, лучше подобные условия прописывать без Or.

  А что если мы хотим, чтобы бот отвечал либо если ему написали "привет", либо если в сообщении есть строка "а" и написал это пользователь с id 386746383. Тоже легко! Вот так:
  ```python
  Or(
      Condition(command="привет"),
      And(Condition(contains_command="a"), Condition(user_id=386746383))
  )
  ```

  И так, давайте разбирать как же строить так любые запросы. Если мы пропишем несколько аргументов в `Condition`, то это будет ИЛИ (or). Если же мы засунем несколько условий в `And`, то тут условие будет истинным если все условия в `And` истинны, то есть это И (and). Если же мы засунем несколько условий в `Or`, то условие будет истинным если истинно хотя бы одно условие в нём, то есть это ИЛИ (or). В `And` и `Or` можно засовывать как и `Condition`, так и другие `And` и `Or`.
  Стоит также заметить, что хандлер без условия будет срабатывать всегда, когда активируется нужное событие (то есть вне зависимости от условий, наверное потому что их нет) - `@Handler.on.message_new()`

  Вот все аргументы Condition:

      command – проверяет на равенство текста (если сообщение, то текста сообщения и т.д.) с этим аргументом.
      contains_command – проверяет на то, есть ли строка contains_command в тексте.
      user_id – проверяет на равенство id пользователя, инициировавшего событие, и этим аргументом.
      peer_id – проверяет на равенство id чата с этим аргументом.
      post_id – проверяет на равенство id записи на стене/id записи в обсуждениях с этим аргументом.
      owner_id – проверяет на равенство id сообщества, где произошло событие (если событие было в сообществе).

  Вот весь список хандлеров:

      Handler.on.message_new – новое сообщение.
      Handler.on.message_edit – редактирование сообщения.
      Handler.on.wall_reply_new – новые комментарий на стене.
      Handler.on.wall_reply_edit – редактирование комментария на стене.
      Handler.on.wall_post_new – новый пост на стене.
      Handler.on.board_post_new – новый комментарий в обсуждениях.
      Handler.on.board_post_edit – редактирование комментария в обсуждениях.

  Списки их аргументов абсолютно идентичны.

  Возможности диспетчера:

      dispatcher.answer – ответить в ЛС. Можно активировать при любом событии, отправит сообщение инициатору события. Список аргументов:
  		text – текст сообщения.
  		attachment – вложение сообщения (в виде части ссылки такого рода:
  		    от ссылки https://vk.com/id386746383?z=photo386746383_457256628%2Falbum386746383_0
  		    берём только photo386746383_457256628 и передаём это в качестве аргумента).
  		keyboard – кнопки ВК.
  		Возвращает структуру Message вашего сообщения.

      dispatcher.reply - ответить на сообщение пользователя. Список аргументов и возвращаемое значение идентичны с answer.
      dispatcher.send_message – ответить в том же чате. Список аргументов и возвращаемое значение идентичны с answer.
      dispatcher.send_comment – ответить в комментариях. Список аргументов идентичен с answer, но аргумент keyboard отсутствует.
      dispatcher.mark_as_read – пометить сообщение как "прочитанное". Никаких аргументов не принимает.
      dispatcher.set_typing_status – установить статус на набор текста / запись голосового сообщения. Принимает один аргумент:
          	typing_status. Его значение по умолчанию "typing" (набор текста). Можно изменить на "audiomessage" – запись голосового сообщения.
      dispatcher.kick_user - удаляет участника из беседы
          	member_id - id участника беседы (id сообщества пишется со знаком -)
      dispatcher.edit_chat_name - изменяет название беседы
          	title - новое название беседы

  Пример использования структуры Message:
  ```python
  @bot.handle
  @Handler.on.message_new(Condition(command="прив"))
  async def handler(dispatcher: Dispatcher):
      message = await dispatcher.reply("Это сообщение исчезнет через 3 секунды, а твоё сообщение будет закреплено")
      await asyncio.sleep(1)
      await message.edit("Это сообщение исчезнет через 2 секунды, а твоё сообщение будет закреплено")
      await asyncio.sleep(1)
      await message.edit("Это сообщение исчезнет через 1 секунду, а твоё сообщение будет закреплено")
      await asyncio.sleep(1)
      await message.delete()
      await dispatcher.message.pin()
  ```

  Можно строить любые запросы, даже если этого не предполагает отсутствие метода в диспетчере:
  ```python
  @bot.handle
  @Handler.on.message_new(Condition(contains_command="прив"), is_lower=True)
  async def handler(dispatcher: Dispatcher):
      result = await bot.execute("messages.send", peer_id=dispatcher.peer_id,
                                 message="okay", random_id=0)
      print(result)
  ```
  В этом примере мы на новое сообщение, содержащее "прив" отвечаем "okay" нашим построенным запросом. `peer_id` же берём из диспетчера.

  Параметры диспетчера:

      dispatcher.token - ваш токен
      dispatcher.user_id - id инициировавшего событие пользователя
      dispatcher.peer_id - id чата (если это ЛС, то peer_id равен user_id)
      dispatcher.post_id - id записи на стене или обсуждения (если событие это новая запись на стене, новый комментарий на стене или в обсуждении)
      dispatcher.owner_id - если событие было внутри группы, то owner_id это id группы
      dispatcher.object_id - id объекта события
      dispatcher.event - объект события
      dispatcher.text - если к примеру событие это новое сообщение, то text это текст сообщения, если это к примеру новый комментарий, то text это текст комментария и т.д.
      dispatcher.reply_text - текст отвеченного сообщения (если таковое имеется)
      dispatcher.reply_user_id - id пользователя написавшего отмеченное сообщение (если таковое имеется)
      dispatcher.reply_peer_id - id чата отмеченного сообщения (если таковое имеется)
      dispatcher.reply_object_id - id объекта ответа
      dispatcher.action_type - тип действия
      dispatcher.action_text - текст действия
      dispatcher.action_object_id - id объекта действия
      dispatcher.action_member_id - id пользователя, инициировавшего действие
      dispatcher.payload - payload
      dispatcher.message - выдаёт структуру Message для сообщения из события
      dispatcher.reply_message - выдаёт структуру Message для отвеченного сообщения из события

  Возможность структуры Message:

      message.edit - изменить сообщение
      		text - новый текст
  		attachment - вложение
   		keyboard - клавиатура
      message.pin - закрепить сообщение
      message.delete - удалить сообщение

  Если вы хотите выполнить сразу несколько запросов асинхронно, то можно просто воспользовать библиотекой `asyncio`. К примеру:
  ```python
  @bot.handle
  @Handler.on.message_new(Condition(contains_command="прив"), is_lower=True)
  async def handler(dispatcher: Dispatcher):
      tasks = [asyncio.create_task(dispatcher.mark_as_read()),
               asyncio.create_task(dispatcher.set_typing_status()),
               asyncio.create_task(asyncio.sleep(9))]

      await asyncio.gather(*tasks)
      await dispatcher.send_message("okay")


  @bot.handle
  @Handler.on.message_new(Condition(contains_command="а"), is_lower=True)
  async def handler(dispatcher: Dispatcher):
      await dispatcher.send_message("Б!")
  ```
  Хандлер, обрабатывающий сообщение, где есть строка "прив" сперва пометит сообщение как прочитанное, потом установит статус "печатает…" и через 9 секунд отправит сообщение "okay" и всё это асинхронно.
  > P.S. хандлеры друг друга не блокируют, так что во время работы первого хандлера вы можете написать "а" и бот ответит "Б!", несмотря на работу первого хандлера.

  По-мимо этого можно делать хандлеры не для условий, а для всего события целиком. Например:
  ```python
  @bot.handle
  @Handler.on("message_new")
  async def handler(dispatcher: Dispatcher):
      if dispatcher.text.lower() == "abs":
          await dispatcher.send_message("peer")
      elif dispatcher.text.lower() == "help me":
          await dispatcher.send_message("no")
  ```
  Этот хандлер будет обрабатывать все события типа `message_new`. В данном случае он на "abs" будет отвечать "peer", а на "help me" будет отвечать "no". И также регистр сообщения не важен, ибо мы применили метод `lower`.

  Так можно делать обработчики для любых событий. К примеру обработчик для новых комментариев:
  ```python
  @bot.handle
  @Handler.on("wall_reply_new")
  async def handler(dispatcher: Dispatcher):
      if dispatcher.text.lower() == "nice":
          await dispatcher.send_comment("ok")
      elif dispatcher.text.lower() == "not bad":
          await dispatcher.send_comment("no, very bad!")
  ```

  Какой обработчик использовать? Для условий или для всего события целиком? Если вам нужно сделать обработчик для простых команд (ответить на то этим и что-то в этом роде), то лучше все эти команды прописать в обработчике события, в данном случае это будет `@Handler.on("message_new")` ведь нам нужно отвечать на сообщения. А если же команды сложные, а не простые ответы с какими-то дополнительными действиями, то лучше их прописать в обработчике условия. К примеру нам нужно, чтобы при сообщении "статистика" бот получил статистику откуда-то, рассортировал и отфильтровал её и потом отправил. Такое лучше прописывать в обработчике условия, в данном случае `@Handler.on.message_new(Condition(command="статистика"))`
  Но нужно смотреть на код в целом, ибо иногда может пригодится сделать исключение и написать сложную команду в обработчик события, а простую в обработчик условия. То есть выбор должен зависеть от ситуации и структуры вашего кода.

  В хандлерах и в самом боте не предусмотрена синхронизация. Поэтому если вы будете пользоваться асинхронной реализацией, к примеру какой-то базы-данных, будет возможно состояние гонки. А пользоваться синхронными реализациями базы-данных плохая идея, это снизит скорость бота. Такая структура позволяет боту быть очень быстрым. Но в библиотеке присутствует синхронизатор, с помощью которого вы можете гарантировать, что команды исполнятся точно в таком порядке, в котором они начались. Таких синхронизаторов можно использовать несколько.
  ```python
  from asyncVK.sync import Synchronizer
  ```
  ```python
  synchronizer = Synchronizer()
  bot = Bot(TOKEN, GROUP_ID)



  async def create_db():
      async with synchronizer:
          await db.execute("""
              CREATE TABLE IF NOT EXISTS profile (
                  user_id INTEGER,
                  money INTEGER
              )
          """)


  @bot.handle
  @Handler.on("message_new")
  async def handler(dispatcher: Dispatcher):
      if dispatcher.text.lower() == "create db" and dispatcher.user_id == OWNER_ID:
          await create_db()
          await dispatcher.send_message("db was created!")

      elif dispatcher.text.lower() == "register":
          async with synchronizer:
              await db.execute("""
                  INSERT INTO profile
                  VALUES (?, 0)
              """, (dispatcher.user_id,))

          await dispatcher.send_message("you are was registered!")


  @bot.handle
  @Handler.on.message_new(Condition(command="click"), is_lower=True)
  async def handler(dispatcher: Dispatcher):
      async with synchronizer:
          await db.execute("""
              UPDATE profile
              SET money=money+1
              WHERE user_id=(?)
          """, (dispatcher.user_id,))

          state = await db.execute("""
              SELECT money
              FROM profile
              WHERE user_id=(?)
          """, (dispatcher.user_id,))

      money = state[0][0]
      await dispatcher.send_message(f"Money: {money}")
  ```
  `OWNER_ID` это константа, которая должна ваш ID в ВК, это условие запрещает создавать база-данных кому-либо кроме вас командой.
  Что делает `async with synchronizer`?. `async with synchronizer` блокирует выполнение других блоков кода, которые также используют синхронизатор, пока внутри него исполняется код. Как код выполнится, он открывает возможность выполнения следующему в очереди блоку кода в синхронизаторе. Синхронизатор можно использовать с чем угодно, а не только с базами-данных (ОСТОРОЖНО!!! НЕ ЗЛОУПОТРЕБЛЯЙТЕ ИМ!!!)

  В фреймворке также присутствует встроенный функционал создания цепочек. Что такое цепочки? Это когда команда состоит из нескольких частей. То есть, к примеру, регистрация. Вы пишите `/регистрация` и бот далее просит вас ввести имя. И вы вводите своё имя и регистрация пройдена в 2 сообщения, то есть 2 части.

  ```python
  from asyncVK.chain import Chain
  ```

  Таким образом мы импортируем класс цепочек. Как создать цепочку? Всё просто. Вместо `bot.handle` используем `chain.add_handler`, а потом `bot.add_chain(chain)`.

  К примеру:
  ```python
  chain = Chain()


  @chain.add_handler
  @Handler.on.message_new(Condition(contains_command="прив"), is_lower=True)
  async def handler_1(dispatcher: Dispatcher):
      await dispatcher.send_message("Напиши что-то")


  @chain.add_handler
  @Handler.on.message_new(Condition(contains_command="что-то"), is_lower=True)
  async def handler_2(dispatcher: Dispatcher):
      await dispatcher.send_message("Пон")


  bot.add_chain(chain)
  ```

  Или:
  ```python
  chain = Chain()


  @Handler.on.message_new(Condition(contains_command="прив"), is_lower=True)
  async def handler_1(dispatcher: Dispatcher):
      await dispatcher.send_message("Напиши что-то")


  @Handler.on.message_new(Condition(contains_command="что-то"), is_lower=True)
  async def handler_2(dispatcher: Dispatcher):
      await dispatcher.send_message("Пон")


  if __name__ == "__main__":
      chain = Chain()
      chain.add_handler(handler_1)
      chain.add_handler(handler_2)
      bot.add_chain(chain)

      run_polling(bot)
  ```

  Также можно пробрасывать какие-то данные по цепочке:
  ```python
  chain = Chain()


  @Handler.on.message_new(Condition(contains_command="прив"), is_lower=True)
  async def handler_1(dispatcher: Dispatcher):
      await dispatcher.send_message("Напиши что-то")
      return 12


  @Handler.on.message_new(Condition(contains_command="что-то"), is_lower=True)
  async def handler_2(dispatcher: Dispatcher):
      await dispatcher.send_message(f"Пон {dispatcher.chain_data}")


  if __name__ == "__main__":
      chain = Chain()
      chain.add_handler(handler_1)
      chain.add_handler(handler_2)
      bot.add_chain(chain)

      run_polling(bot)
  ```

  В таком случае после `прив` бот ответит `Напиши что-то`, и если после этого вы сразу напишете `что-то`, то бот ответит `Пон 12`. Также напоминаю, что одновременно у одного пользователя может быть только одна активная цепочка. Если же две будут активироваться по одинаковому условию, то всё равно активна будет одна из них.

  Также вместо произвольных данных в цепочке можно возвращать команды. В данном случае `Reject` - это полностью сбросить цепочку и `Reset` - текущий хандлер сработает ещё раз. При `Reset` ваш `chain_data` не сбрасывается.

  К примеру

  ```python
  from asyncVK.chain import Chain, Reset


  chain = Chain()


  @Handler.on.message_new(Condition(contains_command="прив"), is_lower=True)
  async def handler_1(dispatcher: Dispatcher):
      await dispatcher.send_message("Напиши что-то")


  @Handler.on.message_new(is_lower=True)
  async def handler_2(dispatcher: Dispatcher):
      if dispatcher.text != "что-то":
          await dispatcher.send_message("Я жду от тебя что-то")
  	return Reset()

      await dispatcher.send_message("Пон")


  if __name__ == "__main__":
      chain = Chain()
      chain.add_handler(handler_1)
      chain.add_handler(handler_2)
      bot.add_chain(chain)

      run_polling(bot)
  ```
  Во втором хандлере бот будет ждать от тебя слова что-то, и пока ты его не напишешь - он будет срабатывать снова и снова в этой цепочке.

  Пример использования структуры `Message` и `ActionCondition`, бот примет закреплённое сообщение и будет его удерживать в закрепе.
  `ActionCondition` это условие на действие.

  Возможные значения `ActionCondition`:

  	chat_pin_message - закрепление сообщения
   	chat_unpin_message - открепление сообщения
    	chat_title_update - обновление названия беседы
     	chat_photo_update - обновление аватарки беседы
      	chat_photo_remove - удаление аватарки беседы
       	chat_kick_user - удаление пользователя из чата, пользователь вышел из чата
        	chat_invite_user - добавление пользователя в чат


  ```python
  pinned_message = {"object": None}


  @bot.handle
  @Handler.on.message_new(Condition(contains_command="удержи"))
  async def handler(dispatcher: Dispatcher):
      pinned_message["object"] = dispatcher.reply_message
      await pinned_message["object"].pin()
      await dispatcher.send_message("ok")


  @bot.handle
  @Handler.on.message_new(Or(ActionCondition(action="chat_pin_message"),
                             ActionCondition(action="chat_unpin_message")))
  async def handler(dispatcher: Dispatcher):
      await dispatcher.send_message("Не, не выйдет")
      await pinned_message["object"].pin()
  ```

  Методы диспетчера `send_message`, `answer`, `reply` возвращают структуру `Message`

  Пример создания кнопок, а также использования пайлоада через `functional_condition`
  ```python
  def check_payload(event_params: dict) -> bool:
      payload = event_params["payload"]
      if payload.get("answer") == "yes":
          return True
      return False


  @bot.handle
  @Handler.on.message_new(Condition(contains_command="дай"))
  async def handler(dispatcher: Dispatcher):
      keyboard = Keyboard(
          Line(
              Button("да", "positive", {"answer": "yes"})
          ),
          Line(
              Button("нет", "negative", {"answer": "no"}),
              Button("возможно", "default", {"answer": "maybe"})
          ), one_time=True, inline=True
      )

      await dispatcher.send_message("Не дам", keyboard=keyboard)


  @bot.handle
  @Handler.on.message_new(Condition(functional_condition=check_payload))
  async def handler(dispatcher: Dispatcher):
      await dispatcher.send_message("Ок")
      await dispatcher.send_message(f"Ваш пайлоад: {dispatcher.payload}")
  ```

  Также существует `PayloadCondition`, который в отличие от простого `Condition` принимает все аргументы за И, а не ИЛИ по-умолчанию.
  ```python
  @bot.handle
  @Handler.on.message_new(Condition(contains_command="дай"))
  async def handler(dispatcher: Dispatcher):
      keyboard = Keyboard(
          Line(
              Button("да", "positive", {"answer": "yes", "module": "vk"})
          ),
          Line(
              Button("нет", "negative", {"answer": "no"}),
              Button("возможно", "default", {"answer": "yes"})
          ), one_time=True, inline=True
      )

      await dispatcher.send_message("Не дам", keyboard=keyboard)


  @bot.handle
  @Handler.on.message_new(PayloadCondition(answer="yes", module="vk"))
  async def handler(dispatcher: Dispatcher):
      await dispatcher.send_message("Ок")
      await dispatcher.send_message(f"Ваш пайлоад: {dispatcher.payload}")
  ```

  В библиотеке есть возможность создавать шаблоны сообщений для дальнейшей их рассылки
  ```python
  @bot.handle
  @Handler.on.message_new(Condition(contains_command="разошли им"), is_lower=True)
  async def handler(dispatcher: Dispatcher):
      await dispatcher.reply("Окей")

      message = dispatcher.create_message_template("Вам послание, месье", forward=dispatcher.forward)
      await message.send_to("476393332,584575899")
  ```
  В этом коде бот перешлёт сообщение двум пользователям с соответствующими id.
  Можно отправлять сообщения по-одиночному, для этого замените на `await message.send_to(476393332)`


pkgId: 9871ceca604052277871069243c1fa8457daa3f38682d927c76fd27358c3df2f
name: python-async-adbc
arch: src
version: 1.0.17
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/kaluluosi/async-adbc
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-adbc-1.0.17-1.src.rpm
checksum_type: sha256
description:
  [![Test-测试](https://github.com/kaluluosi/async-adbc/actions/workflows/test.yml/badge.svg)](https://github.com/kaluluosi/async-adbc/actions/workflows/test.yml)


  ADBC是ADB Client的纯python异步实现，ADBC直接跟ADB Server通信不需要靠进程调用命令行来执行ADB命令。
  有以下特性：
  1. 支持async/await和同步调用
  2. 封装了一些性能测试相关的方法，供性能采集工具使用
  3. 以`service（服务）`为单位封装命令方法，能够跟 `adb`和`android shell`命令更加一致。




  ```shell
  pip install async-adbc
  ```



  `ADBClient`对应的是`adb`命令

  >**note**
  >当连接设备只有一个的时候，`adb`命令可以省略`-s <serialno>`，但是`ADBClient`不会包含这种默认设备的命令方法。因为`async-adbc`认为`adb`和`device`应该职责分明不应有太多的潜规则。因此用户想要操作某个设备一定要使用`Device`对象下的方法，`Device`下的方法相当于是帮我们默认传递了`-s <serialno>`。

  ```python
  from async_adbc import ADBClient

  adbc = ADBClient() # 默认连接 127.0.0.1:5037 ，也就是本机的adb server
  version = awaitadbc.version() # 对应 `adb version`
  print(version)


  devices = adbc.devices()
  for device in devices:
      print(device.serialno)
  ```


  `Device`对象是对Android设备的抽象，所有需要指定 `-s <serialno>` 的操作都被封装到 `Device` 类中。

  ```python
  from async_adbc import ADBClient

  adbc = ADBClient()


  default_device = adbc.device() # 获取 `adb devices` 的第一个设备

  product_model = await defualt_device.prop.get("ro.product.model")
  print(product_model)


  packages = await default_device.pm.list_packages()
  print(packages)


  ret = await default_device.shell("echo hello")
  print(ret)


  fps_stat = await default_device.fps.stat("PKG_NAME")
  print(fps_stat)


  mem_stat = await default_device.mem.stat("PKB_NAME")
  print(mem_stat)


  ```



  1. adb协议 https://github.com/kaluluosi/adbDocumentation/blob/master/README.zh-cn.md
  2. ppadb https://github.com/Swind/pure-python-adb


pkgId: 6150b571e32dc7eaf6aadea4abdc63df09395b930639c1b9cf7e4b1be26fda26
name: python-async-app
arch: src
version: 1.0.0b30
epoch: 0
release: 1
summary: AsyncIO application as a hierarchy of services
url: https://github.com/Kentzo/async_app/
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-app-1.0.0b30-1.src.rpm
checksum_type: sha256
description:
  - Service-oriented application layout
  - Integrate different asyncio libraries with ease
  - `typing-friendly <https://docs.python.org/3/library/typing.html>`_ Config that can enforce types (via `typeguard <typeguard>`_ or `pytypes <pytypes>`_)


pkgId: 540922909b1578290793dd6460c10f5c6eaa8b8d41bdddb6462b6b72d21f210a
name: python-async-batcher
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A service to batch your http requests.
url: https://github.com/hussein-awala/async-batcher
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-batcher-0.2.1-1.src.rpm
checksum_type: sha256
description:
  This project provides a Python library to batch the asynchronous requests and handle them in batches.



  To use the library, you need to install the package in your environment. You can install the package using pip:

  ```bash
  pip install async-batcher
  ```

  Then, you can create a new `AsyncBatcher` class by implementing the `process_batch` method:

  ```python
  from async_batcher.batcher import AsyncBatcher

  class MyAsyncBatcher(AsyncBatcher):
      async def process_batch(self, batch):
          
          print(batch)


  async_batcher = MyAsyncBatcher(max_batch_size=20)
  async_batcher.start()
  ```



  The benchmark is available in the [BENCHMARK.md](https://github.com/hussein-awala/async-batcher/blob/main/BENCHMARK.md)
  file.



  The `AsyncBatcher` library can be used in any application that needs to handle asynchronous requests in batches,
  such as:
  - Serving machine learning models that optimize the batch processing (e.g. TensorFlow, PyTorch, Scikit-learn, etc.)
  - Storing multiple records in a database in a single query to optimize the I/O operations (or to reduce the cost of the
    database operations, e.g. AWS DynamoDB)
  - Sending multiple messages in a single request to optimize the network operations (or to reduce the cost of the network
    operations, e.g. Kafka, RabbitMQ, AWS SQS, AWS SNS, etc.)


pkgId: 04209866a9d8c1199827f473b3de61c7994156abcba498e43e4f9aaec3e2630f
name: python-async-caches
arch: src
version: 0.3.0
epoch: 0
release: 1
url: https://github.com/rafalp/async-caches
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-caches-0.3.0-1.src.rpm
checksum_type: sha256
summary:
  Caching library reimplementing django.core.cache with async support and type hints, inspired by encode/databases.

description:
  [![Build Status](https://travis-ci.org/rafalp/async-caches.svg?branch=master)](https://travis-ci.org/rafalp/async-caches)
  [![Codecov](https://codecov.io/gh/rafalp/async-caches/branch/master/graph/badge.svg)](https://codecov.io/gh/rafalp/async-caches)
  [![PyPI](https://img.shields.io/badge/release-0.3-green.svg)](https://pypi.org/project/async-caches/)
  [![Documentation](https://img.shields.io/badge/documentation-github.io-blue.svg)](https://rafalp.github.io/async-caches/)

  Caching library reimplementing [`django.core.cache` API](https://docs.djangoproject.com/en/2.2/topics/cache/#the-low-level-cache-api) with async support and type hints, inspired by [`encode/databases`](https://github.com/encode/databases).

  Currently three cache backends are available:

  * `dummy` - Dummy cache backend that doesn't cache anything. Used to disable caching in tests!
  * `locmem` - Cache backend that stores data in local memory. Lets you develop and test caching without need for actual cache server.
  * `redis` - Redis cache intended for use in actual deployments.

  **Requirements:** Python 3.6+
  **Documentation:** https://rafalp.github.io/async-caches/




  ```console
  $ pip install async-caches
  ```




  Contributions are welcome!

  If you've found a bug, got idea, question or just want to share the love, open [GitHub issue](https://github.com/rafalp/async-caches/issues) or pull request!




  This is free software and you are welcome to modify and redistribute it under the conditions described in the license. For the complete license, refer to the LICENSE file.

  Parts of software come from [databases](https://github.com/encode/databases/issues) package developed by Tom Christie and contributors and from [Django](https://github.com/django/django) package developed by Django project maintainers and contributors.


pkgId: 7ba54ea7cbad77acc21a44547d7bcc1eaa693d9f660f12adefae586f4a33bf5f
name: python-async-chain
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: A coroutine builder
url: https://github.com/Steffo99/async-chain
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-chain-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A coroutine builder




  Have you ever felt that the `await` syntax in Python was a bit clunky when chaining multiple methods together?

  ```python
  async def on_message(event):
      message = await event.get_message()
      author = await message.get_author()
      await author.send_message("Hello world!")
  ```

  Or even worse:

  ```python
  async def on_message(event):
      (await (await (await event.get_message()).get_author()).send_message("Hello world!"))
  ```

  `async-chain` is here to solve your problem!

  ```python
  async def on_message(event):
      await event.get_message().get_author().send_message("Hello world!")
  ```




  First, install `async_chain` with your favorite package manager:

  ```console
  $ pip install async_chain
  ```
  ```console
  $ pipenv install async_chain
  ```
  ```console
  $ poetry add async_chain
  ```

  Then, add the `@async_chain.method` decorator to any async method you wish to make chainable, and the problem will be
  magically solved!

  ```python
  import async_chain

  class MyEvent:
      @async_chain.method
      async def get_message(self):
          ...
  ```


pkgId: ec81b80ea872223067f9b6482681655cfe9eabde9337e3dab477a0e21ee4248d
name: python-async-couch
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Asynchronous client for CouchDB.
url: https://github.com/symstu/async-couch/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-couch-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ![Logo](docs/source/_static/logo.jpg)
  ![Documentation Status](https://readthedocs.org/projects/async-couch/badge/?version=latest)
  ![Python package](https://github.com/symstu/async-couch/workflows/testing/badge.svg?branch=master)
  ![PyPI version](https://badge.fury.io/py/async-couch.svg)


     * [Documentation](https://async-couch.readthedocs.io/en/latest/)

  > This is simple asynchronous python CouchDB client that works with
  > aiohttp, httpx and able to be adopted easily to any other http client.


     * >= Python 3.11


     * [aiohttp](https://docs.aiohttp.org/en/stable/>)
     * [httpx](https://www.python-httpx.org/>)


  ```bash
  pip install async-couch
  ```


  ```python
     import asyncio

     from async_couch import get_couch_client
     from async_couch.http_clients import HttpxCouchClient


     async def example(client, doc_id: str):
        await client.db_create('test_index')
        await client.doc_create_or_update('test_index', doc_id, dict(val=1))

        response = await client.doc_get('test_index', response.model._id)
        assert response.model._id == doc_id

        await client.attachment_upload(
           'test_index', response.model._id, 'attachment_name', 'text/plain', b'\0')

     if __name__ == '__main__':
        loop = asyncio.get_event_loop()
        client = get_couch_client(request_adapter=HttpxCouchClient)

        loop.run_until_complete(example(client, 'document_name'))
  ```


  * Rest endpoints
  * Aiohttp adapter


pkgId: 482a60ab71ae13bad72dab912ce1ee12e00dd66b41c7a4dd2d323fb4b4fb16d8
name: python-async-customerio
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Async CustomerIO Client - a Python client to interact with CustomerIO in an async fashion.
url: https://github.com/healthjoy/async-customerio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-customerio-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI download month](https://img.shields.io/pypi/dm/async-customerio.svg)](https://pypi.python.org/pypi/async-customerio/)
  [![PyPI version fury.io](https://badge.fury.io/py/async-customerio.svg)](https://pypi.python.org/pypi/async-customerio/)
  [![PyPI license](https://img.shields.io/pypi/l/async-customerio.svg)](https://pypi.python.org/pypi/async-customerio/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/async-customerio.svg)](https://pypi.python.org/pypi/async-customerio/)
  [![CI](https://github.com/healthjoy/async-customerio/actions/workflows/ci.yml/badge.svg)](https://github.com/healthjoy/async-customerio/actions/workflows/ci.yml)
  [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/3629b50827ef4e89ba0eaa5c09584273)](https://www.codacy.com/gh/healthjoy/async-customerio/dashboard?utm_source=github.com&utm_medium=referral&utm_content=healthjoy/async-customerio&utm_campaign=Badge_Coverage)

  - Free software: MIT license
  - Requires: Python 3.7+



  - Fully async
  - Interface preserved as Official Python Client `customerio` has
  - Send push notification
  - Send messages



  ```shell script
  pip install async-customerio
  ```



  ```python
  import asyncio

  from async_customerio import AsyncCustomerIO, Regions


  async def main():
      site_id = "Some-id-gotten-from-CustomerIO"
      api_key = "Some-key-gotten-from-CustomerIO"
      cio = AsyncCustomerIO(site_id, api_key, region=Regions.US)
      await cio.identify(
          id=5,
          email="customer@example.com",
          first_name="John",
          last_name="Doh",
          subscription_plan="premium",
      )
      await cio.track(
          customer_id=5, name="product.purchased", product_sku="XYZ-12345", price=23.45
      )


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  Create an instance of the client with your [Customer.io credentials](https://fly.customer.io/settings/api_credentials).

  ```python
  from async_customerio import AsyncCustomerIO, Regions


  cio = AsyncCustomerIO(site_id, api_key, region=Regions.US)
  ```

  `region` is optional and takes one of two values — `Regions.US` or `Regions.EU`. If you do not specify your region, we assume
  that your account is based in the US (`Regions.US`). If your account is based in the EU and you do not provide the correct region
  (`Regions.EU`), we'll route requests to our EU data centers accordingly, however, this may cause data to be logged in the US.



  ```python
  from async_customerio import validate_signature


  def main():
      webhook_signing_key = (
          "755781b5e03a973f3405a85474d5a032a60fd56fabaad66039b12eadd83955fa"
      )
      x_cio_timestamp = 1692633432  # header  value
      x_cio_signature = "d7c655389bb364d3e8bdbb6ec18a7f1b6cf91f39bba647554ada78aa61de37b9"  # header value
      body = b'{"key": "value"}'
      if validate_signature(
          signing_key=webhook_signing_key,
          timestamp=x_cio_timestamp,
          request_body=body,
          signature=x_cio_signature,
      ):
          print("Request is sent from CustomerIO")
      else:
          print("Malicious request received")


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



  `async-customerio` is offered under the MIT license.



  The latest developer version is available in a GitHub repository:
  [https://github.com/healthjoy/async-customerio](https://github.com/healthjoy/async-customerio)


pkgId: 4e3733b8d30c313ed44bea393424aeaec2c6b2c80022fb96d7bdbc0188faced7
name: python-async-dns
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Asynchronous DNS client and server
url: https://github.com/gera2ld/async_dns
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-dns-2.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/async_dns.svg)]()

  This is the documentation for v2.x. Click [here](https://github.com/gera2ld/async_dns/tree/v1.1.10) for 1.x documentation.

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

  - [Features](#features)
  - [Prerequisite](#prerequisite)
  - [Installation](#installation)
  - [CLI](#cli)
    - [Resolver](#resolver)
    - [Server](#server)
  - [API](#api)
    - [Client](#client)
    - [Routing](#routing)
  - [DoH support](#doh-support)
  - [DNS Spoofing](#dns-spoofing)
  - [Test](#test)
  - [Logging](#logging)
  - [References](#references)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->



  - Built with `asyncio` in pure Python, no third party dependency is required
  - Support DNS over UDP / TCP
  - Support DNS over HTTPS
  - Support DNS over TLS



  - Python >=3.6



  ``` sh
  $ pip3 install async_dns

  $ pip3 install git+https://github.com/gera2ld/async_dns.git
  ```





  ```
  usage: python3 -m async_dns.resolver [-h] [-n NAMESERVERS [NAMESERVERS ...]] [-t TYPES [TYPES ...]]
                                       hostnames [hostnames ...]

  Async DNS resolver

  positional arguments:
    hostnames             the hostnames to query

  optional arguments:
    -h, --help            show this help message and exit
    -n NAMESERVERS [NAMESERVERS ...], --nameservers NAMESERVERS [NAMESERVERS ...]
                          name servers
    -t TYPES [TYPES ...], --types TYPES [TYPES ...]
                          query types, default as `any`
  ```

  Examples:

  ``` sh

  $ python3 -m async_dns.resolver www.google.com
  $ python3 -m async_dns.resolver -t mx -- gmail.com


  $ python3 -m async_dns.resolver -n tcp://127.0.0.1 -- www.google.com


  $ python3 -m async_dns.resolver -n tcps://dns.alidns.com -- www.google.com


  $ python3 -m async_dns.resolver -n udp://127.0.0.1:1053 -- www.google.com


  $ python3 -m async_dns.resolver -n https://dns.alidns.com/dns-query -- www.google.com
  ```

  **Note:** `--` is required before `hostname`s if the previous option can have multiple arguments.



  ```
  usage: python3 -m async_dns.server [-h] [-b BIND] [--hosts HOSTS] [-x [PROXY [PROXY ...]]]

  DNS server by Gerald.

  optional arguments:
    -h, --help            show this help message and exit
    -b BIND, --bind BIND  the address for the server to bind
    --hosts HOSTS         the path of a hosts file, `none` to disable hosts, `local` to read from
                          local hosts file
    -x [PROXY [PROXY ...]], --proxy [PROXY [PROXY ...]]
                          the proxy DNS servers, `none` to serve as a recursive server, `default` to
                          proxy to default nameservers
  ```

  **Note:** TLS and HTTPS are not supported in `async_dns` server. Consider [async-doh](https://github.com/gera2ld/async-doh) for DoH server support.

  Examples:

  ``` sh

  $ python3 -m async_dns.server -b :53 --hosts /etc/hosts


  $ python3 -m async_dns.server -x tcp://114.114.114.114


  $ python3 -m async_dns.server -x none
  ```



  ``` python
  import asyncio
  from async_dns.core import types
  from async_dns.resolver import ProxyResolver

  resolver = ProxyResolver()
  res, cached = asyncio.run(resolver.query('www.baidu.com', types.A))
  print(res)
  ```



  The client sends a request to a remote server and returns the message directly. Unlike resolvers, client does not have a cache and does not modify the response.

  ```python
  import asyncio
  from async_dns.core import types, Address
  from async_dns.resolver import DNSClient

  async def query():
      client = DNSClient()
      res = await client.query('www.google.com', types.A,
                               Address.parse('8.8.8.8'))
      print(res)
      print(res.aa)

  asyncio.run(query())
  ```



  ProxyResolver supports routing based on domains:

  ```python
  resolver = ProxyResolver(proxies=[
      ('*.lan', ['192.168.1.1']),                             # query 'udp://192.168.1.1:53' for '*.lan' domains
      (lambda d: d.endswith('.local'), ['tcp://127.0.0.1']),  # query tcp://127.0.0.1:53 for domains ending with '.local'
      '8.8.8.8',                                              # equivalent to (None, ['8.8.8.8']), matches all others
  ])
  ```



  This library contains a simple implementation of DoH (aka DNS over HTTPS) client with partial HTTP protocol implemented.

  If you need a more powerful DoH client based on [aiohttp](https://docs.aiohttp.org/en/stable/), or a DoH server, consider [async-doh](https://github.com/gera2ld/async-doh).



  You can easily add records to the cache with a hosts file or the cache API.

  - Start a server with a custom hosts file:

    ```bash
    $ python3 -m async_dns.server -b :53 --hosts /path/to/custom/hosts
    ```

  - Add some additional records to a resolver:

    ```python
    from async_dns.core import parse_hosts_file, types

    for name, qtype, data in parse_hosts_file(hosts):
        resolver.cache.add(name, qtype, data)

    resolver.cache.add('www.example.com', types.A, ['127.0.0.1'])
    ```



  ```bash
  $ python3 -m unittest


  $ tox -e py
  ```



  Logging does not work out of the box in v2. It requires at least minimal `logging` configuration.

  ```py
  logging.basicConfig(level=logging.INFO)
  ```

  You can also add a formatter for the logger:

  ```py
  import logging
  from async_dns.core import logger

  logger.setLevel(logging.INFO)
  handler = logging.StreamHandler()
  fmt = logging.Formatter('s s: s')
  handler.setFormatter(fmt)
  logger.addHandler(handler)
  ```



  - <https://tools.ietf.org/html/rfc1034>
  - <https://tools.ietf.org/html/rfc1035>
  - <https://tools.ietf.org/html/rfc1464> TXT
  - <https://tools.ietf.org/html/rfc2915> NAPTR


pkgId: 6d7c87ce13ee26b7547d2d124ec68b96dfb7a3e74a2fb668305888a9572e5bf9
name: python-async-doh
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: DNS over HTTPS based on aiohttp and async_dns
url: https://github.com/gera2ld/async-doh
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-doh-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/async-doh.svg)]()

  DNS over HTTPS based on aiohttp and [async_dns](https://github.com/gera2ld/async_dns).



  ```bash
  $ pip install async-doh
  ```





  ```
  usage: python3 -m async_doh.client [-h] [-n NAMESERVERS [NAMESERVERS ...]] [-t TYPES [TYPES ...]] hostnames [hostnames ...]

  Async DNS resolver with DoH

  positional arguments:
    hostnames             the hostnames to query

  optional arguments:
    -h, --help            show this help message and exit
    -n NAMESERVERS [NAMESERVERS ...], --nameservers NAMESERVERS [NAMESERVERS ...]
                          name servers
    -t TYPES [TYPES ...], --types TYPES [TYPES ...]
                          query types, default as `any`
  ```

  Examples:

  ```sh
  $ python3 -m async_doh.client -n https://223.5.5.5/dns-query -t ANY -- www.google.com
  ```



  ```py
  import asyncio
  import aiohttp
  from async_doh.client import DoHClient

  async def main():
      async with DoHClient() as client:
          result = await client.query('https://1.1.1.1/dns-query', 'www.google.com', 'A')
          print('query:', result)
          result = await client.query_json('https://1.1.1.1/dns-query', 'www.google.com', 'A')
          print('query_json:', result)

  asyncio.run(main())
  ```



  ```py
  from aiohttp import web
  from async_doh.server import application

  web.run(application)
  ```

  Now you have `http://localhost:8080/dns-query` as an endpoint.



  By importing the patch, async_dns will use aiohttp to send queries through HTTPS (aka DNS over HTTPS):

  ```py
  import asyncio
  from async_dns.core import types
  from async_dns.resolver import ProxyResolver
  from async_doh.client import patch

  async def main():
      revoke = await patch()
      resolver = ProxyResolver(proxies=['https://dns.alidns.com/dns-query'])
      res, _ = await resolver.query('www.google.com', types.A)
      print(res)
      await revoke()

  asyncio.run(main())
  ```



  - <https://tools.ietf.org/html/rfc8484>


pkgId: 0a45e0147ae860e7035403c243726dc01c978dbebcea2e3abec0becf9c1adca6
name: python-async-dramatiq
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Dramatiq with Asyncio support and some other goodies
url: https://github.com/motherofcoconuts/async-dramatiq
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-dramatiq-0.1.8-1.src.rpm
checksum_type: sha256
description:
  `AsyncMiddleware` will start a `AsyncWorker` which will be used to run the event loop. This event loop will be shared across the Worker threads.

  To startup and shutdown any resources the `AsyncMiddleware` provides two hooks:
  1. Before the event loop is started
  2. After the event loop is stopped
  To allow for standing up or tearing down of shared async resources

  ```
  from async_dramatiq.middleware import AsyncMiddleware
  async def startup() -> None:
      """This function should contain your resource initialization code."""
      pass
  async def shutdown() -> None:
      """This function should contain your resource teardown code."""
      pass
  class MyAsyncMiddleware(AsyncMiddleware):
      def before_async_worker_thread_startup(
          self, _: RabbitmqBroker, thread: AsyncWorker, **kwargs: dict[str, Any]
      ) -> None:
          thread.event_loop.run_until_complete(startup())
      def after_async_worker_thread_shutdown(
          self, _: RabbitmqBroker, thread: AsyncWorker, **kwargs: dict[str, Any]
      ) -> None:
          thread.event_loop.run_until_complete(shutdown())
          thread.event_loop.close()
  ```

  The async actor, `async_actor`,  acts as a thin wrapper around the Dramatiq actor providing a variety of new functionality.

  Run a job at some interval
  ```
  @async_actor(interval=timedelta(seconds=5))
  def run_every_5_seconds() -> None:
      pass
  ```

  Run a job on a crontab ( See https://crontab.guru/. )
  ```
  @async_actor(interval="0 0 * * *")
  def run_at_midnight() -> None:
    pass
  ```


pkgId: 7de70af40af887a5a5b50e16de979e600884d0d8f467f9d0a85ef8fed2657773
name: python-async-extensions
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Asynchronous extensions.
url: https://github.com/nekitdev/async-extensions
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-extensions-4.0.0-1.src.rpm
checksum_type: sha256
description:
  [![License][License Badge]][License]
  [![Version][Version Badge]][Package]
  [![Downloads][Downloads Badge]][Package]
  [![Discord][Discord Badge]][Discord]
  [![Check][Check Badge]][Actions]

  > *Asynchronous extensions.*

  `async-extensions` builds on top of [`anyio`][anyio] to improve backend-agnostic
  asynchronous programming.



  **Python 3.8 or above is required.**



  Installing the library with `pip` is quite simple:

  ```console
  $ pip install async-extensions
  ```

  Alternatively, the library can be installed from source:

  ```console
  $ git clone https://github.com/nekitdev/async-extensions.git
  $ cd async-extensions
  $ python -m pip install .
  ```



  You can add `async-extensions` as a dependency with the following command:

  ```console
  $ poetry add async-extensions
  ```

  Or by directly specifying it in the configuration like so:

  ```toml
  [tool.poetry.dependencies]
  async-extensions = "^4.0.0"
  ```

  Alternatively, you can add it directly from the source:

  ```toml
  [tool.poetry.dependencies.async-extensions]
  git = "https://github.com/nekitdev/async-extensions.git"
  ```



  If you need support with the library, you can send an [email][Email]
  or refer to the official [Discord server][Discord].



  You can find the changelog [here][Changelog].



  You can find the Security Policy of `async-extensions` [here][Security].



  If you are interested in contributing to `async-extensions`, make sure to take a look at the
  [Contributing Guide][Contributing Guide], as well as the [Code of Conduct][Code of Conduct].



  `async-extensions` is licensed under the MIT License terms. See [License][License] for details.

  [Email]: mailto:support@nekit.dev

  [Discord]: https://nekit.dev/chat

  [Actions]: https://github.com/nekitdev/async-extensions/actions

  [Changelog]: https://github.com/nekitdev/async-extensions/blob/main/CHANGELOG.md
  [Code of Conduct]: https://github.com/nekitdev/async-extensions/blob/main/CODE_OF_CONDUCT.md
  [Contributing Guide]: https://github.com/nekitdev/async-extensions/blob/main/CONTRIBUTING.md
  [Security]: https://github.com/nekitdev/async-extensions/blob/main/SECURITY.md

  [License]: https://github.com/nekitdev/async-extensions/blob/main/LICENSE

  [Package]: https://pypi.org/project/async-extensions

  [Discord Badge]: https://img.shields.io/badge/chat-discord-5865f2
  [License Badge]: https://img.shields.io/pypi/l/async-extensions
  [Version Badge]: https://img.shields.io/pypi/v/async-extensions
  [Downloads Badge]: https://img.shields.io/pypi/dm/async-extensions
  [Check Badge]: https://github.com/nekitdev/async-extensions/workflows/check/badge.svg

  [anyio]: https://github.com/agronholm/anyio


pkgId: d21de6ffef5b3e93cff33ea11aa9faea3a40e29cfea6b69017ca0e4e1dbf7500
name: python-async-files
arch: src
version: 0.4
epoch: 0
release: 1
summary: Async Files
url: https://github.com/Niraj-Kamdar/async-files
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-files-0.4-1.src.rpm
checksum_type: sha256
description:
  ![Test Runner](https://github.com/Niraj-Kamdar/async-files/workflows/Test%20Runner/badge.svg)
  [![codecov](https://codecov.io/gh/Niraj-Kamdar/async-files/branch/main/graph/badge.svg?token=cyY0uU5JB5)](https://codecov.io/gh/Niraj-Kamdar/async-files/branch/main)
  [![CodeFactor](https://www.codefactor.io/repository/github/niraj-kamdar/async-files/badge)](https://www.codefactor.io/repository/github/niraj-kamdar/async-files)

  async-files is a fast, lightweight, and extensible asyncio file library, written in pure python and inspired by [aiofiles](https://github.com/Tinche/aiofiles). This works just like aiofiles which delegates file IO operations to a separate thread pool. Although, async-files have been completely re-written from scratch to use modern `async...await...` syntax and with extensibility and flexibility in mind.



  Files can be opened with async context manager or by calling FileIO instance.
  ```python
  async with FileIO("README.md") as f:
      s = await f.read()
      print(s)
  ```
  or
  ```python
  f = await FileIO("README.md")()  # __init__ can't be asynchronous.
  s = await f.read()
  print(s)
  await f.close()
  ```

  Asynchronous iteration is also supported.

  ```python
  async with FileIO("README.md") as f:
      async for line in f:
          print(line, end="")
  ```

  You can also extend functionality of FileIO to support other classes like `tempfile.TemporaryFile` very easily:
  ```python
  from tempfile import TemporaryFile as _TemporaryFile
  from async_files import FileIO

  class TemporaryFile(FileIO):
      OPEN = _TemporaryFile
  ```

  You can do same for any other IO classes like `gzip.GzipFile`, `zipfile.ZipFile`, etc.
  I have added async version of tempfile and gzip modules in the `v0.2`
  since they are commonly used modules and I will add more modules in the future releases.
  You can use these modules just like you use standard library module, only difference is you need to await coroutine methods.
  You can request for support for new modules by [creating new issue](https://github.com/Niraj-Kamdar/async-files/issues/new).

  You can also create coroutine from any blocking function by using async-files's utility function `async_wraps`. For example:
  ```python
  import shutil
  from async_files.utils import async_wraps
  async_rmtree = async_wraps(shutil.rmtree)
  ```
  You can also use `async_wraps` as a decorator for your custom function.
  > Note: Only use `async_wraps` if target function is IO-bound.

  Following are asynchronous attributes of the FileIO object.
  ```python
  close: Callable[[], Awaitable[None]]
  flush: Callable[[], Awaitable[None]]
  isatty: Callable[[], Awaitable[bool]]
  read: Callable[[], Awaitable[Union[str, bytes]]]
  read1: Callable[[], Awaitable[bytes]]
  readinto: Callable[[bytearray], Awaitable[int]]
  readinto1: Callable[[bytearray], Awaitable[int]]
  readline: Callable[[], Awaitable[Union[str, bytes]]]
  readlines: Callable[[], Awaitable[List[Union[str, bytes]]]]
  seek: Callable[[], Awaitable[int]]
  tell: Callable[[], Awaitable[int]]
  truncate: Callable[[], Awaitable[int]]
  write: Callable[[Union[str, bytes]], Awaitable[int]]
  writelines: Callable[[List[Union[str, bytes]]], Awaitable[None]]
  ```
  Other attributes are synchronous just like standard library fileobj.


  Bugs and feature requests can be made via [GitHub issues](https://github.com/Niraj-Kamdar/async-files/issues/new).
  Be aware that these issues are not private, so take care when providing output to make sure you are not disclosing security issues in other products.

  Pull requests are also welcome via git.

  The async-files uses `sourcery`, `restyled` and `code factor` bots to ensure code quality of the PR.


pkgId: 9f97c2a57af19bf19c089e277b60b41b29f7613eddd8292a7cab6109d2529d5f
name: python-async-firebase
arch: src
version: 3.8.0
epoch: 0
release: 1
url: https://github.com/healthjoy/async-firebase
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-firebase-3.8.0-1.src.rpm
checksum_type: sha256
summary:
  Async Firebase Client - a Python asyncio client to interact with Firebase Cloud Messaging in an easy way.

description:
  [![PyPI download month](https://img.shields.io/pypi/dm/async-firebase.svg)](https://pypi.python.org/pypi/async-firebase/)
  [![PyPI version fury.io](https://badge.fury.io/py/async-firebase.svg)](https://pypi.python.org/pypi/async-firebase/)
  [![PyPI license](https://img.shields.io/pypi/l/async-firebase.svg)](https://pypi.python.org/pypi/async-firebase/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/async-firebase.svg)](https://pypi.python.org/pypi/async-firebase/)
  [![CI](https://github.com/healthjoy/async-firebase/actions/workflows/ci.yml/badge.svg)](https://github.com/healthjoy/async-firebase/actions/workflows/ci.yml)
  [![Codacy coverage](https://img.shields.io/codacy/coverage/b6a59cdf5ca64eab9104928d4f9bbb97?logo=codacy)](https://app.codacy.com/gh/healthjoy/async-firebase/dashboard)


    * Free software: MIT license
    * Requires: Python 3.8+



    * Extremely lightweight and does not rely on ``firebase-admin`` which is hefty
    * Send push notifications to Android and iOS devices
    * Send Multicast push notification to Android and iOS devices
    * Send Web push notifications
    * Set TTL (time to live) for notifications
    * Set priority for notifications
    * Set collapse-key for notifications
    * Dry-run mode for testing purpose
    * Topic Management


  To install `async-firebase`, simply execute the following command in a terminal:
  ```shell script
  $ pip install async-firebase
  ```



  To send push notification to Android:
  ```python3
  import asyncio

  from async_firebase import AsyncFirebaseClient


  async def main():
      client = AsyncFirebaseClient()
      client.creds_from_service_account_file("secret-store/mobile-app-79225efac4bb.json")

      
      

      device_token = "..."

      android_config = client.build_android_config(
          priority="high",
          ttl=2419200,
          collapse_key="push",
          data={"discount": "15%", "key_1": "value_1", "timestamp": "2021-02-24T12:00:15"},
          title="Store Changes",
          body="Recent store changes",
      )
      response = await client.push(device_token=device_token, android=android_config)

      print(response.success, response.message_id)

  if __name__ == "__main__":
      asyncio.run(main())
  ```

  To send push notification to iOS:

  ```python3
  import asyncio

  from async_firebase import AsyncFirebaseClient


  async def main():
      client = AsyncFirebaseClient()
      client.creds_from_service_account_file("secret-store/mobile-app-79225efac4bb.json")

      
      

      device_token = "..."

      apns_config = client.build_apns_config(
          priority="normal",
          ttl=2419200,
          apns_topic="store-updated",
          collapse_key="push",
          title="Store Changes",
          alert="Recent store changes",
          badge=1,
          category="test-category",
          custom_data={"discount": "15%", "key_1": "value_1", "timestamp": "2021-02-24T12:00:15"}
      )
      response = await client.push(device_token=device_token, apns=apns_config)

      print(response.success)

  if __name__ == "__main__":
      asyncio.run(main())
  ```

  This prints:

  ```shell script
  "projects/mobile-app/messages/0:2367799010922733%7606eb557606ebff"
  ```

  To manual construct message:
  ```python3
  import asyncio
  from datetime import datetime

  from async_firebase.messages import APNSConfig, APNSPayload, ApsAlert, Aps
  from async_firebase import AsyncFirebaseClient


  async def main():
      apns_config = APNSConfig(**{
          "headers": {
              "apns-expiration": str(int(datetime.utcnow().timestamp()) + 7200),
              "apns-priority": "10",
              "apns-topic": "test-topic",
              "apns-collapse-id": "something",
          },
          "payload": APNSPayload(**{
              "aps": Aps(**{
                  "alert": ApsAlert(title="some-title", body="alert-message"),
                  "badge": 0,
                  "sound": "default",
                  "content_available": True,
                  "category": "some-category",
                  "mutable_content": False,
                  "custom_data": {
                      "link": "https://link-to-somewhere.com",
                      "ticket_id": "YXZ-655512",
                  },
              })
          })
      })

      device_token = "..."

      client = AsyncFirebaseClient()
      client.creds_from_service_account_info({...})
      response = await client.push(device_token=device_token, apns=apns_config)
      print(response.success)


  if __name__ == "__main__":
      asyncio.run(main())
  ```


  To send push notification to Android:
  ```python3
  import asyncio

  from async_firebase import AsyncFirebaseClient
  from async_firebase.messages import Message


  async def main():
      client = AsyncFirebaseClient()
      client.creds_from_service_account_file("secret-store/mobile-app-79225efac4bb.json")

      
      

      device_token: str = "..."

      android_config = client.build_android_config(
          priority="high",
          ttl=2419200,
          collapse_key="push",
          data={"discount": "15%", "key_1": "value_1", "timestamp": "2021-02-24T12:00:15"},
          title="Store Changes",
          body="Recent store changes",
      )
      message = Message(android=android_config, token=device_token)
      response = await client.send(message)

      print(response.success, response.message_id)

  if __name__ == "__main__":
      asyncio.run(main())
  ```

  To send push notification to iOS:

  ```python3
  import asyncio

  from async_firebase import AsyncFirebaseClient
  from async_firebase.messages import Message


  async def main():
      client = AsyncFirebaseClient()
      client.creds_from_service_account_file("secret-store/mobile-app-79225efac4bb.json")

      
      

      device_token: str = "..."

      apns_config = client.build_apns_config(
          priority="normal",
          ttl=2419200,
          apns_topic="store-updated",
          collapse_key="push",
          title="Store Changes",
          alert="Recent store changes",
          badge=1,
          category="test-category",
          custom_data={"discount": "15%", "key_1": "value_1", "timestamp": "2021-02-24T12:00:15"}
      )
      message = Message(apns=apns_config, token=device_token)
      response = await client.send(message)

      print(response.success)

  if __name__ == "__main__":
      asyncio.run(main())
  ```

  This prints:

  ```shell script
  "projects/mobile-app/messages/0:2367799010922733%7606eb557606ebff"
  ```

  To manual construct message:
  ```python3
  import asyncio
  from datetime import datetime

  from async_firebase.messages import APNSConfig, APNSPayload, ApsAlert, Aps, Message
  from async_firebase import AsyncFirebaseClient


  async def main():
      apns_config = APNSConfig(**{
          "headers": {
              "apns-expiration": str(int(datetime.utcnow().timestamp()) + 7200),
              "apns-priority": "10",
              "apns-topic": "test-topic",
              "apns-collapse-id": "something",
          },
          "payload": APNSPayload(**{
              "aps": Aps(**{
                  "alert": ApsAlert(title="some-title", body="alert-message"),
                  "badge": 0,
                  "sound": "default",
                  "content_available": True,
                  "category": "some-category",
                  "mutable_content": False,
                  "custom_data": {
                      "link": "https://link-to-somewhere.com",
                      "ticket_id": "YXZ-655512",
                  },
              })
          })
      })

      device_token: str = "..."

      client = AsyncFirebaseClient()
      client.creds_from_service_account_info({...})
      message = Message(apns=apns_config, token=device_token)
      response = await client.send(message)
      print(response.success)


  if __name__ == "__main__":
      asyncio.run(main())
  ```


  You can subscribe and unsubscribe client app instances in bulk approach by passing a list of registration tokens to the subscription method to subscribe the corresponding devices to a topic:
  ```python3
  import asyncio

  from async_firebase import AsyncFirebaseClient


  async def main():
      device_tokens: list[str] = ["...", "..."]

      client = AsyncFirebaseClient()
      client.creds_from_service_account_info({...})
      response = await client.subscribe_devices_to_topic(
          device_tokens=device_tokens, topic_name="some-topic"
      )
      print(response)


  if __name__ == "__main__":
      asyncio.run(main())
  ```

  To unsubscribe devices from a topic by passing registration tokens to the appropriate method:
  ```python3
  import asyncio

  from async_firebase import AsyncFirebaseClient


  async def main():
      device_tokens: list[str] = ["...", "..."]

      client = AsyncFirebaseClient()
      client.creds_from_service_account_info({...})
      response = await client.unsubscribe_devices_from_topic(
          device_tokens=device_tokens, topic_name="some-topic"
      )
      print(response)


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  ``async-firebase`` is offered under the MIT license.



  The latest developer version is available in a GitHub repository:
  [https://github.com/healthjoy/async-firebase](https://github.com/healthjoy/async-firebase)


pkgId: ecdb01662a5d855680023f28dc7916e6dcd5d0ec2a07f7264b3e09ae150c4624
name: python-async-graph-data-flow
arch: src
version: 1.5.1
epoch: 0
release: 1
summary: Asynchronous functions that pass data along a directed acyclic graph
url: https://pypi.org/project/async-graph-data-flow/
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-graph-data-flow-1.5.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/async-graph-data-flow.svg)](https://pypi.org/project/async-graph-data-flow/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/async-graph-data-flow.svg)](https://pypi.org/project/async-graph-data-flow/)
  [![CircleCI Builds](https://circleci.com/gh/civisanalytics/async-graph-data-flow.svg?style=shield)](https://circleci.com/gh/civisanalytics/async-graph-data-flow)



  Please visit https://async-graph-data-flow.readthedocs.io

  Please also check out this
  [blog post](https://www.civisanalytics.com/blog/open-source-software-release-introducing-async-graph-data-flow-a-python-library-for-efficient-data-pipelines/)
  introducing this package.



  BSD 3-Clause License. Please see `LICENSE.txt` in the GitHub source code for details.



  The latest code under development is available on GitHub at
  https://github.com/civisanalytics/async-graph-data-flow.
  To obtain this version for experimental features or for development:

  ```bash
  git clone https://github.com/civisanalytics/async-graph-data-flow.git
  cd async-graph-data-flow
  pip install -e ".[dev]"
  ```

  To run tests and styling checks:

  ```bash
  pytest
  flake8 src tests examples
  black --check src tests examples
  ```



  We use the Sphinx framework. The documentation source files are in `docs/source/`.
  These files can be updated as necessary.

  The public documentation is accessible at https://async-graph-data-flow.readthedocs.io.
  The doc build is configured by `.readthedocs.yaml`.
  Normally, even when we need to update the documentation or make a new release of async-graph-data-flow,
  neither this configuration YAML file nor Civis's account on the Read the Docs site need any updates.
  The builds by the Read The Docs site generate the necessary files (the HTML pages and other things)
  for the public documentation. All these auto-generated files are explicitly not versioned (see `.gitignore`).

  To build the documentation locally (for testing and development),
  install the full doc-related dependencies: `pip install -r docs/requirements.txt`,
  then run `sphinx-build -b html docs/ docs/build/`.


pkgId: caa6d80d392fc00c1546e118ee5b998ab12c15d9a6cda90d5809b8c8def5dffb
name: python-async-icq
arch: src
version: 1.3.8
epoch: 0
release: 1
summary: ICQ/VK Teams Bot API interface
url: https://github.com/dasshit/async-icq
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-icq-1.3.8-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Package Version](https://img.shields.io/pypi/v/async_icq)](https://pypi.org/project/async-icq/)
  [![PyPi Package Status](https://img.shields.io/pypi/status/async_icq?color=green&label=stable)](https://pypi.org/project/async-icq/)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/async_icq)](https://pypi.org/project/async-icq/)
  [![Package dwn stats](https://img.shields.io/pypi/dm/async_icq)](https://pypi.org/project/async-icq/)
  [![License](https://img.shields.io/github/license/dasshit/async-icq)](https://pypi.org/project/async-icq/)
  [![Repo size](https://img.shields.io/github/repo-size/dasshit/async-icq)](https://pypi.org/project/async-icq/)
  [![Author stars count](https://img.shields.io/github/stars/dasshit?style=social)](https://pypi.org/project/async-icq/)

  <img src="https://icq.com/botapi/res/logo_icq_new.png" width="40%"><img src="https://myteam.mail.ru/botapi/res/logo_myteam.png" width="40%">

  Pure Async Python interface for Bot API.


  - [Introduction](#introduction)
  - [Quick start](#quick-start)
  - [Installing](#installing)
  - [Examples](#examples)
  - [API description](#api-description)




  This library provides complete ICQ/Myteam Bot API 1.0 interface and requires Python 3.5+



  * Create your own bot by sending the /newbot command to <a href="https://icq.com/people/70001">Metabot</a> and follow the instructions.
      >Note: a bot can only reply after the user has added it to his contact list, or if the user was the first to start a dialogue.
  * You can configure the domain that hosts your ICQ server. When instantiating the Bot class, add the address of your domain.
      > Example: Bot(token=TOKEN, url="https://api.icq.net"), by default we use the domain: https://api.icq.net (ICQ) or http://myteam.mail.ru (VK Teams)



  Install using pip:
  ```bash
  pip install -U async-icq
  ```

  Install from sources:
  ```bash
  git clone https://github.com/dasshit/async-icq.git
  cd async-icq
  python setup.py install
  ```



  Basic example of using this library will look like this

  ```python
  from async_icq.bot import AsyncBot
  from async_icq.events import Event


  example = AsyncBot(
    token='TOKEN',
    url='https://api.icq.net',
  )




  @example.message_handler()
  async def hello(event: Event):

    await event.answer(
      text=f'Hi, {event.from_.userId}'
    )

    await event.log(
      f'Answered to {event.chat.chatId} to {event.from_.userId}')



  example.start_poll()
  ```

  Example of how to use this library could be found in async-icq/examples


  <ul>
      <li><a href="https://icq.com/botapi/">icq.com/botapi/</a></li>
      <li><a href="https://agent.mail.ru/botapi/">agent.mail.ru/botapi/</a></li>
      <li><a href="https://myteam.mail.ru/botapi/">myteam.mail.ru/botapi/</a></li>
  </ul>


pkgId: 2a0b7a69c4c2f52b31c7e8cd7cd2283d600b4da27acbf726c466e62b29ff2d22
name: python-async-interrupt
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Context manager to raise an exception when a future is done
url: https://github.com/bdraco/async_interrupt
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-interrupt-1.2.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/bdraco/async_interrupt/actions/workflows/ci.yml?query=branch%3Amain">
      <img src="https://img.shields.io/github/actions/workflow/status/bdraco/async_interrupt/ci.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://codecov.io/gh/bdraco/async_interrupt">
      <img src="https://img.shields.io/codecov/c/github/bdraco/async_interrupt.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/ambv/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square" alt="black">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/async_interrupt/">
      <img src="https://img.shields.io/pypi/v/async_interrupt.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/async_interrupt.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/async_interrupt.svg?style=flat-square" alt="License">
  </p>

  Interrupt context manager for asyncio.

  This module provides a context manager that can be used to interrupt
  a block of code as soon as possible when a future is done.

  The purpose is to raise as soon as possible to avoid any race conditions.

  This is based loosely on async_timeout by Andrew Svetlov and cpython asyncio.timeout



  ```python
  async with interrupt(future, ValueError, "message"):
      future.set_result(None)
      await asyncio.sleep(0)
  ```



  Install this via pip (or your favourite package manager):

  `pip install async_interrupt`



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- prettier-ignore-start -->
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- markdownlint-disable -->
  <!-- markdownlint-enable -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-end -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Copier](https://copier.readthedocs.io/) and the
  [browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
  project template.


pkgId: e1b21f1c10950a786e1e806628d486d2c3991738a26eab02b6740af955c830b4
name: python-async-kinesis
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: AsyncIO Kinesis Library
url: https://github.com/hampsterx/async-kinesis
rpm_license: Apache2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-kinesis-1.1.5-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black) [![PyPI version](https://badge.fury.io/py/async-kinesis.svg)](https://badge.fury.io/py/async-kinesis) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://www.python.org/downloads/release/python-380/)

  ```
  pip install async-kinesis
  ```



  - uses queues for both producer and consumer
    - producer flushes with put_records() if has enough to flush or after "buffer_time" reached
    - consumer iterates over msg queue independent of shard readers
  - Configurable to handle Sharding limits but will throttle/retry if required
    - ie multiple independent clients are saturating the Shards
  - Checkpointing with heartbeats
    - deadlock + reallocation of shards if checkpoint fails to heartbeat within "session_timeout"
  - processors (aggregator + serializer)
      - json line delimited, msgpack


  See [docs/design](./docs/DESIGN.md) for more details.
  See [docs/yetanother](docs/YETANOTHER.md) as to why reinvent the wheel.



  As required by boto3

  ```
  AWS_ACCESS_KEY_ID
  AWS_SECRET_ACCESS_KEY
  ```



      from kinesis import Producer

      async with Producer(stream_name="test") as producer:
          
          await producer.put({'my': 'data'})


  Options:

  (comments in quotes are Kinesis Limits as per AWS Docs)

  | Arg | Default | Description |
  | --- | --- | --- |
  | session | None | AioSession (to use non default profile etc) |
  | region_name | None | AWS Region |
  | buffer_time | 0.5 | Buffer time in seconds before auto flushing records |
  | put_rate_limit_per_shard | 1000 | "A single shard can ingest up to 1 MiB of data per second (including partition keys) or 1,000 records per second for writes" |
  | put_bandwidth_limit_per_shard | 1024 | Kb per sec. max is 1024 per shard (ie 1 MiB). Keep below to minimize ProvisionedThroughputExceeded" errors * |
  | batch_size | 500 | "Each PutRecords request can support up to 500 records" |
  | max_queue_size | 10000 | put() method will block when queue is at max |
  | after_flush_fun | None | async function to call after doing a flush (err put_records()) call |
  | processor | JsonProcessor() | Record aggregator/serializer. Default is JSON without aggregation. Note this is highly inefficient as each record can be up to 1Mib |
  | retry_limit | None | How many connection attempts should be made before raising a exception |
  | expo_backoff | None | Exponential Backoff when connection attempt fails |
  | expo_backoff_limit | 120 | Max amount of seconds Exponential Backoff can grow |
  | create_stream | False | Creates a Kinesis Stream based on the `stream_name` keyword argument. Note if stream already existing it will ignore |
  | create_stream_shards | 1 | Sets the amount of shard you want for your new stream. Note if stream already existing it will ignore  |

  * Throughput exceeded. The docs (for Java/KPL see: https://docs.aws.amazon.com/streams/latest/dev/kinesis-producer-adv-retries-rate-limiting.html) state:

  > You can lower this limit to reduce spamming due to excessive retries. However, the best practice is for each producer is to retry for maximum throughput aggressively and to handle any resulting throttling determined as excessive by expanding the capacity of the stream and implementing an appropriate partition key strategy.

  Even though our default here is to limit at this threshold (1024kb) in reality the threshold seems lower (~80%).
  If you wish to avoid excessive throttling or have multiple producers on a stream you will want to set this quite a bit lower.




      from kinesis import Consumer

      async with Consumer(stream_name="test") as consumer:
          while True:
              async for item in consumer:
                  print(item)
              


  Options:

  (comments in quotes are Kinesis Limits as per AWS Docs)


  | Arg | Default | Description |
  | --- | --- | --- |
  | session | None | AioSession (to use non default profile etc) |
  | region_name | None | AWS Region |
  | max_queue_size | 10000 | the fetch() task shard will block when queue is at max |
  | max_shard_consumers | None | Max number of shards to use. None = all |
  | record_limit | 10000 | Number of records to fetch with get_records() |
  | sleep_time_no_records | 2 | No of seconds to sleep when caught up |
  | iterator_type | TRIM_HORIZON | Default shard iterator type for new/unknown shards (ie start from start of stream). Alternatives are "LATEST" (ie end of stream), "AT_TIMESTAMP" (ie particular point in time, requires defining `timestamp` arg) |
  | shard_fetch_rate | 1 | No of fetches per second (max = 5). 1 is recommended as allows having multiple consumers without hitting the max limit. |
  | checkpointer | MemoryCheckPointer() | Checkpointer to use |
  | processor | JsonProcessor() |  Record aggregator/serializer. Must Match processor used by Producer() |
  | retry_limit | None | How many connection attempts should be made before raising a exception |
  | expo_backoff | None | Exponential Backoff when connection attempt fails |
  | expo_backoff_limit | 120 | Max amount of seconds Exponential Backoff can grow |
  | create_stream | False | Creates a Kinesis Stream based on the `stream_name` keyword argument. Note if stream already existing it will ignore |
  | create_stream_shards | 1 | Sets the amount of shard you want for your new stream. Note if stream already existing it will ignore  |
  | timestamp | None | Timestamp to start reading stream from. Used with iterator type "AT_TIMESTAMP"




  - memory (the default but kinda pointless)

  ```
      MemoryCheckPointer()
  ```

  - redis

  ```
      RedisCheckPointer(name, session_timeout=60, heartbeat_frequency=15, is_cluster=False)
  ```

  Requires ENV:

  ```
      REDIS_HOST
  ```

  Requires `pip install aredis`





  Aggregation enable batching up multiple records to more efficiently use the stream.
  Refer https://aws.amazon.com/blogs/big-data/implementing-efficient-and-reliable-producers-with-the-amazon-kinesis-producer-library/


  | Class | Aggregator | Serializer | Description |
  | --- | --- | --- | --- |
  | StringProcessor | SimpleAggregator | StringSerializer | Single String record |
  | JsonProcessor | SimpleAggregator | JsonSerializer | Single JSON record |
  | JsonLineProcessor | NewlineAggregator | JsonSerializer | Multiple JSON record separated by new line char |
  | JsonListProcessor | ListAggregator | JsonSerializer | Multiple JSON record returned by list |
  | MsgpackProcessor | NetstringAggregator | MsgpackSerializer | Multiple Msgpack record framed with Netstring Protocol (https://en.wikipedia.org/wiki/Netstring) |
  | KPLJsonProcessor | KPLAggregator | JsonSerializer | Multiple JSON record in a KPL Aggregated Record (https://github.com/awslabs/amazon-kinesis-producer/blob/master/aggregation-format.md) |
  | KPLStringProcessor | KPLAggregator | StringSerializer | Multiple String record in a KPL Aggregated Record (https://github.com/awslabs/amazon-kinesis-producer/blob/master/aggregation-format.md) |

  Note you can define your own processor easily as it's simply a class inheriting the Aggregator + Serializer.

  ```
  class MsgpackProcessor(Processor, NetstringAggregator, MsgpackSerializer):
      pass
  ```

  Just define a new Serializer class with serialize() and deserialize() methods.

  Note:

  * Json will use `pip install ujson` if installed
  * Msgpack requires `pip install msgpack` to be installed
  * KPL requires `pip install aws-kinesis-agg` to be installed



  See [benchmark.py](./benchmark.py) for code

  50k items of approx 1k (python) in size, using single shard.

  ![Benchmark](docs/benchmark.png)




  Uses https://github.com/mhart/kinesalite for local testing.

  Run tests via docker

  ```
  docker-compose up --abort-on-container-exit --exit-code-from test
  ```

  For local testing use

  ```
  docker-compose up kinesis redis
  ```

  then within your virtualenv

  ```
  nosetests


  nosetests tests.py:KinesisTests.test_create_stream_shard_limit_exceeded
  ```

  Note there are a few test cases using the *actual* AWS Kinesis (AWSKinesisTests)
  These require setting an env in order to run

  Create an ".env" file with

  ```
  TESTING_USE_AWS_KINESIS=1
  ```

  Note you can ignore these tests if submitting PR unless core batching/processing behaviour is being changed.


pkgId: 0ed163f03dc5799194b0719940b27794f1ead8b5d7e6ab1756463ed9345b7547
name: python-async-lambda-unstable
arch: src
version: 0.4.17
epoch: 0
release: 1
summary: A framework for creating AWS Lambda Async Workflows. - Unstable Branch
url: https://pypi.org/project/async-lambda-unstable/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-lambda-unstable-0.4.17-1.src.rpm
checksum_type: sha256
description:
  `async-lambda` is a framework for creating `AWS Lambda` applications with built
  in support for asynchronous invocation via a SQS Queue. This is useful if you
  have workloads you need to split up into separate execution contexts.

  `async-lambda` converts your application into a `Serverless Application Model (SAM)`
  template which can be deployed with the `SAM` cli tool.

  An `async-lambda` application is comprised of a `controller` object and `tasks`.

  ```python
  import json
  from async_lambda import AsyncLambdaController, ScheduledEvent, ManagedSQSEvent, config_set_name

  app = AsyncLambdaController()
  config_set_name("project-name")
  lambda_handler = app.async_lambda_handler # This "export" is required for lambda.

  @app.scheduled_task('ScheduledTask1', schedule_expression="rate(15 minutes)")
  def scheduled_task_1(event: ScheduledEvent):
      app.async_invoke("AsyncTask1", payload={"foo": "bar"}) # Payload must be JSON serializable and < 2560Kb

  @app.async_task('AsyncTask1')
  def async_task_2(event: ManagedSQSEvent):
      print(event.payload)  #{"foo": "bar"}

  ```

  **When the app is packaged for lambda, only the main module, and the `vendor` and `src` directories are included.**



  The core abstraction in `async-lambda` is a `task`. Each task will result in a separate lambda function.
  Tasks have a `trigger_type` which determines what event triggers them. A task is identified by its unique `task_id`.

  All task decorators share common arguments for configuring the underlying lambda function:

  - `memory: int = 128` Sets the memory allocation for the function.
  - `timeout: int = 60` Sets the timeout for the function (max 900 seconds).
  - `ephemeral_storage: int = 512` Sets the ephemeral storage allocation for the function.
  - `maximum_concurrency: Optional[int | List[int]] = None` Sets the maximum concurrency value for the SQS trigger for the function. (only applies to `async_task` and `sqs_task` tasks.) When using the `lanes` feature, this can be a list of maximum concurrency for each lane. The length of the list must equal the # of lanes.

  It is often useful to run code during the `INIT_START` phase of the lambda lifecycle.
  This is achieved by placing that code outside of the lambda handler, this will
  result in this code being run for all tasks within the application as it is
  executed on import. `async-lambda` provides a utility `init_tasks` argument which
  will run given functions during the `INIT_START` phase only for that specific task.

  The functions should have either 0 or 1 arguments, if they have 1 argument then
  the `task_id` will be passed in.

  `async-lambda` also provides a helper class for when a value needs to be stored
  from this execution. The `Defer` class takes a function, and args/kwargs and
  will only execute the function when its value is requested. This can be used in
  combination with `init_tasks` to cache values during the `INIT_START` phase.

  EX:

  ```python

  def get_a_value(a: int, b: int) -> int:
      return random.randint(a, b)

  cache = Defer(get_a_value, 10, 100)

  @controller.async_task("Task", init_tasks=[cache.execute])
  def task(event: ManagedSQSEvent):
      for i in range(cache.value):
          
          ...
  ```

  For all lambda executions which share a container `cache.value` will be the same
  and `get_a_value` will only be called once.



  All async tasks have a matching SQS queue which the lambda function consumes from (1 message per invocation).
  All async task queues share a DLQ. Async tasks can be invoked from anywhere within the app by using the
  `AsyncLambdaController.async_invoke` method. Calling this method sends a message into the queue for the given task.
  The task function should have a single parameter of the `ManagedSQSEvent` type.

  ```python
  app = AsyncLambdaController()

  @app.async_task("TaskID")
  def async_task(event: ManagedSQSEvent):
      event.payload # payload sent via the `async_invoke` method
      event.source_task_id # the task_id where the event originated
  ```

  **It is quite easy to get into infinite looping situations when utilizing `async-lambda` and care should be taken.**

  **INFINITE LOOP EXAMPLE**

  ```python



  @app.async_task("Task1")
  def task_1(event: ManagedSQSEvent):
      app.async_invoke("Task2", {})

  @app.async_task("Task2")
  def task_1(event: ManagedSQSEvent):
      app.async_invoke("Task1", {})
  ```



  Sometimes you may want multiple "lanes" for events to travel through, especially when you have constrained throughput with `maximum_concurrency`. Utilize the `lanes` feature to open up multiple paths to an `async-task`. This can be useful if you have a large backlog of messages you need to process, but you don't want to interrupt the normal message flow.

  The # of lanes can be controlled at the controller, sub-controller, and/or task level. With the configuration propagating down the tree, but it can be overridden at any of the levels. The # of lanes can be set with the `lane_count` parameter.

  By default all usages of `async_invoke` will place the message in the default lane (`0`). To change this specify `lane=` in the `async_invoke` call. By default, any further calls of `async_invoke` down the call stack will continue to put the messages into the same lane if it is available. You can turn of this behavior by setting `propagate_lane_assignment=False` at the controller level.

  For example, we will use a payload field to determine which lane processing should occur in. We will set the maximum concurrency for the default lane at 10, and for the other lane at `2`.

  ```python
  app = AsyncLambdaController(lane_count=2)

  @app.async_task("SwitchBoard")
  def switch_board(event: ManagedSQSEvent):
      value = event.payload['value']
      lane = 0
      if value > 50_000:
          lane = 1
      app.async_invoke("ProcessingTask", event.payload, lane=lane)

  @app.async_task("ProcessingTask", maximum_concurrency=[10, 2])
  def processing_task(event: ManagedSQSEvent):
      ...
  ```

  `async-lambda` creates `n` queues and lambda triggers per `async-task` where `n = lane_count`. All of the `n` queues are still consumed by a single lambda function.



  Unmanaged SQS tasks consume from any arbitrary SQS queue (1 message per invocation).
  The task function should have a single parameter of the `UnmanagedSQSEvent` type.

  ```python
  app = AsyncLambdaController()

  @app.sqs_task("TaskID", queue_arn='queue-arn')
  def sqs_task(event: UnmanagedSQSEvent):
      event.body # sqs event body
  ```



  Scheduled tasks are triggered by an eventbridge schedule. The schedule expression can be
  a [cron expression](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-cron-expressions.html)
  or a [rate expression](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rate-expressions.html).
  The task function should have a single parameter of the `ScheduledEvent` type.

  ```python
  app = AsyncLambdaController()

  @app.scheduled_task("TaskID", schedule_expression='rate(15 minutes)')
  def scheduled_task(event: ScheduledEvent):
      ...
  ```



  API tasks are triggered by a Web Request. `async-lambda` creates an APIGateway endpoint matching the
  `method` and `path` in the task definition. It is possible to configure a custom domain and certificate
  for all API tasks within an `async-lambda` app.
  The task function should have a single parameter of the `APIEvent` type.

  ```python
  app = AsyncLambdaController()

  @app.api_task("TaskID", path='/test', method='get')
  def api_task(event: APIEvent):
      event.headers # request headers
      event.querystring_params # request querystring params
      event.body # request body
      event.headers # This is a case insensitive dict
  ```



  Middleware functions can be registered with controllers which will wrap the execution of tasks.
  These functions can be configured to trigger on specific types of tasks and can trigger
  side effects and modify the `event` or `response` objects.

  Middleware functions must have the signature `Callable[[BaseEvent, Callable[[BaseEvent], T]], T]`.
  The first argument is the `event`, and the second argument (`call_next`) is a function which will propagate the
  calls down the middleware/task stack. The `call_next` function must be called, and its result in most cases be returned.
  If this is not done then tasks will not run as expected.

  **Extreme care should be taken with middleware as a simple mistake can have catastrophic effects.**

  - Middleware functions are run in the order which they were registered and parent controller middleware will be run first.

  - Middleware functions which are registered more than once will only be run once.

  Registration can be done when the `AsyncLambdaController` is initialized with the parameter `middleware` or by using the `add_middleware` method.

  Middleware functions have three sections:

  1. Pre task
  2. Task execution
  3. Post task

  ```python
  def async_lambda_middleware(event: BaseEvent, call_next):
      
      result = call_next(event) # task execution
      
      return result
  ```

  If there are multiple middleware functions then `call_next` will actually be calling the next middleware function in the stack.

  For example if there is middleware functions `A` and `B` registered in that order.
  Then the execution order would go:

  `A(Pre)` -> `B(Pre)` -> `Task` -> `B(Post)` -> `A(Post)`

  EX:

  ```python
  def async_task_only_middleware(event: ManagedSQSEvent, call_next):
      print(f"Invocation Payload: {event}")
      result = call_next(event)
      print(f"Invocation Result: {result}")
      return result

  def all_task_types_middleware(event: BaseEvent, call_next):
      print(f"This event is of the type {type(event)}")
      result = call_next(event)
      print(f"The result is of the type {type(result)}")
      return event

  controller = AsyncLambdaController(middleware=[([BaseEvent], all_task_types_middleware)])

  controller.add_middleware([ManagedSQSEvent], async_task_only_middleware)

  @controller.async_task("ATask")
  def a_task(event: ManagedSQSEvent):
      pass

  @controller.api_task("BTask", "/test", "get")
  def b_task(event: APIEvent):
      return "hello world"
  ```

  In this scenario when `ATask` is invoked first `all_task_types_middleware` will be run, then
  `async_task_only_middleware` will be run and finally the `a_task` function will be executed.

  When `BTask` is invoked first `all_task_types_middleware` will be run, and then the `b_task`
  function will be executed



  Configuration options can be set with the `.async_lambda/config.json` file.
  The configuration options can be set at the app, stage, and task level. A configuration option set
  will apply unless overridden at a more specific level (app -> stage -> task -> stage).
  The override logic attempts to non-destructive so if you have a `layers` of `['layer_1']` at the app level,
  and `[layer_2]` at the stage level, then the value will be `['layer_1', 'layer_2']`.

  **Config file levels schema**

  ```
  {
      
      "stages": {
          "stage_name": {
              
          }
      },
      "tasks": {
          "task_id": {
              
              "stages": {
                  "stage_name": {
                      
                  }
              }
          }
      }
  }
  ```

  **At any of these `levels` any of the configuration options can be set:**
  With the exception of `domain_name`, `tls_version`, and `certificate_arn` which can not be set at the task level.



  ```
  {
      "ENV_VAR_NAME": "ENV_VAR_VALUE"
  }
  ```

  This config value will set environment variables for the function execution.
  These environment variables will also be available during build time.

  [The value is passed to the `Environment` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment)



  ```
  [
      'IAM_POLICY_ARN' | STATEMENT
  ]
  ```

  Use this config option to attach any arbitrary policies to the lambda functions execution role.

  [The value is passed to the `Policies` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-policies), in addition to the `async-lambda` created inline policies.



  ```
  [
      "LAYER_ARN"
  ]
  ```

  Use this config option to add any arbitrary lambda layers to the lambda functions. Ordering matters,
  and merging is done thru concatenation.

  [The value is passed to the `Layers` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-layers)



  ```
  [
      "SUBNET_ID
  ]
  ```

  Use this config option to put the lambda function into a vpc/subnet.

  The value is passed into the [`SubnetIds`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) field of the [`VpcConfig` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-vpcconfig)



  ```
  [
      "SECURITY_GROUP_ID"
  ]
  ```

  Use this config option to attach a security group to the lambda function.

  The value is passed into the [`SecurityGroupIds`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) field of the [`VpcConfig` property on `SAM::Serverless::Function`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-vpcconfig)



  ```
  [
      {
          
      }
  ]
  ```

  Use this config option to add extra resources for managed SQS queues (`async_task` tasks.)

  For example this might be used to attach alarms to these queues.

  Each item in the list should be a complete cloudformation resource. `async-lambda` provides a few custom substitutions
  so that you can reference the extras and the associated managed sqs resource by `LogicalId`.

  - `$QUEUEID"` will be replaced with the `LogicalId` of the associated Managed SQS queue.
  - `$EXTRA<index>` will be replaced with the `LogicalId` of the extra at the specified index.



  **This config value can only be set at the app or stage level.**

  ```
  [
      {...}
  ]
  ```

  If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.

  The value is passed into the [`MethodSettings`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-methodsettings) property of the `AWS::Serverless::Api`. The spec for `MethodSetting` can be found [here](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-stage-methodsetting.html).



  **This config value can only be set at the app or stage level.**

  ```
  "domain_name"
  ```

  If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.

  This config value will set the [`DomainName`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain)



  **This config value can only be set at the app or stage level.**

  ```
  "tls_version"
  ```

  If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.

  This config value will set the [`SecurityPolicy`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain)

  Possible values are `TLS_1_0` and `TLS_1_2`



  **This config value can only be set at the app or stage level.**

  ```
  "certificate_arn"
  ```

  If your `async-lambda` app contains any `api_task` tasks, then a `AWS::Serverless::Api` resource is created.

  This config value will set the [`CertificateArn`](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-api-domainconfiguration.html) field of the [`Domain` property](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-api.html#sam-api-domain)



  ```
  {
      "TAG_NAME": "TAG_VALUE"
  }
  ```

  This config value will set the `Tags` field of all resources created by async-lambda. This will not set the field on `managed_queue_extras` resources.

  The keys `framework` and `framework-version` will always be set and the system values will override any values set by the user.

  For managed queues the tags `async-lambda-queue-type` will be set to `dlq`, `dlq-task`, or `managed` depending on the queue type.

  For `async_task` queues (non dlq-task) the `async-lambda-lane` will be set.



  ```
  {
      "ApplicationLogLevel": "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL",
      "LogFormat": "Text" | "JSON",
      "LogGroup": "",
      "SystemLogLevel": "DEBUG" | "INFO" | "WARN"
  }
  ```

  The value is passed directly to the [`LoggingConfig`](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html#cfn-lambda-function-loggingconfig) Cloudformation parameter for lambda function/s.



  **When the app is packaged for lambda, only the main module, and the `vendor` and `src` directories are included.**

  From the project root directory, utilize the `async-lambda` CLI tool to generate
  a SAM template and function bundle. Optionally specify the `stage` to use `stage` specific configs.

  ```bash

  async-lambda build app --stage <stage-name>
  ```

  This will generate a SAM template `template.json` as well as an `deployment.zip` file.
  This template and zip file can then be deployed or transformed into regular cloudformation
  via the `sam` or `aws` cli tools.



  - Lambda Configuration - not all of the lambda configuration spec is present in `async-lambda`. It is relatively trivial to add in configuration options. Make an issue if there is a feature you would like to see implemented.
  - The `async_invoke` payload must be `JSON` serializable with `json.dumps`.
  - It is possible to get into infinite loops quite easily. (Task A invokes Task B, Task B invokes Task A)


pkgId: 2ad0939819cfd908bbd0d4d4f8bb27fe47a9a4f8e086567689a3b2ba3ebfbe42
name: python-async-metrics
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: simple metrics for your app
url: https://github.com/amenezes/async_metrics
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-metrics-0.1.0-1.src.rpm
checksum_type: sha256
description:
  [![ci](https://github.com/amenezes/async_metrics/workflows/ci/badge.svg)](https://github.com/amenezes/async_metrics/actions)
  [![codecov](https://codecov.io/gh/amenezes/async_metrics/branch/main/graph/badge.svg?token=Y0J7INSN6Y)](https://codecov.io/gh/amenezes/async_metrics)
  [![PyPI version](https://badge.fury.io/py/async_metrics.svg)](https://badge.fury.io/py/async_metrics)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/async_metrics)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  [asyncio](https://docs.python.org/3/library/asyncio.html) metrics for your app.

  Available metrics:
  - asyncio: event loop status, policy and exception handler and tasks info;
  - system: uptime, platform, recursion limit, default encoding, phisical and virtual processors, system load and process user;
  - dependencies: application dependencies;
  - python: implementation, version and PATH;
  - process: application process info like: threads, open files, connections, context switch and childrens PID;
  - partitions: partitions usage;
  - about: async_metrics version, project: url, issues and release pages.

  ![dashboard](docs/dashboard.png)



  Install and update using pip:

  ````bash
  pip install -U async_metrics
  ````





  ```python
  from aiohttp import web
  from async_metrics.ext.aiohttp import setup_async_metrics


  app = web.Application()
  setup_async_metrics(app)

  web.run_app(app, host="0.0.0.0")
  ```



  ```python
  from flask import Flask
  from async_metrics.ext.flask import setup_async_metrics

  app = Flask(__name__)
  setup_async_metrics(app)

  @app.route('/')
  def hello_world():
      return 'Hello, World!'
  ```




  Clone the repository, install the dependencies and follow the following steps:



  ```bash
  python examples/aiohttp_example.py
  ```

  For web UI dashboard access:
  - http://localhost:8080/async_metrics/dashboard




  ```bash
  FLASK_APP=examples/flask_example.py flask run
  ```

  For web UI dashboard access:
  - http://localhost:5000/async_metrics/dashboard






  ```bash
  pip install async_metrics[cli]
  ```



  ```bash
  python -m async_metrics show -h
  Usage: python -m async_metrics show [OPTIONS] [ADDRESS]

  Options:
    --asyncio     Show summary information about async environmen.
    --system      Show information about system environment.
    --deps        Show applications dependencies.
    --python      Show information about current python environment.
    --process     Show summary information about application process.
    --partitions  Show summary information about disk partition.
    --about       Show information about async_metrics.
    -h, --help    Show this message and exit.
  ```

  > **ADDRESS** can be set via environment variable `ASYNC_METRICS_HOST`

  Acessing AIOHTTP example metrics:

  ```bash

  python -m async_metrics show --system
  ```

  Acessing Flask example metrics:


  ```bash
  python -m async_metrics show http://localhost:5000/async_metrics --system
  ```



  - License: [Apache License](https://choosealicense.com/licenses/apache-2.0/)
  - Code: [https://github.com/amenezes/async_metrics](https://github.com/amenezes/async_metrics)
  - Issue tracker: [https://github.com/amenezes/async_metrics/issues](https://github.com/amenezes/async_metrics/issues)
  - Docs: [https://github.com/amenezes/async_metrics](https://github.com/amenezes/async_metrics)


pkgId: e08536c57e74211e2d3ca45fd1cb26211cabd2906e5d98dd13ecf778aa13888d
name: python-async-mojang
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: An async Python wrapper for the Mojang API.
url: https://github.com/FroostySnoowman/Async-Mojang
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-mojang-1.0.4-1.src.rpm
checksum_type: sha256
description:
  ```Async-Mojang``` is a Python package for accessing Mojang's services. This library can be used to convert UUIDs, get a profile's information, change your Minecraft username or skin, and much more.

  There is one component to this package:

  - **Public API** - Used to parse information about Minecraft profiles and more. Authentication is not required.


  **Python 3.7 or higher is required.**

  The easiest way to install the library is using `pip`. Just run the following console command:

  ```
  pip install async-mojang
  ```


  ```py
  import asyncio
  from async_mojang import API

  async def get_uuid(username: str):
      async with API() as api:
          uuid = await api.get_uuid(username)
          return uuid

  async def get_stripped_uuid(username: str):
      async with API() as api:
          stripped_uuid = await api.get_stripped_uuid(username)
          return stripped_uuid

  async def get_username(uuid: str):
      async with API() as api:
          username = await api.get_username(uuid)
          return username

  async def get_profile(uuid: str):
      async with API() as api:
          profile = await api.get_profile(uuid)
          return profile

  async def get_blocked_servers():
      async with API() as api:
          blocked_servers = await api.get_blocked_servers()
          return blocked_servers

  async def main():
      uuid = await get_uuid("FroostySnoowman")
      print(uuid)

      stripped_uuid = await get_stripped_uuid("FroostySnoowman")
      print(stripped_uuid)

      username = await get_username(uuid)
      print(username)

      profile = await get_profile(uuid)
      print(profile)

      blocked_servers = await get_blocked_servers()
      print(blocked_servers)

  if __name__ == "__main__":
      asyncio.run(main())
  ```


pkgId: d1ecaa54a6eedac13ce9dabe63695327251c3194174a7e26cfb98763103204f4
name: python-async-openai
arch: src
version: 0.0.52
epoch: 0
release: 1
summary: Unofficial Async Python client library for the OpenAI API
url: https://github.com/GrowthEngineAI/async-openai
rpm_license: MIT Style
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-openai-0.0.52-1.src.rpm
checksum_type: sha256
description:
  ```bash

  pip install async-openai

  pip install git+https://github.com/GrowthEngineAI/async-openai.git
  ```

  ```python
  import asyncio
  from async_openai import OpenAI, settings, CompletionResponse










  OpenAI.configure(
      api_key = "sk-XXXX",
      organization = "org-XXXX",
      debug_enabled = False,
  )







  result: CompletionResponse = OpenAI.completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )


  print(result.text)

  print(len(result))

  print(result.consumption)


  result: CompletionResponse = asyncio.run(
      OpenAI.completions.async_create(
          prompt = 'say this is a test',
          max_tokens = 4,
          stream = True
      )
  )
  ```

  The following environment variables can be used to configure the client.
  ```
  OpenAI Configuration
  url: The OpenAI API URL                                     | Env: [`OPENAI_API_URL`]
  scheme: The OpenAI API Scheme                               | Env: [`OPENAI_API_SCHEME`]
  host: The OpenAI API Host                                   | Env: [`OPENAI_API_HOST`]
  port: The OpenAI API Port                                   | Env: [`OPENAI_API_PORT`]
  api_base: The OpenAI API Base                               | Env: [`OPENAI_API_BASE`]
  api_key: The OpenAI API Key                                 | Env: [`OPENAI_API_KEY`]
  api_path: The OpenAI API Path                               | Env: [`OPENAI_API_PATH`]
  api_type: The OpenAI API Type                               | Env: [`OPENAI_API_TYPE`]
  api_version: The OpenAI API Version                         | Env: [`OPENAI_API_VERSION`]
  api_key_path: The API Key Path                              | Env: [`OPENAI_API_KEY_PATH`]
  organization: Organization                                  | Env: [`OPENAI_ORGANIZATION`]
  proxies: The OpenAI Proxies                                 | Env: [`OPENAI_PROXIES`]
  timeout: Timeout in Seconds                                 | Env: [`OPENAI_TIMEOUT`]
  max_retries: The OpenAI Max Retries                         | Env: [`OPENAI_MAX_RETRIES`]
  ignore_errors: Ignore Errors                                | Env: [`OPENAI_IGNORE_ERRORS`]
  disable_retries: Disable Retries                            | Env: [`OPENAI_DISABLE_RETRIES`]
  max_connections: Max Connections                            | Env: [`OPENAI_MAX_CONNECTIONS`]
  max_keepalive_connections: Max Keepalive Connections        | Env: [`OPENAI_MAX_KEEPALIVE_CONNECTIONS`]
  keepalive_expiry: Keepalive Expiry                          | Env: [`OPENAI_KEEPALIVE_EXPIRY`]
  custom_headers: Custom Headers                              | Env: [`OPENAI_CUSTOM_HEADERS`]
  Azure Configuration
  azure_url: The OpenAI API URL                               | Env: [`AZURE_OPENAI_API_URL`]
  azure_scheme: The OpenAI API Scheme                         | Env: [`AZURE_OPENAI_API_SCHEME`]
  azure_host: The OpenAI API Host                             | Env: [`AZURE_OPENAI_API_HOST`]
  azure_port: The OpenAI API Port                             | Env: [`AZURE_OPENAI_API_PORT`]
  azure_api_key: The OpenAI API Key                           | Env: [`AZURE_OPENAI_API_KEY`]
  azure_api_base: The OpenAI API Base                         | Env: [`AZURE_OPENAI_API_BASE`]
  azure_api_path: The OpenAI API Path                         | Env: [`AZURE_OPENAI_API_PATH`]
  azure_api_type: The OpenAI API Type                         | Env: [`AZURE_OPENAI_API_TYPE`]
  azure_api_version: The OpenAI API Version                   | Env: [`AZURE_OPENAI_API_VERSION`]
  azure_api_key_path: The API Key Path                        | Env: [`AZURE_OPENAI_API_KEY_PATH`]
  azure_organization: Organization                            | Env: [`AZURE_OPENAI_ORGANIZATION`]
  azure_proxies: The OpenAI Proxies                           | Env: [`AZURE_OPENAI_PROXIES`]
  azure_timeout: Timeout in Seconds                           | Env: [`AZURE_OPENAI_TIMEOUT`]
  azure_max_retries: The OpenAI Max Retries                   | Env: [`AZURE_OPENAI_MAX_RETRIES`]
  ```

  ```python
  from async_openai import OpenAI

  OpenAI.configure(
      api_key = "sk-XXXX",
      organization = "org-XXXX",
      debug_enabled = False,
      
      azure_api_base = 'https://....openai.azure.com/',
      azure_api_version = '2023-07-01-preview',
      azure_api_key = '....',
  )

  oai = OpenAI.init_api_client()

  az = OpenAI.init_api_client('az', set_as_default = False, debug_enabled = True)
  result = az.completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )

  result = OpenAI.completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )

  result = oai.completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )

  result = OpenAI['az'].completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )

  result = OpenAI['default'].completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )

  result = OpenAI[0].completions.create(
      prompt = 'say this is a test',
      max_tokens = 4,
      stream = True
  )
  ```

  The below will show you how to rotate between multiple clients when you hit an error.
  **Important** Auto-rotation is only supported with `chat_create` and `async_chat_create` methods. Otherwise, you should handle the rotation manually.
  ```python
  import asyncio
  from async_openai import OpenAI, ChatResponse
  from async_openai.utils import logger
  OpenAI.configure(
      api_key = "sk-XXXX",
      organization = "org-XXXX",
      debug_enabled = False,
      
      azure_api_base = 'https://....openai.azure.com/',
      azure_api_version = '2023-07-01-preview',
      azure_api_key = '....',
      
      
      enable_rotating_clients = True,
      
      prioritize = "azure",
  )

  OpenAI.get_current_client_info(verbose = True)





  result: ChatResponse = OpenAI.chat_create(
      model = "gpt-3.5-turbo-16k",
      messages = [
          {"role": "user", "content": "Translate the following English text to French: “Multiple models, each with different capabilities and price points. Prices are per 1,000 tokens. You can think of tokens as pieces of words, where 1,000 tokens is about 750 words. This paragraph is 35 tokens”"}
      ],
      auto_retry = True,
  )
  logger.info(f'Result Chat Message: {result.messages}')
  logger.info(f'Result Usage: {result.usage}')
  logger.info(f'Result Consumption: {result.consumption}')



  result: ChatResponse = asyncio.run(
      OpenAI.async_chat_create(
          model = "gpt-3.5-turbo-16k",
          messages = [
              {"role": "user", "content": "Translate the following English text to French: “Multiple models, each with different capabilities and price points. Prices are per 1,000 tokens. You can think of tokens as pieces of words, where 1,000 tokens is about 750 words. This paragraph is 35 tokens”"}
          ],
          auto_retry = True,
      )
  )
  ```

  The latest version of the API allows for function calls to be made. This is currently only supported in `Chat` and requires api version: `2023-07-01-preview` for `azure`.
  Function calls support using `pydantic` models to auto-generate the schemas
  ```python
  import asyncio
  from enum import Enum
  from client_rotate import OpenAI
  from async_openai.utils import logger
  from pydantic import BaseModel, Field
  class Unit(str, Enum):
      celsius = "celsius"
      fahrenheit = "fahrenheit"
  class Weather(BaseModel):
      location: str = Field(..., description="The city and state, e.g. San Francisco, CA.")
      unit: Unit = Field(Unit.fahrenheit)
  functions = [
    {
      "name": "get_current_weather",
      "description": "Get the current weather in a given location",
      "parameters": Weather,
    }
  ]
  result: ChatResponse = OpenAI.chat_create(
      model = "gpt-3.5-turbo-16k",
      messages = [
          {"role": "user", "content": "What's the weather like in Boston today?"}
      ],
      functions = functions,
      auto_retry = True,
  )
  logger.info(f'Result Chat Message: {result.messages}')
  logger.info(f'Result Chat Function: {result.function_results}')
  logger.info(f'Result Usage: {result.usage}')
  logger.info(f'Result Consumption: {result.consumption}')
  """
  Result:
  > Result Chat Message: [ChatMessage(content='', role='assistant', function_call=FunctionCall(name='get_current_weather', arguments={'location': 'Boston, MA'}), name=None)]
  > Result Chat Function: [FunctionCall(name='get_current_weather', arguments={'location': 'Boston, MA'})]
  > Result Usage: prompt_tokens=16 completion_tokens=19 total_tokens=35
  > Result Consumption: 0.00012399999999999998
  """
  ```

  Your azure models may be named differently than the default mapping. By configuring the mapping, you can automatically map the models to the correct azure model (when using openai model names).
  ```python
  from async_openai import OpenAI
  """
  Default Azure Model Mapping
  {
      'gpt-3.5-turbo': 'gpt-35-turbo',
      'gpt-3.5-turbo-16k': 'gpt-35-turbo-16k',
      'gpt-3.5-turbo-instruct': 'gpt-35-turbo-instruct',
      'gpt-3.5-turbo-0301': 'gpt-35-turbo-0301',
      'gpt-3.5-turbo-0613': 'gpt-35-turbo-0613',
  }
  """
  AzureModelMapping = {
      'gpt-3.5-turbo': 'azure-gpt-35-turbo',
      'gpt-3.5-turbo-16k': 'azure-gpt-35-turbo-16k',
      'gpt-3.5-turbo-instruct': 'azure-gpt-35-turbo-instruct',
      'gpt-3.5-turbo-0301': 'azure-gpt-35-turbo-0301',
      'gpt-3.5-turbo-0613': 'azure-gpt-35-turbo-0613',
  }
  OpenAI.configure(
      api_key = "sk-XXXX",
      organization = "org-XXXX",
      debug_enabled = False,
      
      azure_api_base = 'https://....openai.azure.com/',
      azure_api_version = '2023-07-01-preview',
      azure_api_key = '....',
      azure_model_mapping = AzureModelMapping,
  )

  OpenAI.init_api_client('az', set_as_default = True, debug_enabled = True)

  result: ChatResponse = OpenAI.chat.create(
      model = "gpt-3.5-turbo-16k",
      messages = [
          {"role": "user", "content": "Translate the following English text to French: “Multiple models, each with different capabilities and price points. Prices are per 1,000 tokens. You can think of tokens as pieces of words, where 1,000 tokens is about 750 words. This paragraph is 35 tokens”"}
      ],
      auto_retry = True,
  )


pkgId: 7aee5b22b2d534311265e9f030ef06e7b5772f76c6208cf84066fc47a5def498
name: python-async-pokepy
arch: src
version: 0.1.5a0
epoch: 0
release: 1
summary: A simple asynchronous wrapper for the PokeAPI.co API.
url: https://github.com/PendragonLore/async_pokepy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-pokepy-0.1.5a0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/async_pokepy.svg)](https://pypi.python.org/pypi/async-pokepy/)
  [![PyPI status](https://img.shields.io/pypi/status/async_pokepy.svg)](https://pypi.python.org/pypi/async_pokepy/)
  [![PyPI license](https://img.shields.io/pypi/l/async_pokepy.svg)](https://github.com/PendragonLore/async_pokepy/blob/master/LICENSE)
  [![Documentation Status](https://readthedocs.org/projects/async-pokepy/badge/?version=master)](https://async-pokepy.readthedocs.io/en/master/?badge=master)
  [![Pipelines Status](https://gitlab.com/PendragonLore/async_pokepy/badges/master/pipeline.svg)](https://gitlab.com/PendragonLore/async_pokepy/pipelines)
  [![Build Status](https://img.shields.io/travis/com/PendragonLore/async_pokepy.svg?label=TravisCI)](https://travis-ci.com/PendragonLore/async_pokepy)
  [![CircleCI](https://img.shields.io/circleci/project/github/PendragonLore/async_pokepy/master.svg?label=CircleCI)](https://circleci.com/gh/PendragonLore/async_pokepy)
  [![AppYevorCI](https://img.shields.io/appveyor/ci/PendragonLore/async-pokepy/master.svg?label=AppVeyorCI)](https://ci.appveyor.com/project/PendragonLore/async-pokepy)

  An, in the works, asynchronous wrapper for the [PokeAPI.co API](https://pokeapi.co).

  You can check out the (failing) pipelines @ [gitlab](https://gitlab.com/PendragonLore/async_pokepy).



  The docs are available @ [readthedocs](https://async-pokepy.readthedocs.io/en/master/).



  The wrapper is available on PyPi, you can install it with:

  ``pip install async_pokepy``



  It's very recommended to install the library with lru-dict,
  you can do this by installing the wrapper with this command:

  ``pip install async_pokepy[lru]``

  The wrapper will throw a warning if you try to use it without this extra package.



  If you also want to be able to run the tests/lint install it with:

  ``pip install async_pokepy[tests]``

  The best way to run tests is by using ``tox``.

  For docs building:

  ``pip install async_pokepy[docs]``



  ```python
  import asyncio

  import async_pokepy


  async def main(query):
      client = await async_pokepy.Client.connect()

      pokemon = await client.get_pokemon(query)

      fmt = ", ".join(map(str, pokemon.abilities))
      print("{0} has the abilities {1}".format(pokemon, fmt))

      await client.close()


  loop = asyncio.get_event_loop()
  loop.run_until_complete(main("Snorlax"))
  ```

  This will output: "Snorlax has the abilities Gluttony, Thick Fat, Immunity".

  You can check out more examples in the [example](https://github.com/PendragonLore/async_pokepy/tree/master/example)
  folder in the github repository or in the introduction section of the docs.


pkgId: 7d085d7ea952a20e0a9fe889210070a351a6a3762c780d63eebd12b3579d74dd
name: python-async-processor
arch: src
version: 0.1.18
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/async-processor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-async-processor-0.1.18-1.src.rpm
checksum_type: sha256
description:
  ```console
  pip install "async_processor[sqs]"
  ```





  ```python
  from async_processor import (
      InputMessage,
      Processor,
      WorkerConfig,
      SQSInputConfig,
      SQSOutputConfig,
  )


  class MultiplicationProcessor(Processor):
      def process(self, input_message: InputMessage) -> int:
          body = input_message.body
          return body["x"] * body["y"]


  app = MultiplicationProcessor().build_app(
      worker_config=WorkerConfig(
          input_config=SQSInputConfig(
              queue_url="YOUR_INPUT_SQS_URL",
              visibility_timeout=2,
          ),
          output_config=SQSOutputConfig(queue_url="YOUR_OUTPUT_SQS_URL"),
      ),
  )
  ```


  ```console
  gunicorn app:app --workers 1 --worker-class uvicorn.workers.UvicornWorker --bind 127.0.0.1:8000
  ```

  Output:
  ```console
  ✦6 ❯ gunicorn app:app --workers 1 --worker-class uvicorn.workers.UvicornWorker --bind 127.0.0.1:8000
  [2023-08-17 16:10:33 +0530] [78736] [INFO] Starting gunicorn 21.2.0
  [2023-08-17 16:10:33 +0530] [78736] [INFO] Listening at: http://127.0.0.1:8000 (78736)
  [2023-08-17 16:10:33 +0530] [78736] [INFO] Using worker: uvicorn.workers.UvicornWorker
  [2023-08-17 16:10:33 +0530] [78738] [INFO] Booting worker with pid: 78738
  [2023-08-17 16:10:33 +0530] [78738] [INFO] Started server process [78738]
  [2023-08-17 16:10:33 +0530] [78738] [INFO] Waiting for application startup.
  2023-08-17 16:10:33,764 - app - INFO - Invoking the processor init method
  2023-08-17 16:10:33,765 - app - INFO - Processor init method execution completed
  2023-08-17 16:10:33,765 - app - INFO - Starting processor runner
  2023-08-17 16:10:34,461 - app - INFO - Started processor runner
  2023-08-17 16:10:34,462 - app - INFO - Polling messages
  [2023-08-17 16:10:34 +0530] [78738] [INFO] Application startup complete.
  ```


  ```console
  curl 'http://localhost:8000/process' -H 'Content-Type: application/json'  -d '{"request_id": "abc", "body": {"x": 1, "y": 2}}'
  ```

  Output:
  ```console
  ❯ curl 'http://localhost:8000/process' -H 'Content-Type: application/json'  -d '{"request_id": "abc", "body": {"x": 1, "y": 2}}'
  {"request_id":"abc","status":"SUCCESS","body":2,"error":null}
  ```

  * A FastAPI documentation dashboard will be available on http://localhost



  ```python
  import json
  import uuid

  from async_processor import InputMessage, OutputMessage, ProcessStatus
  import boto3


  def send_request(input_sqs_url: str, output_sqs_url: str):
      sqs = boto3.client("sqs")
      request_id = str(uuid.uuid4())

      sqs.send_message(
          QueueUrl=input_sqs_url,
          MessageBody=json.dumps(
              InputMessage(request_id=request_id, body={"x": 1, "y": 2}).dict()
          ),
      )

      while True:
          response = sqs.receive_message(
              QueueUrl=output_sqs_url, MaxNumberOfMessages=1, WaitTimeSeconds=19
          )
          if "Messages" not in response:
              continue
          msg = response["Messages"][0]
          response = OutputMessage(**json.loads(msg["Body"]))

          if ProcessStatus[response.status] is not ProcessStatus.SUCCESS:
              raise Exception(f"processing failed: {response.error}")
          print(response)
          break

  if __name__ == "__main__":
      send_request(input_sqs_url="YOUR_INPUT_SQS_URL", output_sqs_url="YOUR_OUTPUT_SQS_URL")
  ```

  Run the above python script
  ```console
  python send_async_request.py
  ```

  Output:
  ```console
  ❯ python send_async_request.py
  request_id='46a4ebc6-afdb-46a0-8587-ba29abf0f0d4' status='SUCCESS' body=2 error=None
  ```


