# packages

pkgId: 2b35863e31ecbde9ce564609fffb627f28d21d687863beec34c9541837de5df9
name: python-Alcohol-Total-Game
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: A collection of mini-games and utilities.
url: https://github.com/HongKiBum/Alcohol_Total_Game
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Alcohol-Total-Game-0.1.7-1.src.rpm
checksum_type: sha256
description:
  1. **비용 계산**
     - 영수증 사진과 인원 수를 입력하면, 총 비용을 계산하여 1인당 부담해야 할 금액을 정산해 줍니다.
  2. **취한 정도 파악 게임**
     - 음성 파일을 입력하면 문장 정확도를 기반으로 사용자의 취한 정도를 측정합니다.
  3. **사진 벌칙 게임**
     - 사용자가 업로드한 사진 속 손 모양을 분석하고 랜덤하게 벌칙 대상을 선택합니다.
  4. **사진 기반 인물 퀴즈**
     - 사용자 지정 사진을 입력해 인물 퀴즈를 진행할 수 있습니다.
  5. **룰렛 벌칙 게임**


pkgId: c9e025f2cf18f908e1ddf475418a123f495f3a7ffe638da190eceaf00cbaf748
name: python-AlekSIS-Core
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: AlekSIS (School Information System) — Core
url: https://aleksis.org
rpm_license: EUPL-1.2-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlekSIS-Core-3.2.1-1.src.rpm
checksum_type: sha256
description:
  This is the core of the AlekSIS framework and the official distribution
  (see below). It bundles functionality for all apps, and utilities for
  developers and administrators.
  If you are looking for the AlekSIS standard distribution, i.e. the complete
  software product ready for installation and usage, please visit the `AlekSIS®`_
  website or the distribution repository on `EduGit`_.


pkgId: 159a71ab43f3f385bc11d4a808647d347854121c947785ca23c9a096090e5676
name: python-AlexaPy
arch: src
version: 1.29.2
epoch: 0
release: 1
summary: Python API to control Amazon Echo Devices Programmatically.
url: https://gitlab.com/keatontaylor/alexapy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlexaPy-1.29.2-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Python version compatibility](https://img.shields.io/pypi/pyversions/alexapy)](https://pypi.org/project/alexapy)
  [![Version on PyPi](https://img.shields.io/pypi/v/alexapy)](https://pypi.org/project/alexapy)
  [![pipeline status](https://gitlab.com/keatontaylor/alexapy/badges/master/pipeline.svg)](https://gitlab.com/keatontaylor/alexapy/commits/master)
  ![PyPI - Downloads](https://img.shields.io/pypi/dd/alexapy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/alexapy)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/alexapy)

  Python Package for controlling Alexa devices (echo dot, etc) programmatically. This was originally designed for [alexa_media_player](https://github.com/custom-components/alexa_media_player) a custom_component for [Home Assistant](https://www.home-assistant.io/).

  **NOTE:** Alexa has no official API; therefore, this library may stop
  working at any time without warning.



  Originally inspired by [this blog](https://blog.loetzimmer.de/2017/10/amazon-alexa-hort-auf-die-shell-echo.html) [(GitHub)](https://github.com/thorsten-gehrig/alexa-remote-control).
  Additional scaffolding from [simplisafe-python](https://github.com/bachya/simplisafe-python)



  1.  [Check for open features/bugs](https://gitlab.com/keatontaylor/alexapy/issues)
      or [initiate a discussion on one](https://gitlab.com/keatontaylor/alexapy/issues/new).
  2.  [Fork the repository](https://gitlab.com/keatontaylor/alexapy/forks/new).
  3.  Install the dev environment: `make init`.
  4.  Enter the virtual environment: `pipenv shell`
  5.  Code your new feature or bug fix.
  6.  Write a test that covers your new functionality.
  7.  Update `README.md` with any new documentation.
  8.  Run tests and ensure 100% code coverage for your contribution: `make coverage`
  9.  Ensure you have no linting errors: `make lint`
  10. Ensure you have typed your code correctly: `make typing`
  11. Add yourself to `AUTHORS.md`.
  12. Submit a pull request!



  [Apache-2.0](LICENSE). By providing a contribution, you agree the contribution is licensed under Apache-2.0.



  [See the docs 📚](https://alexapy.readthedocs.io/en/latest/index.html).


pkgId: 8e03d473de6826af61b807e1578c45c49f27243eee9003fabf3a6c20f5bcdb7e
name: python-Alfred-Workflow
arch: src
version: 1.40.0
epoch: 0
release: 1
summary: Full-featured helper library for writing Alfred 2/3/4 workflows
url: http://www.deanishe.net/alfred-workflow/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Alfred-Workflow-1.40.0-1.src.rpm
checksum_type: sha256
description:
  * Catches and logs workflow errors for easier development and support
  * "Magic" arguments to help development/debugging
  * Auto-saves settings
  * Super-simple data caching
  * Fuzzy, Alfred-like search/filtering with diacritic folding
  * Keychain support for secure storage (and syncing) of passwords, API keys etc.
  * Simple generation of Alfred feedback (XML output)
  * Input/output decoding for handling non-ASCII text
  * Lightweight web API with modelled on `requests`_
  * Pre-configured logging
  * Painlessly add directories to ``sys.path``
  * Easily launch background tasks (daemons) to keep your workflow responsive
  * Check for new versions and update workflows hosted on GitHub.
  * Post notifications via Notification Center.


pkgId: 34edd4b8a9c80962d3d1f4920a0fa13f8690fcd406b659817b4806d07504b6e3
name: python-AlgBench
arch: src
version: 2.4.1
epoch: 0
release: 1
summary: Util for benchmarking algorithms.
url: https://github.com/d-krupke/AlgBench
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlgBench-2.4.1-1.src.rpm
checksum_type: sha256
description:
  There are a number of challenges when performing benchmarks for
  (long-running) algorithms.
  -  Saving all information requires a lot of **boilerplate code** and
     often you forget something.
  -  If you add some further instances or want to compare an additional
     parameter, you have to check which data is already available to
     **skip existing entries**. Same if you need to interrupt the
     benchmark.
  -  Just piping the results into a file can create a **huge amount of
     data**, no longer fitting into memory.
  -  Proper benchmarks often take days or even weeks to run, such that
     **parallelization** is necessary (e.g., with slurm) which requires a
     thread-safe database.
  -  Many file formats and databases are **difficult to access or
     impossible to repair** once corrupted.
  AlgBench tries to ease your life by
  -  saving a lot of the information and data (function arguments, return
     values, runtime, environment information, stdout, etc.) automatically
     with a single line of code
  -  remembering which function arguments have already run and skipping
     those
  -  providing a compressible database to save memory, and saving highly
     redundant information, e.g., of the environment, only once
  -  providing an NFS-compatible parallel database and compatibility to
     distribution libraries, such as slurminade
  -  using a simple format based on JSON and Zip to allow simple parsing
     and even repairing broken databases by hand
  There is a predecessor project, called
  `AeMeasure <https://github.com/d-krupke/AeMeasure>`__. AeMeasure made
  saving the data easy, but required more boilerplate code and reading the
  data was more difficult and less efficient.


pkgId: b30b101c69f90b11dccd5ba24b63cb956cdeb72ff24bad3f65682d7a1facb2af
name: python-AlgDiff
arch: src
version: 2.4
epoch: 0
release: 1
url: https://github.com/aothmane-control/Algebraic-differentiators/tree/master
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlgDiff-2.4-1.src.rpm
checksum_type: sha256
summary:
  AlgDiff is a Python class implementing all necessary tools for the design, analysis, and discretization of algebraic differentiators. An interface to Matlab is also provided.

description:
  * [Motivation](#motivation)
  * [On algebraic differentiators](#on-algebraic-differentiators)
  * [GUI](#gui)
  * [Prerequisites for the implementation](#prerequisites-for-the-implementation)
  * [Installation](#installation)
  * [How to use  the implementation](#how-to-use--the-implementation)
  * [Troubleshooting](#troubleshooting)
  * [Documentation](#documentation)
  * [Questions  &amp; Contact](#questions---contact)
  * [License](#license)
  * [References](#references)

  Estimating the derivatives of noisy signals is of paramount importance in many
  fields of engineering and applied mathematics. It is, however, a longstanding ill-posed
  and challenging problem, in the sense that a small error in measurement data can
  induce a significant error in the estimated derivatives.
  Figure 1 shows the results of the numerical estimation of the first time derivative of a noisy signal based on an algebraic differentiator on the one hand and the simple difference quotient rule on the other. This simulation shows the excellent performance of this numerical differentiation approach.
  | ![Motivation example](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/data/motivationAlgDiff.png) |
  |:--:|
  | Figure 1. Numerical differentiation of a noisy signal using a simple difference quotient on the one hand and an algebraic differentiator on the other |

  Algebraic differentiators have been derived and discussed in the systems and control theory community. The initial works based on differential-algebraic methods have been developed by Mboup,  Join, and Fliess in [[2]](#2). These numerical, non-asymptotic approximation approaches
  for higher-order derivatives of noisy signals are well suited for real-time embedded systems. A historical overview and a detailed discussion of these differentiators and their time-domain and frequency-domain properties are given in the survey [[1]](#1).
  The approximation-theoretic derivation recalled in the survey [[1]](#1) permits the interpretation of the estimation process by the following three steps illustrated in the figure below stemming from [[1]](#1):
  1. Projection: At time <img src="https://render.githubusercontent.com/render/math?math=t">, the sough <img src="https://render.githubusercontent.com/render/math?math=n">-th order time derivative <img src="https://render.githubusercontent.com/render/math?math=y^{(n)}"> over the interval <img src="https://render.githubusercontent.com/render/math?math=I_{T}(t)"> is projected onto the space of polynomials of degree <img src="https://render.githubusercontent.com/render/math?math=\mathrm{N}">. This yields the polynomial <img src="https://render.githubusercontent.com/render/math?math=p_\mathrm{N}"> depicted in the left and middle part of Figure 2.
  2. Evaluation: The polynomial <img src="https://render.githubusercontent.com/render/math?math=p_\mathrm{N}"> is evaluated at <img src="https://render.githubusercontent.com/render/math?math=t-\delta_t">, which gives an estimate <img src="https://render.githubusercontent.com/render/math?math={\hat{y}^{(n)}(t)=p_{\N}(t-\delta_t)}"> for the derivative <img src="https://render.githubusercontent.com/render/math?math=y^{(n)}(t)"> as depicted in the central part of Figure 2. Choosing the delay to be the largest root of a special Jacobi polynomial increases the approximation order by 1 with a minimal delay. Alternatively, a delay-free estimation or even a prediction of the future derivative might be
      selected, at the cost of a reduced accuracy.
  3. Repetition: The first two steps are repeated at each discrete time instant <img src="https://render.githubusercontent.com/render/math?math=t_i"> while keeping the parameters of the differentiator constant. This yields  the estimate <img src="https://render.githubusercontent.com/render/math?math=\hat{y}^{(n)}"> depicted in the right part of the Figure 2.
  | ![filter_characteristics](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/data/interpretationDifferentiators.png) |
  |:--:|
  | Figure 2. Three-step process of the estimation of the  <img src="https://render.githubusercontent.com/render/math?math=n">-th order derivative <img src="https://render.githubusercontent.com/render/math?math={y^{(n)}:t\mapsto y^{(n)}(t)}"> of a signal <img src="https://render.githubusercontent.com/render/math?math=y:t\mapsto y(t)"> using  algebraic differentiators (figure from [[1]](#1)) |
  Algebraic differentiators can be interpreted as linear time-invariant filters with a finite-duration impulse response. Figure 3 visualizes the online estimation process of the first derivative of a noisy signal. The filter window, the buffered signal, and the filter kernel can be clearly seen.
  |  <img src="https://github.com/aothmane-control/Algebraic-differentiators/blob/master/data/animationEstimation.gif" height="500">|
  |:--:|
  | Figure 3. Visualization of the online estimation of the first derivative a noisy signal using an algebraic differentiator.|
  These filters can be approximated as lowpass filters with a known cutoff frequency and a stopband slope. Figure 4 presents the amplitude and phase spectra of two exemplary filters. The lowpass approximation is also shown.
  | ![filter_characteristics](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/data/filterSpectrum.png) |
  |:--:|
  | Figure 4. Amplitude and phase spectra of two different filters and the corresponding lowpass approximation of the amplitude spectrum |
  See [[1]](#1), [[3]](#3), [[4]](#4), and [[5]](#5) for more details on the parametrization of these differentiators.

  Since Version 1.1 a GUI is provided. Executable files for Linux and Windows operating systems are provided and do not require the installation of additional software. The binary files of the GUIs for different operating systems can be downloaded from the latest release [page](https://github.com/aothmane-control/Algebraic-differentiators/releases).
   Neither Python not Matlab have to be installed to start designing algebraic differentiators, get discrete filter coefficients, and estimate derivatives. This GUI can be used to plot relevant data (impulse and step responses, amplitude and phase spectra, estimated derivatives, ...), display relevant properties of the differentiators (estimation delay, cutoff frequency, window length, discretization effects, ...), and load measured signals for the estimation of their derivatives without a single line of code. Relevant properties, signals, spectra, and discrete filter coefficients can be exported for further processing. For testing the import of measurement data, a [file](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/QuickStart.ipynb) has been provided in the folder DataForGUI.
  | ![GUI](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/data/figureGUI.png) |
  |:--:|
  | Figure 5. GUI for the interactive design, analysis, and use of algebraic differentiators |

  The code is implemented in Python 3. To use all functionalities the required packages are given in the requirements.txt file. The examples implemented in Python are written in [jupyter notebooks](https://jupyter.org/) and require the packages [jupyter_latex_envs](https://github.com/jfbercher/jupyter_latex_envs) for the generation of useful documentations and [matplotlib](https://matplotlib.org/) for the creation of plots. The functions in the toolbox can also be used in Matlab for which different examples are also included. Check the Matlab [documentation](https://de.mathworks.com/help/matlab/matlab_external/install-supported-python-implementation.html) for more details on the compatibility of your Matlab version with Python.

  To use AlgDiff using pip run the following in the command line:
  ```
     $ pip install AlgDiff
  ```

  The contribution of this implementation is an easy to use framework for the design and discretization of algebraic differentiators to achieve desired filter characteristics, i.e., to specify the cutoff frequency and the stopband slope. The file [algebraicDifferentiator.py](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/algebraicDifferentiator.py) implements the class AlgebraicDifferentiator. This class contains all necessary functions for the design, analysis, and discretization of the differentiators.
  Different examples are provided as jupyter notebooks and Matlab code in the following:
  * A quick start in a jupyter [notebook](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/QuickStart.ipynb) available also as an [HTML file](https://htmlpreview.github.io/?https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/QuickStart.html)
  * A detailed jupyter [notebook](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/DetailedExamples.ipynb) available also as an [HTML file](https://htmlpreview.github.io/?https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/DetailedExamples.html)
  * The simultaneous elimination of a harmonic disturbance and approximation of derivatives is demonstrated in the jupyter [notebook](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/EliminationDisturbancesExample.ipynb) available also as an [HTML file](https://htmlpreview.github.io/?https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/EliminationDisturbancesExample.html)
  * A quick start in [Matlab](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/QuickStart.mlx)
  * A [Matlab](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/examples/DetailedExamples.mlx) code with several examples

  A list of known issues and fixes is also [provided](https://algebraic-differentiators.readthedocs.io/en/latest/troubleshooting.html).

   A detailed [documentation](https://algebraic-differentiators.readthedocs.io/en/latest/documentation.html) for all the functions is also provided in the webpage of the [project](https://algebraic-differentiators.readthedocs.io/en/latest/index.html).

  Feel free to contact [Amine](https://www.uni-saarland.de/en/chair/rudolph/staff/aothmane.html) in case of suggestions or questions.

  BSD 3-Clause "New" or "Revised" License, see [License-file](https://github.com/aothmane-control/Algebraic-differentiators/blob/master/LICENSE).

  <a id="5">[1]</a> A. Othmane, L. Kiltz, and J. Rudolph, "Survey on algebraic numerical differentiation: historical developments, parametrization, examples, and applications", Int. J. Syst. Sci. https://doi.org/10.1080/00207721.2022.2025948
  <a id="1">[2]</a> M. Mboup,  C. Join, and M. Fliess, "Numerical differentiation with annihilators in noisy environment", Numerical Algorithms, 50 (4), 439–467, 2009, https://doi.org/10.1007/s11075-008-9236-1
  <a id="2">[3]</a> L. Kiltz and J. Rudolph, “Parametrization of algebraic numerical
  differentiators to achieve desired filter characteristics,” in Proc. 52nd
  IEEE Conf. on Decision and Control, Firenze, Italy, 2013, pp. 7010–
  7015, https://doi.org/10.1109/CDC.2013.6761000
  <a id="3">[4]</a> M. Mboup and S. Riachy, "Frequency-domain analysis and tuning of the algebraic differentiators," Int. J. Control , 91 (9), 2073–2081, 2018, https://doi.org/10.1080/00207179.2017.1421776
  <a id="4">[5]</a> A. Othmane, J. Rudolph, and H. Mounier, "Systematic comparison of numerical differentiators and an application to model-free control", Eur. J. Control. https://doi.org/10.1016/j.ejcon.2021.06.020
  <a id="6">[6]</a> A. Othmane and J. Rudolph "AlgDiff: an open source toolbox for the design, analysis and discretisation of algebraic differentiators", at - Automatisierungstechnik https://doi.org/10.1515/auto-2023-0035 https://arxiv.org/abs/2308.04888

rpm_license:
  Copyright 2024 Amine Othmane  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: 74737f019b2876e440166ae9210415ba420ed53a4cd1e28b81126bbad3f33753
name: python-AlgebraicNumber
arch: src
version: 2.4.4
epoch: 0
release: 1
summary: Manipulation of algebraic numbers
url: https://gitlab.com/ydethe/algebraicnumber
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlgebraicNumber-2.4.4-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/AlgebraicNumber.svg)](https://pypi.python.org/pypi/AlgebraicNumber)
  [![image](https://gitlab.com/ydethe/algebraicnumber/badges/master/pipeline.svg)](https://gitlab.com/ydethe/algebraicnumber/pipelines)
  [![codecov](https://codecov.io/gl/ydethe/algebraicnumber/branch/master/graph/badge.svg?token=T84J2LCHND)](https://codecov.io/gl/ydethe/algebraicnumber)

  A library to manipulate algebraic numbers



  To generate the documentation,run:

      nox

  https://ydethe.gitlab.io/algebraicnumber/docs



      >>> z = AlgebraicNumber.unity() + AlgebraicNumber.imaginary()
      >>> z.poly.printCoeff()
      '[2,-2,1]'
      >>> p = z*z.conj()
      >>> p.poly.printCoeff()
      '[-2,1]'


pkgId: a6103c593cf26a2cadc83d4482fb801da24d902d115605f33a243bd0a4dc96d2
name: python-AlgoM
arch: src
version: 1.4
epoch: 0
release: 1
summary: Python algorithms and data structures library
url: https://github.com/martarel/AlgoPack
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlgoM-1.4-1.src.rpm
checksum_type: sha256
description:
  Use this package to quickly implement various algorithms in python.
  Read the full documentation at: https://martarel.pythonanywhere.com/algoM/docs/


pkgId: 14bd898484be13d1df9b546ef669e7c4dc10a47998c5a6b703138ea4f66d0bd2
name: python-AlgorithmADTs
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: General purpose Abstract Data Types for Algorithmics
url: https://pypi.org/project/AlgorithmADTs/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlgorithmADTs-0.3.3-1.src.rpm
checksum_type: sha256
description:
  Finlay's package for Abstract Data Types written for Algorithmics class


  Run the following command in your terminal:
  `pip install AlgorithmADTs --force-reinstall`

  AlgorithmADTs can now be imported into your python scripts!

  I recommend `from AlgorithmADTs import *` to include all functionality, but you can also import from `AlgorithmADTs.AbstractDataTypes` or `AlgorithmADTs.GraphAlgorithms`


  ```
  Array
      create: Integer -> Array
      set: Array x Integer x Element -> Array
      get: Array x Integer -> Element

  ```

  ```
  List
      create: None -> List
      is_empty: Array -> Boolean
      set: Array x Integer x Element -> List
      get: Array x Integer -> Element
      append: Array x Element -> List
  ```
  ```
  Stack
      create: None -> Stack
      push: Stack x Element -> Stack
      pop: Stack -> Stack
      is_empty: Stack -> Boolean
      head: Stack -> Element
  ```
  ```
  Queue
      create: None -> Queue
      enqueue: Queue x Element -> Queue
      dequeue: Queue -> Queue
      is_empty: Queue -> Boolean
      head: Queue -> Element
  ```
  ```
  PriorityQueue
      create: None -> Priority Queue
      enqueue: Priority Queue x Element x Integer -> Priority Queue
      dequeue: Priority Queue -> Priority Queue
      is_empty: Priority Queue -> Boolean
      head: Priority Queue -> Element
  ```
  ```
  Dictionary
      create: None -> Dictionary
      get: Dictionary x Element -> Element
      set: Dictionary x Element x Element -> Dictionary
      add: Dictionary x Element x Element -> Dictionary
      remove: Dictionary x Element -> Dictionary
      has_key: Dictionary x Element -> Boolean
      is_empty: Dictionary -> Boolean
  ```
  ```
  Graph
      create: None -> Graph
      add_node: Graph x Element -> Graph
      add_edge: Graph x Element x Element -> Graph
      adjacent: Graph x Element x Element -> Boolean
      neighbours: Graph x Element -> List
  ```
  Multiple nodes and edges can now be added at one time with `add_nodes` and `add_edges`, using an iterable
  ```
  WeightedGraph (inherits from Graph)
      create: None -> Graph
      add_node: Graph x Element -> Graph
      add_edge: Graph x Element x Element -> Graph
      adjacent: Graph x Element x Element -> Boolean
      neighbours: Graph x Element -> List
      get_weight: Graph x Element x Element -> integer
  ```


  Note that there is no restriction in these classes that elements be hashable, unlike some Python data types
  e.g. a Python `dict` requires keys to be hashable.

  It also defines a variable `infinity`, set equal to `float('inf')`

  The following magic methods are supported:
  - `__getitem__` and `__setitem__` for classes with a 'get' and 'set' function.
      This allows you to call `instance[key]` and `instance[key] = value`.
  - `__iter__` for Array and List, which operates as expected. Dictionary iter returns an iterable of keys.
      This enables iterating through a class like `for elem in instance`
  - `__str__` and `__repr__` are defined for all classes except graphs and allow for classes to be easily viewed through printing
      Note that only the head element is visible for a stack or queue, so it is the only information that can be returned by these methods
  - Numerical magic methods (e.g. `__add__`) are defined for matrices
  - `__len__` is defined for Array, List and Dictionary


  Currently, the following graph algorithms are defined:
  - Prim's algorithm for computing the Minimal Spanning Tree of a weighted, undirected graph
  - Dijkstra's algorithm for finding the single source shortest path in a weighted graph
  - The Bellman-Ford algorithm which extends the functionality of Dijkstra's algorithm to allow for negative weights
  - The two variants of the Floyd-Warshall algorithm to calculate shortest path between all nodes and transitive closure of an unweighted graph
  - The PageRank algorithm for determining the relative importance of nodes in an unweighted graph


  To implement:
  - ALLOW `List([1,3,34])` rather than having to stupidly define every value separately.
  - Allow default value for Arrays
  - Optional hashing for graphs?
  - Search methods like DPS BFS
  - LEn of dict


pkgId: 70a6ce5e52700986230a95b70e02c5c5109e45565d0f9ece1eadf866cac160f6
name: python-AliceGit
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: Project Alice Python to Git utilities
url: https://github.com/project-alice-assistant/AliceGit
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AliceGit-1.0.7-1.src.rpm
checksum_type: sha256
description:
  A python bridge to Git for Project Alice.

  This is in no way intended to be suitable for other projects, although, many functions will work.


  ```bash
  pip3 install AliceGit
  ```


  - Clone this repository
  - Open a terminal on whatever OS you are
  - CD to the path where you cloned this repository
  - Create a python 3.8+ virtual environment:
    `python -m venv`
  - Activate your virtual environment
  - Install the package in dev mode:
    `pip install --editable .`


pkgId: a4ef84c763e4c131d0361248bfd830efd0edc91255988beb604e3ad1c5d81489
name: python-AlignmentUtilis
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Simple application of sequence alignment algorithms
url: https://pypi.org/project/AlignmentUtilis/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlignmentUtilis-0.1.0-1.src.rpm
checksum_type: sha256
description:
  `AlignmentUtilis` is a collection utilities of sequence alignment algorithms,

  - Needleman-Wunsch and Smith-Watermen algorithms to conduct sequence alignment with affine gap penalty
  - Naive exact matching to conduct reads alignment problem
  - ...



  ```shell
  pip install AlignmentUtilis
  ```





  ```shell

  from AlignmentUtilis.Pairwise import *

  seq1 = "TCGTAGACGA"
  seq2 = "ATAGAATGCGG"

  PairwiseSequenceAlignment.Runalignment(seq1, seq2, 1, -1, -2, -1, local=False)

  PairwiseSequenceAlignment.Runalignment(seq1, seq2, 1, -1, -2, -1, local=True)


  from AlignmentUtilis.Naive import *

  test_occurrences = Naive.naive_exact_matching('AG', 'AGCTTAGATAGC')
  print('The pattern is AG')
  print('The target sequence is AGCTTAGATAGC')
  print(f'The start position of exact matching is {test_occurrences}')


  from AlignmentUtilis.BM import *

  p = 'TCAA'
  p_bm = BoyerMoore(p)
  print(p_bm.amap)
  print(p_bm.bad_character_rule(2, 'T'))

  t = 'ACGTCGTGCGGTGAGTCGGTAGCGTAGCTAGATACAATCAAGAGAGAGTGCGGAGTGCGAGTCAA'
  occurrences = boyer_moore(p, p_bm, t)
  print(occurrences)


  from AlignmentUtilis.KmerIndex import *
  t = 'GCTACGATCTAGAATCTA'
  p = 'TCTA'
  index = Index(t, 2)
  print(queryIndex(p, t, index))
  ```





  MIT License
  Copyright (c) 2022 Youpu Chen
  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: 3242fec75fe9a03c67ec6c80e6168a686dbe851aef052adc9956e635fb385477
name: python-AlistMediaRename
arch: src
version: 2.7.0
epoch: 0
release: 1
url: https://pypi.org/project/AlistMediaRename/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlistMediaRename-2.7.0-1.src.rpm
checksum_type: sha256
summary:
  从 The Movie Database(TMDb) 获取剧集/电影信息，并对 Alist 指定媒体文件重命名，便于播放器刮削识别剧集/电影。测试Kodi, Nplayer, Infuse均可正确识别媒体信息。

description:
  从 The Movie Database(TMDb) 获取剧集/电影信息，并对 Alist 指定媒体文件重命名，便于播放器刮削识别剧集/电影。测试Kodi, Nplayer, Infuse均可正确识别媒体信息。

  ![](./tutorial.gif)





  - [x] 重命名异步操作，速度已较上个版本快数十倍
  - [x] 自动通过 Alist 2FA 验证
  - [x] 支持电影/剧集文件重命名
  - [x] 根据关键字/TMDbID 搜索媒体信息
  - [x] 从指定季数、指定集数开始重命名文件
  - [x] 自动排除已重命名成功的文件
  - [x] 指定文件重命名格式





  1. 环境配置

     Python(>=3.9)，建议使用 3.12 版本，已在 Windwos 11/Linux 测试通过。

  2. 安装依赖

     从 PyPI 安装包

     `pip install AlistMediaRename`

     从 PyPI 升级包

     `pip install --upgrade AlistMediaRename`

     若想使用本地模块请进行操作：
     `git clone https://github.com/jkoor/Alist-Media-Rename.git`
     安装以下四个库：`requests`, `pyotp`, `natsort`, `colorama`, `pydantic`

  4. 下载`src/main.py` 主程序文件

  5. 获取 TMDb API 密钥

     首次运行会要去输入 TMDb API 密钥， 用于获取 TMDb 电影/剧集信息，可前往 TMDb 官网免费申请，链接：https://developers.themoviedb.org/3/getting-started/introduction


  6. Alist 2FA 验证（未开启可跳过）

     若用户开启了 Alist 2FA 验证功能，则需要提供验证密钥（非6位验证码），可通过保存验证码的对应 APP 获取，或者扫描初次绑定的二维码，可获取一串代码，最后的 sercet 字段即为 base64 密钥，格式为一串包含数字和字母的长字段，如：2ELR4M···KVH563X





  初始使用请按提示输入 Alist 网址、账号、密码、2FA 密钥以及 TMDb API 密钥，配置信息会保存在同目录下`config.json`文件中。

  **使用方法**

  ```

  python main.py [剧集关键字] -d [Alist 文件夹路径]


  python main.py -i [剧集id] -d [Alist 文件夹路径]


  python main.py [剧集关键字] -d [Alist 文件夹路径] -n [集数]


  python main.py -m [电影关键字] -d [Alist 文件夹路径]
  python main.py -m -i [电影id] -d [Alist 文件夹路径]


  python main.py [剧集关键字] -d [Alist 文件夹路径] -p [路径访问密码]


  python main.py -h
  ```



  **举个例子**

  TMDb 的剧集/电影 id 为对应网址中的数字，如剧集[《刀剑神域》](https://www.themoviedb.org/tv/45782)的 id 为 45782，电影《[刀剑神域：序列之争](https://www.themoviedb.org/movie/413594)》的 id 为 413594

  剧集《刀剑神域》的视频及字幕文件在 Alist 网盘中路径为：/阿里云盘/动漫/SAO/

  文件重命名前后对比：1.mp4 -> 刀剑神域-S01E01.剑的世界.mp4

  ```

  python main.py 刀剑神域 -d /阿里云盘/动漫/SAO


  python main.py -i 45782 -d /阿里云盘/动漫/SAO -p 123
  ```

  电影《刀剑神域：序列之争》的视频及字幕文件在 Alist 网盘中路径为：/阿里云盘/电影/SAO

  ```

  python main.py -m 刀剑神域 -d /阿里云盘/电影/SAO


  python main.py -m -i 413594 -d /阿里云盘/电影/SAO -p 123
  ```

  完整参数列表：python main.py -[?] [keyword] -d [dir]

  | 参数            | 类型 | 默认          | 说明                                      |
  | --------------- | :--: | ------------- | ----------------------------------------- |
  | keyword         | 必须 |               | TMDb 搜索字段                             |
  | -d              | 必须 |               | Alist 文件夹路径                          |
  | -i, --id        | 可选 |               | 根据 TMDb id 获取剧集/电影信息            |
  | -m, --movie     | 可选 |               | 查找电影信息，而不是剧集                  |
  | -p, --password  | 可选 | None          | Alist 文件夹访问密码                      |
  | -n, --number    | 可选 | 1             | 指定从第几集开始命名                      |
  | -c, --config    | 可选 | ./config.json | 指定配置文件路径                          |
  | -f, --folderdir | 可选 | 1             | 覆盖配置文件中的`media_folder_rename`参数 |
  | -h, --help      |  /   |               | 显示使用帮助信息                          |
  | -v, --version   |  /   |               | 显示版本信息                              |

  **配置文件**

  在本地保存的配置文件中，除基本的登录参数外，还包含几个可配置项

  | alist 相关参数 | 类型   | 默认值           |
  | -------------- | ------ | ---------------- |
  | url            | str    | ""               |
  | guest_mode     | *bool* | True / **False** |
  | user           | str    | ""               |
  | password       | str    | ""               |
  | totp           | str    | ""               |

  1. `url`: alist 主页
  1. `guest_mode`: 使用访客身份权限，不需要登陆
  1. `user`: 用户名
  1. `password`: 密码
  1. `totp`: 二次验证密钥

  | TMDB 相关参数 | 类型 | 默认值                       |
  | ------------- | ---- | ---------------------------- |
  | api_url       | str  | https://api.themoviedb.org/3 |
  | api_key       | str  | ""                           |
  | language      | str  | "zh-CN"                      |

  1. `api_url`: TMDB API 链接
  2. `api_key`: TMDB API 密钥
  3. `language`: 指定TMDb获取信息及重命名语言，遵循 ISO 639-1 标准

  | amr 相关参数           | 类型   | 默认值                                        |
  | ---------------------- | ------ | --------------------------------------------- |
  | exclude_renamed        | *bool* | ***True*** / False                            |
  | rename_by_async        | *bool* | ***True*** / False                            |
  | media_folder_rename    | bool   | ***True*** / False                            |
  | folder_name_format     | *str*  | {name} ({year})                               |
  | movie_name_format      | *str*  | {name} ({year})                               |
  | tv_name_format         | *str*  | {name}-S{season:0>2}E{episode:0>2}.{title}    |
  | video_regex_pattern    | *list* | \(\?i\)\.\*\\\.\(flv\|mov\|mp4\|mkv\|rmvb\)\$ |
  | subtitle_regex_pattern | *list* | \(\?i\)\.\*\\\.\(ass\|srt\|ssa\|sub\)\$       |

  1. `exclude_renamed`: 是否排除已重命名成功的文件
  5. `rename_by_async`: 是否使用异步操作进行重命名

  > 异步操作可以极大地缩短多文件重命名所需时间，但由于各网盘的限制方式不同，若出现请求频繁状态，可将此参数设置为`False`禁用。

  6. `media_folder_rename`: 指定是否对父文件夹重命名

  7. `folder_name_format`: 父文件夹重命名格式，使用python `format()`函数识别

     可用变量：参考 `movie_name_format` / `tv_name_format`

  8. `movie_name_format`: 电影文件重命名格式，使用python `format()`函数识别

     可用变量：

     **name**: 电影名称

     **original_name**: 电影原始名称（未翻译名称）

     **year**: 上映年份

     **release_date**: 上映日期

     **language**: 电影语言

     **region**: 电影所属地区

     **rating**: 电影评分（TMDB）

     默认命名：{name} ({year}) -> 复仇者联盟 (2012).mp4


  8. `tv_name_format`：剧集文件重命名格式，使用python `format()`函数识别

     可用变量：

     **name**: 剧集名称

     **original_name**: 剧集原始名称（未翻译名称）

     **year**: 剧集首播年份

     **first_air_date**: 剧集首播年份

     **language**: 剧集语言

     **region**: 剧集所属地区

     **rating**: 剧集评分（TMDB）

     **season**: 剧集季度

     单集可用变量：

     **episode**: 单集序号

     **air_date**: 单集放映日期

     **episode_rating**: 单集评分（TMDB）

     **title**: 单集标题

     默认命名：{name}-S{season:0>2}E{episode:0>2}.{title} -> 刀剑神域-S01E01.剑的世界.mp4

  9. `video_regex_pattern`: 需要识别的视频文件正则表达式

  10. `subtitle_regex_pattern`: 需要识别的字幕文件正则表达式



  若需要在其他 Python 文件中调用本程序，可参考以下内容：

  在`AlistMediaRename`文件夹定义了一个类Amr()，根据代码注释要求传入相关参数，即可调用本程序的主函数

  ```python
  from AlistMediaRename import Amr, Config


  config = Config()
  config.alist.url = "xxx"
  config.alist.user = "xxx"
  config.alist.password = "xxx"
  config.alist.totp = "xxx"
  config.tmdb.api_key = "xxx"
  config.save("./config.json") # 保存配置到文件
  config.load("./config.json") # 从文件中读取配置
  amr = AlistMediaRename(config)

  amr = AlistMediaRename("./config.json") # 从文件中读取配置，文件不存在则会自动创建


  amr.movie_rename_id('keyword', 'dir', 'password')

  amr.movie_rename_keyword('keyword', 'dir', 'password')

  amr.tv_rename_id('keyword', 'dir', 'password')

  amr.tv_rename_keyword('keyword', 'dir', 'password')

  ```





  - 本项目是受到了 GitHub 中一个获取TMDb信息并对本地文件重命名项目的启发：[wklchris/Media-Renamer](https://github.com/wklchris/Media-Renamer)

  - TMDb Api 在短时间内频繁使用会限制使用，如出现此情况请稍后再试

  - 欢迎邮件联系，一起交流探讨：oharcy@outlook.com

  - 本程序使用 TMDB API，但未经 TMDB 认可或认证。

    ![](https://www.themoviedb.org/assets/2/v4/logos/v2/blue_long_2-9665a76b1ae401a510ec1e0ca40ddcb3b0cfe45f1d51b77a308fea0845885648.svg)


pkgId: fe0eca8c7b15778ad0f94512fb2b8e1f1271154756e643219eef607a85f5c4f3
name: python-All-in-one-chay
arch: src
version: 4.1.1
epoch: 0
release: 1
summary: 多功能一体机（All-in-one）
url: https://github.com/lichenyichay/All-in-one-Including/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-All-in-one-chay-4.1.1-1.src.rpm
checksum_type: sha256
description:
  Line 9 中文版README

  Line 348 Readme in English





  多功能一体机库版本，现已更新至4.0.0版本
  说明如下：





  Line 40 Allinone.py 主文件

  Line 70 shujuku.py 数据库文件

  Line 94 xiaogongju.py 模块文件

  Line 128 calculator.py 计算器模块

  Line 205 numbertochinese.py 数字、中文互换模块

  Line 237 lotterytickets.py 彩票一体机模块

  Line 260 erfenchazhao_py.py 二分查找模块

  Line 282 marh_cal.py math库计算器模块

  Line 304 student_py.py 小学学生信息管理系统模块

  Line 324 tuxing_cal.py 图形计算器模块



  ```python

  Help on module Allinone:

  NAME
      Allinone

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS
      allinone(fuwu, mode, *args)
          :param fuwu 需要服务的功能
          :param mode 部分功能需要的模式（详见Github中All-in-one2.4.0分支的Wiki页）
          :param *args 可变参数，表示需要传入的参数，建议用元组或列表类型，具体所需类型见README.MD
          :return: 0：正常，1：不正常，其他返回值表示功能的结果

          功能（按代码顺序排序，不分先后）：大小写互换、抽取随机数、求最小公倍数、求最大公倍数、图形计算器、小学学生信息管理系统、二分查找、求余、向下取整、向上取整、多个数求和、多个数求差、多个数求积、判断闰年、判断是否为质数、整数、小数计算（加减乘除）、分数计算（加减乘除）......（具体见Github All-in-one2.4.0分支Readme.md文件）

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\allinone.py
  ```



  ```python
  Help on module shujuku:

  NAME
      shujuku

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS

      sjc(fuwu: str, mode: int, canshu: str)

  FILE
      d:\chay\project\all-in-one-including(git)\all-in-one_chaylichenyi\module\shujuku.py
  ```



  ```python
  Help on module xiaogongju:

  NAME
      xiaogongju

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      chouqusuiji(num1: int, num2: int, mode: int, weishu: int) -> str

      daorxiao(args: str, mode: int) -> str

      f(a: float, n: int, m: int) -> int

      kaisamima(arg: str, mode: int, n: int) -> str

      quzheng(num: float, mode: int) -> int

      twonumbers_TheBiggestCommonfactor(num1: int, num2: int) -> int

      twonumbers_TheMinimumCommonmultiple(num1: int, num2: int) -> int

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\xiaogongju.py
  ```



  ```python
  Help on module calculator:

  NAME
      calculator

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      FtemporCtemp(mode: str, FtemporCtemp: float) -> float

      duihuan(mode: int, money: float) -> float

      fab(x: int) -> int

      factorization(num: int) -> list[int]

      fanzhuanzifuchuan(s: str) -> str

      fenjisuan(num1: str, num2: str, mode: str) -> float

      isfab(x: int) -> bool

      isfabhuiwenshu(x: int) -> bool

      isfabhuiwenzhishu(x: int) -> bool

      isfabparam(x: int) -> bool

      isfabwanquanpingfangshu(num: int) -> bool

      ishuiwenshu(d: int) -> bool

      ishuiwenzhishu(d: int) -> bool

      isleapyear(x) -> bool

      isparam(d: int) -> bool

      istribonacci(n: int) -> bool

      istribonaccihuiwenshu(n: int) -> bool

      istribonaccihuiwenshuparam(n: int) -> bool

      istribonacciparam(n: int) -> bool

      istribonacciwanquanpingfangshu(num: int) -> bool

      iswanquanpingfangshu(num: int) -> bool

      jinzhizhuanhuan(a: int, b: int, c: str) -> str

      mima(num: int, n: int) -> int

      tribonacci(n: int) -> int

      wanquanpingfangshu(num: int) -> int

      xiaoorfen(num: str, mode: int) -> str

      xiaoorzhengjisuan(num1: float, num2: float, mode: str) -> float

      yiyuannci(fangcheng: str, mode: int) -> tuple

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\calculator.py

  ```



  ```python
  Help on module numbertochinese:

  NAME
      numbertochinese

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS
      No2Cn(number: int) -> str

      chinese2digits(uchars_chinese: str) -> int

      maxdigit(number: int, count: int) -> tuple

  DATA
      common_used_numerals = {'零': 0, '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '日': 7, '八': 8, '九': 9, '十': 10, '百': 100, '千': 1000, '万': 10000, '亿': 100000000}
      digitdict = {1: '十', 2: '百', 3: '千', 4: '万'}
      numdict = {1:"一",2:"二",3:"三",4:"四",5:"五",6:"六",7:"七",8:"八",9:"九",0:"零"}

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\numbertochinese.py
  ```



  ```python
  Help on module lotterytickets:

  NAME
      lotterytickets

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS
      lotterytickets(user: str, mubiao: str, mode: int) -> str

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\lotterytickets.py
  ```



  ```python
  Help on module erfenchazhao_py:

  NAME
      erfenchazhao_py

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      erfenchazhao(yuanlst, shengxulst, target)

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\erfenchazhao_py.py
  ```



  ```python
  Help on module math_cal_py:

  NAME
      math_cal_py

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      math_cal(mode, float1, float2)

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\math_cal_py.py
  ```



  ```python
  Help on module student_py:

  NAME
      student_py

  DESCRIPTION
      函数名：student
      调用形式：student()
      作用：小学学生信息管理系统

  FUNCTIONS
      student()

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\student_py.py
  ```



  ```python
  Help on module tuxing_cal:

  NAME
      tuxing_cal

  DESCRIPTION
      函数名：tuxing
      调用形式：tuxing(huida)
      :param huida 图形
      :return 0
      作用：进行图形计算

  FUNCTIONS
      tuxing(huida, mode, *args2)

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\tuxing_cal.py
  ```

  详见<https://github.com/lichenyichay/All-in-one> 和 <https://github.com/lichenyichay/All-in-one-Including/wiki>







  Line 364 Allinone Main Module Documentation

  Line 370 Calculator Module Documentation

  Line 673 Xiaogongju Module Documentation

  Line 760 Math_calculator Module Documentation

  Line 820 Tuxing_calculator Module Documentation



  Allinone.py
  Main module for the Allinone Function.
  mode:depending on your choice, you can choose the function you want to use.(such as you choose Ftemp or Ctemp you should incoming mode param in "℃to℉" or "℉to℃")



  FtemporCtemp
  Converts temperature between Fahrenheit and Celsius.

  ```python
  def FtemporCtemp(mode: str, FtemporCtemp: float) -> float
  ```

  mode: "℃to℉" (Celsius to Fahrenheit) or "℉to℃" (Fahrenheit to Celsius)
  FtemporCtemp: Temperature to convert
  Returns: Converted temperature (without unit)

  duihuan
  Performs currency exchange.

  ```python
  def duihuan(mode: int, money: float) -> float
  ```

  mode: 1-16, corresponding to different currency conversions
  money: Amount to exchange (in the currency unit before the arrow in the mode)
  Returns: Converted currency amount

  yiyuannci
  Solves linear, quadratic, and cubic equations.

  ```python
  def yiyuannci(fangcheng: str, mode: int) -> tuple
  ```

  fangcheng: Equation in the form ax+b=0, ax^2+bx+c=0, or ax^3+bx^2+cx+d=0
  mode: Highest degree of the equation (1, 2, or 3)
  Returns: Tuple containing the solution(s) of the equation

  fanzhuanzifuchuan
  Reverses a string.

  ```python
  def fanzhuanzifuchuan(s: str) -> str
  ```

  s: String to reverse
  Returns: Reversed string
  isparam
  Checks if a number is prime.

  ```python
  def isparam(d: int) -> bool
  ```

  d: Number to check
  Returns: True if prime, False otherwise

  ishuiwenshu
  Checks if a number is a palindrome.

  ```python
  def ishuiwenshu(d: int) -> bool
  ```

  d: Number to check
  Returns: True if palindrome, False otherwise

  ishuiwenzhishu
  Checks if a number is a palindromic prime.

  ```python
  def ishuiwenzhishu(d: int) -> bool
  ```

  d: Number to check
  Returns: True if palindromic prime, False otherwise

  fab
  Calculates the xth number in the Fibonacci sequence.

  ```python
  def fab(x: int) -> int
  ```

  x: Position in the Fibonacci sequence
  Returns: The xth Fibonacci number

  isfab
  Checks if a number is in the Fibonacci sequence.

  ```python
  def isfab(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if in Fibonacci sequence, False otherwise

  isfabparam
  Checks if a number is both in the Fibonacci sequence and prime.

  ```python
  def isfabparam(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if Fibonacci prime, False otherwise

  isfabhuiwenshu
  Checks if a number is both in the Fibonacci sequence and a palindrome.

  ```python
  def isfabhuiwenshu(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if Fibonacci palindrome, False otherwise

  isfabhuiwenzhishu
  Checks if a number is in the Fibonacci sequence, a palindrome, and prime.

  ```python
  def isfabhuiwenzhishu(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if Fibonacci palindromic prime, False otherwise

  isleapyear
  Checks if a year is a leap year.

  ```python
  def isleapyear(x) -> bool
  ```

  x: Year to check
  Returns: True if leap year, False otherwise

  tribonacci
  Calculates the xth number in the Tribonacci sequence.

  ```python
  def tribonacci(n: int) -> int
  ```

  n: Position in the Tribonacci sequence
  Returns: The nth Tribonacci number

  istribonacci
  Checks if a number is in the Tribonacci sequence.

  ```python
  def istribonacci(n: int) -> bool
  ```

  n: Number to check
  Returns: True if in Tribonacci sequence, False otherwise

  istribonaccihuiwenshu
  Checks if a number is both in the Tribonacci sequence and a palindrome.

  ```python
  def istribonaccihuiwenshu(n: int) -> bool
  ```

  n: Number to check
  Returns: True if Tribonacci palindrome, False otherwise

  istribonaccihuiwenshuparam
  Checks if a number is in the Tribonacci sequence, a palindrome, and prime.

  ```python
  def istribonaccihuiwenshuparam(n: int) -> bool
  ```

  n: Number to check
  Returns: True if Tribonacci palindromic prime, False otherwise

  istribonacciparam
  Checks if a number is both in the Tribonacci sequence and prime.

  ```python
  def istribonacciparam(n: int) -> bool
  ```

  n: Number to check
  Returns: True if Tribonacci prime, False otherwise

  iswanquanpingfangshu
  Checks if a number is a perfect square.

  ```python
  def iswanquanpingfangshu(num: int) -> bool
  ```

  num: Number to check
  Returns: True if perfect square, False otherwise

  wanquanpingfangshu
  Calculates the dth perfect square.

  ```python
  def wanquanpingfangshu(num: int) -> int
  ```

  num: Position of the perfect square
  Returns: The dth perfect square

  isfabwanquanpingfangshu
  Checks if a number is both in the Fibonacci sequence and a perfect square.

  ```python
  def isfabwanquanpingfangshu(num: int) -> bool
  ```

  num: Number to check
  Returns: True if Fibonacci perfect square, False otherwise

  istribonacciwanquanpingfangshu
  Checks if a number is both in the Tribonacci sequence and a perfect square.

  ```python
  def istribonacciwanquanpingfangshu(num: int) -> bool
  ```

  num: Number to check
  Returns: True if Tribonacci perfect square, False otherwise

  jinzhizhuanhuan
  Converts numbers between different bases.

  ```python
  def jinzhizhuanhuan(a: int, b: int, c: str) -> str
  ```

  a: Base of input number (2 <= a <= 36)
  b: Base of output number (2 <= b <= 36)
  c: Number to convert (without prefix, must follow rules of base a)
  Returns: Converted number as a string

  factorization
  Performs prime factorization of a number.

  ```python
  def factorization(num: int) -> list[int]
  ```

  num: Number to factorize
  Returns: List of prime factors

  mima
  Extracts a password from a number.

  ```python
  def mima(num: int, n: int) -> int
  ```

  num: Number to extract password from
  n: Number of digits in the password
  Returns: Extracted password

  xiaoorfen
  Converts between decimal and fraction representations.

  ```python
  def xiaoorfen(num: str, mode: int) -> str
  ```

  num: Number to convert
  mode: 1 (decimal to fraction) or 2 (fraction to decimal)
  Returns: Converted number as a string

  xiaoorzhengjisuan
  Performs arithmetic operations on decimals or integers.

  ```python
  def xiaoorzhengjisuan(num1: float, num2: float, mode: str) -> float
  ```

  num1: First operand
  num2: Second operand
  mode: Operation (+, -, *, or ** for exponentiation)
  Returns: Result of the operation

  fenjisuan
  Performs arithmetic operations on fractions.

  ```python
  def fenjisuan(num1: str, num2: str, mode: str) -> float
  ```

  num1: First fraction
  num2: Second fraction
  mode: Operation (+, -, *, or ** for exponentiation)
  Returns: Result of the operation as a fraction

  bmi
  Calculates BMI (Body Mass Index).

  ```python
  def bmi(weight: int, height: int) -> float
  ```

  weight: Weight in kg
  height: Height in meters
  Returns: BMI inde





  def quzheng(num: float, mode: int) -> int:

  Function to round numbers.

  Parameters:
  num: The number to be rounded (float)
  mode: Rounding mode (1 for floor, 2 for ceiling)
  Returns: The rounded number
  Raises: ValueError if mode is not 1 or 2



  def daorxiao(args: str, mode: int) -> str:

  Function to convert case of characters.

  Parameters:
  args: The string to be converted
  mode: Conversion mode (1 for uppercase to lowercase, 2 for lowercase to uppercase)
  Returns: The converted string
  Raises: TypeError if mode is invalid



  def twonumbers_TheBiggestCommonfactor(num1: int, num2: int) -> int:

  Function to find the greatest common factor of two numbers.

  Parameters:
  num1: The first number
  num2: The second number
  Returns: The greatest common factor of num1 and num2



  def twonumbers_TheMinimumCommonmultiple(num1: int, num2: int) -> int:

  Function to find the least common multiple of two numbers.

  Parameters:
  num1: The first number
  num2: The second number
  Returns: The least common multiple of num1 and num2



  def chouqusuiji(num1: int, num2: int, mode: int, weishu: int) -> str:

  Function to generate random values.

  Parameters:
  num1: The minimum value in the random number range
  num2: The maximum value in the random number range
  mode: 1 for random number, 2 for random string, 3 for random color code (#......)
  weishu: The number of characters in the random string
  Returns: The generated random value as a string



  def kaisamima(arg: str, mode: int, n: int) -> str:

  Function to encrypt or decrypt using Caesar cipher.

  Parameters:
  arg: The string to be encrypted or decrypted
  mode: 1 for encryption, 2 for decryption
  n: The shift value
  Returns: The encrypted or decrypted string
  Raises: ValueError if arg contains non-alphabetic characters, TypeError if mode is invalid



  def f(a: float, n: int, m: int) -> int:

  Function to round numbers based on specific rules.

  Parameters:
  a: The float number to be rounded
  n: Lower bound for rounding
  m: Upper bound for rounding
  Returns: The rounded integer
  Raises: ValueError if the input doesn't meet the specified rules





  This function performs various mathematical calculations based on the specified mode.



  ```python
  def math_cal(mode:int,float1:float,float2:float)
  ```



  ```python
  s = math_cal(mode,float1,float2)
  ```



  mode (int): The calculation mode, ranging from 1 to 19. If the mode is outside this range, an exception will be raised.
  float1 (float): First float parameter.
  float2 (float): Second float parameter.



  The parameters float1 and float2 are used based on the selected mode.
  If a parameter is not needed for a particular mode, use 0 as a placeholder.



  Mode 3: math_cal(3, 5.2, 0)
  Mode 4: math_cal(4, 0, 0)
  Mode 1: math_cal(1, 5.92, -8)
  Return Value
  Returns the result of the calculation based on the selected mode.



  Copysign
  Cosine
  Degrees
  e (Euler's number)
  π (Pi)
  Tangent
  Square root
  Sine
  Radians
  Power
  Modf
  Logarithm
  Ldexp
  Not isnan
  Not isinf
  Factorial
  Absolute value
  Exp
  Exceptions
  Raises a TypeError if the mode is not within the valid range (1-19).



  Function: tuxing



  Performs geometric calculations for various shapes.



  This function performs various geometric calculations based on the specified shape and mode.

  ```python
  tuxing(huida, mode, *args2)
  ```



  huida: The shape to calculate (e.g., "长方体", "正方体", "正方形", etc.)
  mode: The calculation mode (e.g., "体积", "面积", "表面积", etc.)
  *args2: Additional arguments required for the calculation



  The result of the calculation, or:

  0: Successful calculation
  1: Invalid calculation mode
  2: Invalid shape





  体积 (Volume)
  表面积 (Surface Area)
  染色问题 (Coloring Problem)
  棱长总和 (Sum of Edge Lengths)
  容积 (Capacity)



  体积 (Volume)
  表面积 (Surface Area)
  染色问题 (Coloring Problem)
  棱长总和 (Sum of Edge Lengths)
  容积 (Capacity)



  面积 (Area)
  边长之和 (Sum of Side Lengths)
  折纸盒问题 (Paper Box Folding Problem)



  面积 (Area)
  周长 (Perimeter)
  折纸盒问题 (Paper Box Folding Problem)



  面积 (Area)
  周长 (Perimeter)
  折纸盒问题 (Paper Box Folding Problem)



  面积 (Area)
  周长 (Perimeter)



  面积 (Area)
  周长 (Perimeter)



  面积 (Area)
  周长 (Perimeter)



  面积 (Area)
  周长 (Perimeter)
  方中圆 (Circle in Square)
  圆中方 (Square in Circle)


pkgId: f72288b10e113e6f8a925ce6b90665dbdba598649af9bbb9c7e842859f565291
name: python-Allagash
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: A Python Spatial Optimization Library
url: https://apulverizer.github.io/allagash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Allagash-0.4.3-1.src.rpm
checksum_type: sha256
description:
  To install with geopandas run:
  `conda install -c conda-forge allagash geopandas`
  To install with arcgis run:
  `conda install -c conda-forge -c esri allagash arcgis`
  To install without a spatial library run:


pkgId: 63c01aeee07349a815761f5548d60ed4d201c929f595d06e5149746d25512608
name: python-AllanTools
arch: src
version: 2024.6
epoch: 0
release: 1
summary: A python library for calculating Allan deviation and related time & frequency statistics
url: https://github.com/aewallin/allantools
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AllanTools-2024.6-1.src.rpm
checksum_type: sha256
description:
  A python library for calculating Allan deviation and related
  time & frequency statistics. `LGPL v3+ license <https://www.gnu.org/licenses/lgpl.html>`_.
  * Development at https://github.com/aewallin/allantools
  * Installation package at https://pypi.python.org/pypi/AllanTools
  * Discussion group at https://groups.google.com/d/forum/allantools
  * Documentation available at https://allantools.readthedocs.org
  Input data should be evenly spaced observations of either fractional frequency,

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.   This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.  0. Additional Definitions.  As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License.  "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.  An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.  A "Combined Work" is a work produced by combining or linking an Application with the Library.  The particular version of the Library with which the Combined Work was made is also called the "Linked Version".  The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.  The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.  1. Exception to Section 3 of the GNU GPL.  You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.  2. Conveying Modified Versions.  If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:  a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or  b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.  3. Object Code Incorporating Material from Library Header Files.  The object code form of an Application may incorporate material from a header file that is part of the Library.  You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:  a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the object code with a copy of the GNU GPL and this license document.  4. Combined Works.  You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:  a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.  b) Accompany the Combined Work with a copy of the GNU GPL and this license document.  c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.  d) Do one of the following:  0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.  1) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.  e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)  5. Combined Libraries.  You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.  b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  6. Revised Versions of the GNU Lesser General Public License.  The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.  If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.


pkgId: 9ed114f2ad355163839f1a0a36455e0e26af25de4c7e05bdb1fd0b70ea1d2934
name: python-AlleleFinder
arch: src
version: 0.4.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/OLC-Bioinformatics/AlleleFinder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlleleFinder-0.4.7-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/OLC-Bioinformatics/AlleleFinder/tree/main.svg?style=shield)](https://circleci.com/gh/OLC-LOC-Bioinformatics/AlleleFinder/tree/main)
  [![codecov](https://codecov.io/gh/OLC-Bioinformatics/AlleleFinder/branch/main/graph/badge.svg?token=Z6SSEJV9GU)](https://codecov.io/gh/OLC-Bioinformatics/AlleleFinder)
  [![Anaconda-Server Badge](https://img.shields.io/badge/install%20with-conda-brightgreen)](https://anaconda.org/olcbioinformatics/allelefinder)
  [![GitHub Release](https://img.shields.io/github/v/release/OLC-Bioinformatics/AlleleFinder?display_name=release&label=version&color=%20dark%20green
  )](https://github.com/OLC-Bioinformatics/AlleleFinder/releases)
  [![GitHub issues](https://img.shields.io/github/issues/OLC-Bioinformatics/AlleleFinder)](https://github.com/OLC-LOC-Bioinformatics/AlleleFinder/issues)
  [![Documentation Status](https://readthedocs.org/projects/pip/badge/?version=stable)](https://OLC-Bioinformatics.github.io/AlleleFinder/?badge=stable)
  [![license](https://img.shields.io/badge/license-MIT-brightgreen)](https://github.com/OLC-Bioinformatics/AlleleFinder/blob/main/LICENSE)



  AlleleFinder is a Python-based suite of tools designed for the discovery, sequence typing, and profiling of _stx_ alleles in Shiga toxin-producing _Escherichia coli_ (STEC). It provides a comprehensive solution for researchers and professionals working in the field of bacterial genomics.



  AlleleFinder offers seven main functionalities, each represented by a separate script:

  1. [`profile_reduce`](https://olc-bioinformatics.github.io/AlleleFinder/profile_reduce): Reduces full wgMLST profile from Enterobase using genes of interest.
  2. [`allele_translate_reduce`](https://olc-bioinformatics.github.io/AlleleFinder/allele_translate_reduce): Translates allele files from Enterobase in nucleotide format to amino acid, performs content and length checks, and removes duplicates.
  3. [`allele_find`](https://olc-bioinformatics.github.io/AlleleFinder/allele_find): Performs BLAST analyses on a nucleotide allele database against nucleotide query sequences to discover their sequence types.
  4. [`allele_translate_find`](https://olc-bioinformatics.github.io/AlleleFinder/allele_translate_find): Performs BLAST analyses on an amino acid database against amino acid query sequences to find matching alleles.
  5. [`aa_allele_find`](https://olc-bioinformatics.github.io/AlleleFinder/aa_allele_find): Performs BLAST analyses on an amino acid database against amino acid query sequences to find matching alleles.
  6. [`allele_split`](https://olc-bioinformatics.github.io/AlleleFinder/allele_split): Splits a single allele database file into multiple files; one sequence per file.
  7. [`allele_concatenate`](https://olc-bioinformatics.github.io/AlleleFinder/allele_concatenate): Concatenates alleles of the _stx_ A and B subunits into a single sequence with a linker.



  Detailed documentation for each script and general usage of AlleleFinder is available at the [AlleleFinder GitHub pages site](https://olc-bioinformatics.github.io/AlleleFinder/).



  [`Conda`](https://docs.conda.io/en/latest/) is required to install AlleleFinder. See the [documentation](http://bioconda.github.io/) or [AlleleFinder installation](https://olc-bioinformatics.github.io/AlleleFinder/install/) for instructions on getting conda installed on your system.

  Create a new conda environment:

  ```bash
  conda create -n allele_finder -c olcbioinformatics allelefinder
  ```

  Additional installation instructions are available [here](https://olc-bioinformatics.github.io/AlleleFinder/installation).



  Each script has specific input requirements and usage instructions. Please refer to the respective documentation for each script for detailed information:

  - [`profile_reduce`](https://olc-bioinformatics.github.io/AlleleFinder/profile_reduce)
  - [`allele_translate_reduce`](https://olc-bioinformatics.github.io/AlleleFinder/allele_translate_reduce)
  - [`allele_find`](https://olc-bioinformatics.github.io/AlleleFinder/allele_find)
  - [`allele_translate_find`](https://olc-bioinformatics.github.io/AlleleFinder/allele_translate_find)
  - [`aa_allele_find`](https://olc-bioinformatics.github.io/AlleleFinder/aa_allele_find)
  - [`allele_split`](https://olc-bioinformatics.github.io/AlleleFinder/allele_split)
  - [`allele_concatenate`](https://olc-bioinformatics.github.io/AlleleFinder/allele_concatenate)



  We welcome your feedback. If you encounter any issues installing or running AlleleFinder, have feature requests, or need assistance, please [open an issue on GitHub](https://github.com/OLC-Bioinformatics/AlleleFinder/issues/new/choose).



  AlleleFinder is licensed under the MIT License. See the [LICENSE](https://github.com/OLC-Bioinformatics/AlleleFinder/blob/main/LICENSE) file for more details.


pkgId: 7989fd81d4532199c0fa036ef9820394b1af36ab9b75e856ff1523a8a55cd2c7
name: python-Allinoneincluding
arch: src
version: 4.1.5
epoch: 0
release: 1
summary: 多功能一体机（All-in-one）
url: https://github.com/lichenyichay/All-in-one-Including/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Allinoneincluding-4.1.5-1.src.rpm
checksum_type: sha256
description:
  Line 9 中文版README

  Line 392 Readme in English





  注：导入时请使用

  ```py
  from Allinoneincluding import *
  ```

  或

  ```py
  import Allinoneincluding as aioi #你没有安装aioi时
  ```

  且本项目与All-in-one-chay库功能相同，由于库文件配置问题，导致源库无法正常使用，请下载本库，谢谢！

  多功能一体机库版本，现已更新至4.1.0版本
  说明如下：





  Line 56 Allinone.py 主文件

  Line 86 shujuku.py 数据库文件

  Line 110 xiaogongju.py 模块文件

  Line 144 calculator.py 计算器模块

  Line 221 numbertochinese.py 数字、中文互换模块

  Line 253 lotterytickets.py 彩票一体机模块

  Line 276 erfenchazhao_py.py 二分查找模块

  Line 298 marh_cal.py math库计算器模块

  Line 320 student_py.py 小学学生信息管理系统模块

  Line 340 tuxing_cal.py 图形计算器模块

  Line 364 inequalitychay.py 不等式计算模块



  ```python

  Help on module Allinone:

  NAME
      Allinone

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS
      allinone(fuwu, mode, *args)
          :param fuwu 需要服务的功能
          :param mode 部分功能需要的模式（详见Github中All-in-one2.4.0分支的Wiki页）
          :param *args 可变参数，表示需要传入的参数，建议用元组或列表类型，具体所需类型见README.MD
          :return: 0：正常，1：不正常，其他返回值表示功能的结果

          功能（按代码顺序排序，不分先后）：大小写互换、抽取随机数、求最小公倍数、求最大公倍数、图形计算器、小学学生信息管理系统、二分查找、求余、向下取整、向上取整、多个数求和、多个数求差、多个数求积、判断闰年、判断是否为质数、整数、小数计算（加减乘除）、分数计算（加减乘除）......（具体见Github All-in-one2.4.0分支Readme.md文件）

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\allinone.py
  ```



  ```python
  Help on module shujuku:

  NAME
      shujuku

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS

      sjc(fuwu: str, mode: int, canshu: str)

  FILE
      d:\chay\project\all-in-one-including(git)\all-in-one_chaylichenyi\module\shujuku.py
  ```



  ```python
  Help on module xiaogongju:

  NAME
      xiaogongju

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      chouqusuiji(num1: int, num2: int, mode: int, weishu: int) -> str

      daorxiao(args: str, mode: int) -> str

      f(a: float, n: int, m: int) -> int

      kaisamima(arg: str, mode: int, n: int) -> str

      quzheng(num: float, mode: int) -> int

      twonumbers_TheBiggestCommonfactor(num1: int, num2: int) -> int

      twonumbers_TheMinimumCommonmultiple(num1: int, num2: int) -> int

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\xiaogongju.py
  ```



  ```python
  Help on module calculator:

  NAME
      calculator

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      FtemporCtemp(mode: str, FtemporCtemp: float) -> float

      duihuan(mode: int, money: float) -> float

      fab(x: int) -> int

      factorization(num: int) -> list[int]

      fanzhuanzifuchuan(s: str) -> str

      fenjisuan(num1: str, num2: str, mode: str) -> float

      isfab(x: int) -> bool

      isfabhuiwenshu(x: int) -> bool

      isfabhuiwenzhishu(x: int) -> bool

      isfabparam(x: int) -> bool

      isfabwanquanpingfangshu(num: int) -> bool

      ishuiwenshu(d: int) -> bool

      ishuiwenzhishu(d: int) -> bool

      isleapyear(x) -> bool

      isparam(d: int) -> bool

      istribonacci(n: int) -> bool

      istribonaccihuiwenshu(n: int) -> bool

      istribonaccihuiwenshuparam(n: int) -> bool

      istribonacciparam(n: int) -> bool

      istribonacciwanquanpingfangshu(num: int) -> bool

      iswanquanpingfangshu(num: int) -> bool

      jinzhizhuanhuan(a: int, b: int, c: str) -> str

      mima(num: int, n: int) -> int

      tribonacci(n: int) -> int

      wanquanpingfangshu(num: int) -> int

      xiaoorfen(num: str, mode: int) -> str

      xiaoorzhengjisuan(num1: float, num2: float, mode: str) -> float

      yiyuannci(fangcheng: str, mode: int) -> tuple

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\calculator.py

  ```



  ```python
  Help on module numbertochinese:

  NAME
      numbertochinese

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS
      No2Cn(number: int) -> str

      chinese2digits(uchars_chinese: str) -> int

      maxdigit(number: int, count: int) -> tuple

  DATA
      common_used_numerals = {'零': 0, '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '日': 7, '八': 8, '九': 9, '十': 10, '百': 100, '千': 1000, '万': 10000, '亿': 100000000}
      digitdict = {1: '十', 2: '百', 3: '千', 4: '万'}
      numdict = {1:"一",2:"二",3:"三",4:"四",5:"五",6:"六",7:"七",8:"八",9:"九",0:"零"}

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\numbertochinese.py
  ```



  ```python
  Help on module lotterytickets:

  NAME
      lotterytickets

  DESCRIPTION
      
      
      
      
      
      

  FUNCTIONS
      lotterytickets(user: str, mubiao: str, mode: int) -> str

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\lotterytickets.py
  ```



  ```python
  Help on module erfenchazhao_py:

  NAME
      erfenchazhao_py

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      erfenchazhao(yuanlst, shengxulst, target)

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\erfenchazhao_py.py
  ```



  ```python
  Help on module math_cal_py:

  NAME
      math_cal_py

  DESCRIPTION
      
      
      
      
      

  FUNCTIONS
      math_cal(mode, float1, float2)

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\math_cal_py.py
  ```



  ```python
  Help on module student_py:

  NAME
      student_py

  DESCRIPTION
      函数名：student
      调用形式：student()
      作用：小学学生信息管理系统

  FUNCTIONS
      student()

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\student_py.py
  ```



  ```python
  Help on module tuxing_cal:

  NAME
      tuxing_cal

  DESCRIPTION
      函数名：tuxing
      调用形式：tuxing(huida)
      :param huida 图形
      :return 0
      作用：进行图形计算

  FUNCTIONS
      tuxing(huida, mode, *args2)

  FILE
      d:\chay\project\all-in-one\src\all-in-one_chaylichenyi\module\tuxing_cal.py
  ```





  本代码提供了两个主要功能：suijiine 用于生成指定难度级别（即操作数数量）的随机不等式表达式，solveine 用于解线性不等式表达式并返回解集。



  功能：根据给定的难度级别（dif），生成一个随机的不等式表达式。
  参数：
  dif (int): 不等式表达式的难度级别，决定了操作数的数量。
  返回值：
  str: 随机生成的不等式表达式字符串。



  功能：解给定的线性不等式表达式，并返回解集。
  参数：
  s (str): 作为字符串的线性不等式表达式。
  返回值：
  str: 不等式的解集。



  在解不等式时，假设输入的不等式是线性且只有一个未知数 x。
  如果 a（不等式左侧 x 的系数）为0，则根据 b 的值返回“所有实数”或“无解”。
  使用 fractions.Fraction 来处理分数，确保解集以分数的形式返回，如果可能的话。

  详见<https://github.com/lichenyichay/All-in-one> 和 <https://github.com/lichenyichay/All-in-one-Including/wiki>





  Using the Allinoneincluding library, you can use

  ```py
  from Allinoneincluding import *
  ```

  or

  ```py
  import Allinoneincluding as aioi #When you didn't install aioi library
  ```

  codes.

  This project has the same functionality as the All-in-one-chay library. However,due to configuration issues with the library files, the original library cannot be used normally. Please download the Allinoneincluding library. Thank you!



  Line 426 Allinone Main Module Documentation

  Line 432 Calculator Module Documentation

  Line 735 Xiaogongju Module Documentation

  Line 822 Math_calculator Module Documentation

  Line 882 Tuxing_calculator Module Documentation

  Line 970 Inequalitychay Moudle Documentation



  Allinone.py
  Main module for the Allinone Function.
  mode:depending on your choice, you can choose the function you want to use.(such as you choose Ftemp or Ctemp you should incoming mode param in "℃to℉" or "℉to℃")



  FtemporCtemp
  Converts temperature between Fahrenheit and Celsius.

  ```python
  def FtemporCtemp(mode: str, FtemporCtemp: float) -> float
  ```

  mode: "℃to℉" (Celsius to Fahrenheit) or "℉to℃" (Fahrenheit to Celsius)
  FtemporCtemp: Temperature to convert
  Returns: Converted temperature (without unit)

  duihuan
  Performs currency exchange.

  ```python
  def duihuan(mode: int, money: float) -> float
  ```

  mode: 1-16, corresponding to different currency conversions
  money: Amount to exchange (in the currency unit before the arrow in the mode)
  Returns: Converted currency amount

  yiyuannci
  Solves linear, quadratic, and cubic equations.

  ```python
  def yiyuannci(fangcheng: str, mode: int) -> tuple
  ```

  fangcheng: Equation in the form ax+b=0, ax^2+bx+c=0, or ax^3+bx^2+cx+d=0
  mode: Highest degree of the equation (1, 2, or 3)
  Returns: Tuple containing the solution(s) of the equation

  fanzhuanzifuchuan
  Reverses a string.

  ```python
  def fanzhuanzifuchuan(s: str) -> str
  ```

  s: String to reverse
  Returns: Reversed string
  isparam
  Checks if a number is prime.

  ```python
  def isparam(d: int) -> bool
  ```

  d: Number to check
  Returns: True if prime, False otherwise

  ishuiwenshu
  Checks if a number is a palindrome.

  ```python
  def ishuiwenshu(d: int) -> bool
  ```

  d: Number to check
  Returns: True if palindrome, False otherwise

  ishuiwenzhishu
  Checks if a number is a palindromic prime.

  ```python
  def ishuiwenzhishu(d: int) -> bool
  ```

  d: Number to check
  Returns: True if palindromic prime, False otherwise

  fab
  Calculates the xth number in the Fibonacci sequence.

  ```python
  def fab(x: int) -> int
  ```

  x: Position in the Fibonacci sequence
  Returns: The xth Fibonacci number

  isfab
  Checks if a number is in the Fibonacci sequence.

  ```python
  def isfab(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if in Fibonacci sequence, False otherwise

  isfabparam
  Checks if a number is both in the Fibonacci sequence and prime.

  ```python
  def isfabparam(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if Fibonacci prime, False otherwise

  isfabhuiwenshu
  Checks if a number is both in the Fibonacci sequence and a palindrome.

  ```python
  def isfabhuiwenshu(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if Fibonacci palindrome, False otherwise

  isfabhuiwenzhishu
  Checks if a number is in the Fibonacci sequence, a palindrome, and prime.

  ```python
  def isfabhuiwenzhishu(x: int) -> bool
  ```

  x: Number to check (0 < x <= 12586269025)
  Returns: True if Fibonacci palindromic prime, False otherwise

  isleapyear
  Checks if a year is a leap year.

  ```python
  def isleapyear(x) -> bool
  ```

  x: Year to check
  Returns: True if leap year, False otherwise

  tribonacci
  Calculates the xth number in the Tribonacci sequence.

  ```python
  def tribonacci(n: int) -> int
  ```

  n: Position in the Tribonacci sequence
  Returns: The nth Tribonacci number

  istribonacci
  Checks if a number is in the Tribonacci sequence.

  ```python
  def istribonacci(n: int) -> bool
  ```

  n: Number to check
  Returns: True if in Tribonacci sequence, False otherwise

  istribonaccihuiwenshu
  Checks if a number is both in the Tribonacci sequence and a palindrome.

  ```python
  def istribonaccihuiwenshu(n: int) -> bool
  ```

  n: Number to check
  Returns: True if Tribonacci palindrome, False otherwise

  istribonaccihuiwenshuparam
  Checks if a number is in the Tribonacci sequence, a palindrome, and prime.

  ```python
  def istribonaccihuiwenshuparam(n: int) -> bool
  ```

  n: Number to check
  Returns: True if Tribonacci palindromic prime, False otherwise

  istribonacciparam
  Checks if a number is both in the Tribonacci sequence and prime.

  ```python
  def istribonacciparam(n: int) -> bool
  ```

  n: Number to check
  Returns: True if Tribonacci prime, False otherwise

  iswanquanpingfangshu
  Checks if a number is a perfect square.

  ```python
  def iswanquanpingfangshu(num: int) -> bool
  ```

  num: Number to check
  Returns: True if perfect square, False otherwise

  wanquanpingfangshu
  Calculates the dth perfect square.

  ```python
  def wanquanpingfangshu(num: int) -> int
  ```

  num: Position of the perfect square
  Returns: The dth perfect square

  isfabwanquanpingfangshu
  Checks if a number is both in the Fibonacci sequence and a perfect square.

  ```python
  def isfabwanquanpingfangshu(num: int) -> bool
  ```

  num: Number to check
  Returns: True if Fibonacci perfect square, False otherwise

  istribonacciwanquanpingfangshu
  Checks if a number is both in the Tribonacci sequence and a perfect square.

  ```python
  def istribonacciwanquanpingfangshu(num: int) -> bool
  ```

  num: Number to check
  Returns: True if Tribonacci perfect square, False otherwise

  jinzhizhuanhuan
  Converts numbers between different bases.

  ```python
  def jinzhizhuanhuan(a: int, b: int, c: str) -> str
  ```

  a: Base of input number (2 <= a <= 36)
  b: Base of output number (2 <= b <= 36)
  c: Number to convert (without prefix, must follow rules of base a)
  Returns: Converted number as a string

  factorization
  Performs prime factorization of a number.

  ```python
  def factorization(num: int) -> list[int]
  ```

  num: Number to factorize
  Returns: List of prime factors

  mima
  Extracts a password from a number.

  ```python
  def mima(num: int, n: int) -> int
  ```

  num: Number to extract password from
  n: Number of digits in the password
  Returns: Extracted password

  xiaoorfen
  Converts between decimal and fraction representations.

  ```python
  def xiaoorfen(num: str, mode: int) -> str
  ```

  num: Number to convert
  mode: 1 (decimal to fraction) or 2 (fraction to decimal)
  Returns: Converted number as a string

  xiaoorzhengjisuan
  Performs arithmetic operations on decimals or integers.

  ```python
  def xiaoorzhengjisuan(num1: float, num2: float, mode: str) -> float
  ```

  num1: First operand
  num2: Second operand
  mode: Operation (+, -, *, or ** for exponentiation)
  Returns: Result of the operation

  fenjisuan
  Performs arithmetic operations on fractions.

  ```python
  def fenjisuan(num1: str, num2: str, mode: str) -> float
  ```

  num1: First fraction
  num2: Second fraction
  mode: Operation (+, -, *, or ** for exponentiation)
  Returns: Result of the operation as a fraction

  bmi
  Calculates BMI (Body Mass Index).

  ```python
  def bmi(weight: int, height: int) -> float
  ```

  weight: Weight in kg
  height: Height in meters
  Returns: BMI inde





  def quzheng(num: float, mode: int) -> int:

  Function to round numbers.

  Parameters:
  num: The number to be rounded (float)
  mode: Rounding mode (1 for floor, 2 for ceiling)
  Returns: The rounded number
  Raises: ValueError if mode is not 1 or 2



  def daorxiao(args: str, mode: int) -> str:

  Function to convert case of characters.

  Parameters:
  args: The string to be converted
  mode: Conversion mode (1 for uppercase to lowercase, 2 for lowercase to uppercase)
  Returns: The converted string
  Raises: TypeError if mode is invalid



  def twonumbers_TheBiggestCommonfactor(num1: int, num2: int) -> int:

  Function to find the greatest common factor of two numbers.

  Parameters:
  num1: The first number
  num2: The second number
  Returns: The greatest common factor of num1 and num2



  def twonumbers_TheMinimumCommonmultiple(num1: int, num2: int) -> int:

  Function to find the least common multiple of two numbers.

  Parameters:
  num1: The first number
  num2: The second number
  Returns: The least common multiple of num1 and num2



  def chouqusuiji(num1: int, num2: int, mode: int, weishu: int) -> str:

  Function to generate random values.

  Parameters:
  num1: The minimum value in the random number range
  num2: The maximum value in the random number range
  mode: 1 for random number, 2 for random string, 3 for random color code (#......)
  weishu: The number of characters in the random string
  Returns: The generated random value as a string



  def kaisamima(arg: str, mode: int, n: int) -> str:

  Function to encrypt or decrypt using Caesar cipher.

  Parameters:
  arg: The string to be encrypted or decrypted
  mode: 1 for encryption, 2 for decryption
  n: The shift value
  Returns: The encrypted or decrypted string
  Raises: ValueError if arg contains non-alphabetic characters, TypeError if mode is invalid



  def f(a: float, n: int, m: int) -> int:

  Function to round numbers based on specific rules.

  Parameters:
  a: The float number to be rounded
  n: Lower bound for rounding
  m: Upper bound for rounding
  Returns: The rounded integer
  Raises: ValueError if the input doesn't meet the specified rules





  This function performs various mathematical calculations based on the specified mode.



  ```python
  def math_cal(mode:int,float1:float,float2:float)
  ```



  ```python
  s = math_cal(mode,float1,float2)
  ```



  mode (int): The calculation mode, ranging from 1 to 19. If the mode is outside this range, an exception will be raised.
  float1 (float): First float parameter.
  float2 (float): Second float parameter.



  The parameters float1 and float2 are used based on the selected mode.
  If a parameter is not needed for a particular mode, use 0 as a placeholder.



  Mode 3: math_cal(3, 5.2, 0)
  Mode 4: math_cal(4, 0, 0)
  Mode 1: math_cal(1, 5.92, -8)
  Return Value
  Returns the result of the calculation based on the selected mode.



  Copysign
  Cosine
  Degrees
  e (Euler's number)
  π (Pi)
  Tangent
  Square root
  Sine
  Radians
  Power
  Modf
  Logarithm
  Ldexp
  Not isnan
  Not isinf
  Factorial
  Absolute value
  Exp
  Exceptions
  Raises a TypeError if the mode is not within the valid range (1-19).



  Function: tuxing



  Performs geometric calculations for various shapes.



  This function performs various geometric calculations based on the specified shape and mode.

  ```python
  tuxing(huida, mode, *args2)
  ```



  huida: The shape to calculate (e.g., "长方体", "正方体", "正方形", etc.)
  mode: The calculation mode (e.g., "体积", "面积", "表面积", etc.)
  *args2: Additional arguments required for the calculation



  The result of the calculation, or:

  0: Successful calculation
  1: Invalid calculation mode
  2: Invalid shape





  体积 (Volume)
  表面积 (Surface Area)
  染色问题 (Coloring Problem)
  棱长总和 (Sum of Edge Lengths)
  容积 (Capacity)



  体积 (Volume)
  表面积 (Surface Area)
  染色问题 (Coloring Problem)
  棱长总和 (Sum of Edge Lengths)
  容积 (Capacity)



  面积 (Area)
  边长之和 (Sum of Side Lengths)
  折纸盒问题 (Paper Box Folding Problem)



  面积 (Area)
  周长 (Perimeter)
  折纸盒问题 (Paper Box Folding Problem)



  面积 (Area)
  周长 (Perimeter)
  折纸盒问题 (Paper Box Folding Problem)



  面积 (Area)
  周长 (Perimeter)



  面积 (Area)
  周长 (Perimeter)



  面积 (Area)
  周长 (Perimeter)



  面积 (Area)
  周长 (Perimeter)
  方中圆 (Circle in Square)
  圆中方 (Square in Circle)





  This code provides two main functionalities: suijiine for generating random inequality expressions based on a specified level of difficulty (i.e., the number of operations), and solveine for solving linear inequality expressions and returning the solution set.



  Functionality: Generates a random inequality expression based on the given difficulty level (dif).
  Parameters:
  dif (int): The difficulty level of the inequality expression, which determines the number of operations.
  Returns:
  str: A randomly generated inequality expression string.



  Functionality: Solves a given linear inequality expression and returns the solution set.
  Parameters:
  s (str): The linear inequality expression as a string.
  Returns:
  str: The solution set of the inequality expression.



  It assumes the input inequality is linear and has only one unknown x.
  If a (the coefficient of x on the left side of the inequality) is 0, it returns "All real numbers" or "No solution" depending on the value of b.
  Uses fractions.Fraction to handle fractions, ensuring that the solution set is returned in fractional form if possible.


pkgId: dcb7e95c059735853daa2bca83ae70eca49705d788162d85e936bb3533812e2d
name: python-AllyInvestPy
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: A blackbox Ally Invest/TradeKing API interface for application developers.
url: https://github.com/anthonymorast/AllyInvest.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AllyInvestPy-1.0.16-1.src.rpm
checksum_type: sha256
description:
  A blackbox Ally Invest/TradeKing API interface for application developers.

  AllyInvest.py is a part of the PyPi repository and can be installed via

  ```
    pip install AllyInvestPy
  ```

  AllyAPI.py
  A Python3 class that allows access to all of the functionality in the
  Ally/TradeKing API.

  This package attempts to stay on top of changes to the API and allow an
  easy to user interface with the Ally Invest API. The API does no formatting
  for the user. A response format of 'xml' or 'json' can be specified and
  the API responses will be returned as the raw XML or JSON, respectively.

  This API was built with the developer in mind and should allow a developer
  to build applications around the Ally Invest API without having to deal with
  accessing and managing the requests and responses.



  Doxygen was used to generate documentation for this interface. The generated
  documentation can be found [here](http://www.anthonymorast.com/allyinvestapi/).

  Perhaps the most useful documentation is of the [AllyAPI class](http://www.anthonymorast.com/allyinvestapi/classally_1_1_ally_a_p_i.html)
  as this documentation shows which functionality is available and describes how to
  use each function.



  Details coming soon. Some basic usage can be found in example.py until then.


  + Documentation
    + URLs.py and examples.py
  + Implement missing functionality
    + Right now, the API implements many of the calls listed on [Ally's documentation page](https://www.ally.com/api/invest/documentation/)
      but there are many not yet implemented (due to time constraints). Below is a list.
    + Adding the functionality is pretty straight forward, some more details are below.
  + Test
    + Everything
    + Add unit tests



  To add a new API function the API URL has to be added to the URLs class in URLs.py.
  Note that the request endpoint is already stored in the class e.g.

  > https://api.tradeking.com/v1/

  Therefore, only anything after */v1/* needs to be added as a URL. A method to
  obtain the full URL must be implemented as well, examples abound in the URLs class.

  After the URL is added, implementing the POST or GET is very simple. There are two
  private methods in the *AllyAPI* class that allow easily retrieving data provided
  only the URL. these are *__get_data(self, url)* and *__to_format(self, response)*.

  To add the new functionality, just create a method call in the *AllyAPI* class that
  uses your new URL and returns/calls the *__get_date(...)* method. This will return the
  raw XML or JSON response from the user depending on the format set up when creating
  the *AllyAPI* class instance.


  + MARKET
      + GET market/options/search
      + GET market/options/strikes
      + GET market/options/expirations
      + GET market/timesales
  + WATCHLIST
      + GET watchlists
      + POST watchlists
      + GET watchlists/:id
      + DELETE watchlists/:id
      + POST watchlists/:id/symbols
      + DELETE watchlists/:id/symbols
  + STREAMING OPERATIONS
      + MARKET
          + GET market/quotes


pkgId: 63b62dbb849716b0f840566e195328c6cc35f8359a7cb42a922b6ec47f362b6e
name: python-AlphaDSSP
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Tool for converting Alphafold tar shards to a database of DSSP secondary structure information.
url: https://github.com/noelgarber/AlphaDSSP
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlphaDSSP-0.5.1-1.src.rpm
checksum_type: sha256
description:
   DSSP Analysis for Alphafold Secondary Structure Parsing

  This tool generates DSSP secondary structure information and allows masks to be generated that identify specific regions of a protein by secondary structure and confidence. It can be useful when searching for sequence motifs; for example, if you're searching sequences for a short linear motif that must exist in disordered strands (rather than, say, a helix or a beta-strand), you can use AlphaDSSP to make a boolean mask that shows you everywhere in the sequence that cannot contain your motif due to incompatible secondary structure.

  Alphafold provides data as tar shards for organisms by TaxID, which you can download by following the instructions at https://github.com/google-deepmind/alphafold/blob/main/afdb/README.md
  To use this tool, you must have a directory containing the tar shards for your organism of interest.



  1. Install this tool from PyPI by running the command `pip install alphadssp`
  2. Import the main function into your script as `from alphadssp import generate_dssp`
  3. Use the main function either with default arguments or your own: `excluded_results = generate_dssp(tar_dir = None, dssp_executable="/usr/bin/dssp", forbidden_codes = ("H","B","E","G","I","T"), plddt_thres=70)`

  `dssp_executable` is the path to your local installation of the DSSP program, which generally comes with BioPython
  `forbidden_codes` refers to a tuple of DSSP single-letter codes for secondary structures that you want to mask out. For example, if you want to find everything that isn't a disordered strand, this is a tuple of all other non-disordered secondary structure codes.
  `plddt_thres` is the pLDDT confidence threshold required for a predicted forbidden DSSP secondary structure to contribute to the mask of forbidden residues

  The output is a dictionary, `excluded_results`, where each key is a base file name (e.g. AF-A0A023HHL0-F1-model_v4). The dict value is a tuple of (mask, dssp_str), where `mask` is a boolean mask of forbidden areas of the sequence containing confidently disallowed secondary structures, and `dssp_str` is a string of DSSP letter codes corresponding to the protein sequence.


pkgId: b839a8aa6f4c90efb7edefd37f4ae62a3971a1780b9774215a888cc2e699acd4
name: python-AlphaZero-GameEnv
arch: src
version: 1.1.4.0
epoch: 0
release: 1
summary: alphazero_game_env
url: https://github.com/Michi-123/AlphaZeroGameEnv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlphaZero-GameEnv-1.1.4.0-1.src.rpm
checksum_type: sha256
description:
  ![image](https://github.com/Michi-123/AlphaZeroCode/assets/26673104/3b773129-74d2-4e11-bcab-d39f17c10980)
  https://www.udemy.com/course/alphazero/<br>
  AlphaZeroのためのゲーム環境です。セルフプレイでも使用します。<br>
  <h1>AlphaZeroの意外な構造</h1>
  <h2>またはAlphaGoは如何にして棋譜データの利用を止めて自分の経験に頼るようになったか</h2>
  囲碁AIのAlphaGoから、人の知識なしでゼロから学習に成功した強化学習モデル のゲームＡＩ「AlphaZero」 を、初心者・中級者向けに、イラストなどで解説していきます。AlphaZeroは、将棋ＡＩとしても成果を出しています。<br>

  <pre>
  pip install AlphaZero-GameEnv
  </pre>
  <pre>
  import alphazero_game_env
  </pre>


pkgId: 6ada24df2ba98cceea83422bc87c8f33d75e1792d9fb8e893ad05f0c569e64bd
name: python-AltTester-Driver
arch: src
version: 2.1.2
epoch: 0
release: 1
url: https://alttester.com/docs/sdk/latest/
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AltTester-Driver-2.1.2-1.src.rpm
checksum_type: sha256
summary:
  Python bindings for the AltTester® framework. AltTester® is an open-source UI driven test automation tool that helps you find objects in your game and interacts with them.

description:
  This package contains an library for adding Python language binding to the AltTester® framework.

  AltTester® Unity SDK is an open-source UI driven test automation tool that helps you find objects in your application and interacts with them using tests written in C#, Python, Java or Robot Framework.

  You can run your tests on real devices (mobile, PCs, etc.) or inside the Unity Editor.

  Read the documentation on https://alttester.com/docs/sdk/latest/



  Check out the [Get Started](https://alttester.com/docs/sdk/latest/pages/get-started.html) guide from the documentation.



  -   Code Style: [PEP-0008](https://www.python.org/dev/peps/pep-0008/)
  -   Docstring style: [Google Style Docstrings](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html).



  Run the following command to install the dev dependencies:

  ```
  $ pip install -r requirements-dev.txt
  ```



  ```
  $ pytest tests/unit/
  ```



  ```
  $ pytest tests/integration/
  ```



  Check out the full contributing guide [contributing](https://alttester.com/docs/sdk/latest/pages/contributing.html).



  Join our Google Group for questions and discussions: https://groups.google.com/a/altom.com/g/alttesterforum

  Join our Discord Server to chat with other members of the community: https://discord.gg/Ag9RSuS



  Distributed under the **GNU General Public License v3.0**. See [LICENSE](https://github.com/alttester/AltTester-Unity-SDK/blob/master/LICENSE) for more information.


pkgId: 08a925fb8aaa1e20d4cd04357c39b3f3eb896df924dc532ad258547fdde82c03
name: python-Alvaro
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Easy to use networking library.
url: https://github.com/edgecase963/Alvaro
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Alvaro-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Updates](https://pyup.io/repos/github/edgecase963/Alvaro/shield.svg)](https://pyup.io/repos/github/edgecase963/Alvaro/) [![Downloads](https://pepy.tech/badge/alvaro)](https://pepy.tech/project/alvaro) [![CodeFactor](https://www.codefactor.io/repository/github/edgecase963/alvaro/badge)](https://www.codefactor.io/repository/github/edgecase963/alvaro)
  ![Logo](readme_media/logo.png)
  Alvaro is a high-level, event-based networking module built to save you time on your projects without compromising on reliability, security or functionality.
  It offers SSL support, user management and many more features to help you on your projects.

  ![Alvaro Demo](demos/demo.gif)
  To learn more, check out [the wiki!](https://github.com/edgecase963/Alvaro/wiki)
  Never spend hours or even days writing complicated networking software just to get two devices to communicate again. All the difficult tasks of flow control, encryption and _endless_ bugs all taken care of for you! This project provides you the ability to create a fully functional server in just a few lines of code. So you can dive right into your project.
  After all, time is our most valuable resource.
  ```bash

  git clone https://github.com/edgecase963/Alvaro
  cd Alvaro


  pip3 install -r requirements.txt

  sudo python3 setup.py install
  ```
  Alternatively, you can also use the pip command to install Alvaro:
  ```bash
  pip3 install alvaro
  ```

  As of the creation of this README, installing the `requirements.txt` via pip is **not necessary**.
  The requirements file only contains `uvloop` which helps speed up Alvaro, but does not prevent it from working.
  Alvaro is designed to work out of the box with no extra installations or dependencies.
  This project is completely open source and anyone is free to use it.
  Alvaro comes with some built-in features to help make data transfer not just more reliable, but easier to manage and implement into your project. One of these is the ability to monitor an ongoing download.
  ![Download Demo](demos/download_demo.gif)
  Below is a demonstration of how to set up a minimalistic server using Alvaro:
  ```python
  import alvaro, asyncio
  server = alvaro.Host("127.0.0.1", port=8888)
  asyncio.run( server.start() )
  ```
  Alvaro uses asyncio to host/run/manage its servers. In order to start a server, it must be started with the `asyncio.run` function.
  If you're already using asynchronous software and want to run Alvaro in your program's main loop, simply use `await`
  ```python
  import alvaro, asyncio
  server = alvaro.Host("127.0.0.1", port=8888)
  async def start_server():
      await server.start()
  ```


pkgId: c53d1b26d8f7c3f3048845111b622dcb793577f5d99657c48a3d195b4a3144ae
name: python-AlveolEye
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Reads lung slides with AI-driven and classical methods
url: https://pypi.org/project/AlveolEye/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AlveolEye-0.1.2-1.src.rpm
checksum_type: sha256
description:
  1. ![#FF3333](https://placehold.co/15x15/FF3333/FF3333.png) **Toggle manual thresholding**: To manually set a threshold value, toggle manual threshold; otherwise, a threshold value will be determined with Otsu's method.
     a. To use manual thresholding, check the “Manual thresholding” box and proceed; to use automatic thresholding, leave the box unchecked and skip to step 2.
     b. Type a percentage and/or click the “-” and “+” buttons in the “Manual thresholding” input box to set the threshold level.
  2. ![#FF9933](https://placehold.co/15x15/FF9933/FF9933.png) **Remove small particles**: Type a percentage and/or click the “-” and “+” buttons in the “Remove small particles” input box to set the maximum size cutoff for particles to remove. Particles with fewer pixels than the set number will be removed.
  3. ![#FFFF33](https://placehold.co/15x15/FFFF33/FFFF33.png) **Remove small holes**: Type a percentage and/or click the “-” and “+” buttons in the “Remove small holes” input box to set the maximum size cutoff for holes to remove. Holes with fewer pixels than the set number will be removed.


pkgId: 1387bce0462a6ec896d3a4a2ce7bfb9dceb2ccd13dc9b693c7e2f3d922c18954
name: python-AmaProductReviews
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Analyze Amazon product reviews
url: https://pypi.org/project/AmaProductReviews/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AmaProductReviews-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This Python script aims to analyze Amazon product reviews by extracting reviews from a specific product's URL and performing sentiment analysis on those reviews.



  1. **get_url_review_page(UrlProduct, i)**:
     - Constructs the URL for a specific page of product reviews.

  2. **get_rating(UrlProduct)**:
     - Retrieves the overall rating of the product.

  3. **get_product_name(UrlProduct)**:
     - Extracts the name of the product from its URL.

  4. **get_global_rating(UrlProduct)**:
     - Fetches the global rating of the product.

  5. **get_image_url(UrlProduct)**:
     - Obtains the URL of the product's image.

  6. **extract_reviews(UrlProduct)**:
     - Extracts reviews from a specific page of product reviews.

  7. **extract_all_reviews(UrlProduct)**:
     - Extracts all reviews from multiple pages of product reviews.

  8. **clean_comment(comment)**:
     - Cleans the text of a comment by converting it to lowercase, removing non-alphabetic characters, digits, and stop words.

  9. **sentiment_analysis_textblob(text)**:
     - Performs sentiment analysis using TextBlob and returns the sentiment label (Positive, Negative, or Neutral).

  10. **comment_dataFrame(UrlProduct)**:
      - Constructs a DataFrame containing cleaned comments and their corresponding sentiments.

  11. **sentiment_by_comment(df)**:
      - Calculates the count of comments by sentiment.



  - Python 3.x
  - Packages listed in the `requirements.txt` file. Install them using `pip install -r requirements.txt`.
  - [en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl#sha256=86cc141f63942d4b2c5fcee06630fd6f904788d2f0ab005cce45aadb8fb73889](https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl#sha256=86cc141f63942d4b2c5fcee06630fd6f904788d2f0ab005cce45aadb8fb73889)
  - beautifulsoup4
  - selenium
  - pandas
  - nltk
  - spacy
  - textblob
  - streamlit
  - plotly
  - requests
  - wordcloud
  - webdriver_manager



  - El Ouankrimi Ali
  - Olamine Zakaria
  - Oubella Abdallah

  \x00
  \x00


pkgId: 1e44b80afac62985f018ec7c8549c06b7ddf0b8102dd763b96c2944e54c395c8
name: python-Ambit-Stochastics
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: A pacakge dedicated to the study of Ambit fields and Trawl processes
url: https://github.com/danleonte/Ambit_Stochastics
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Ambit-Stochastics-1.0.7-1.src.rpm
checksum_type: sha256
description:
  A repository dedicated to the study of Ambit fields and Trawl processes. The library can be downloaded from https://pypi.org/project/Ambit-Stochastics/.

  The `Trawl processes example usage` and `Simple ambit field example usage` jupyter notebooks in the git root folder explains the functionality of the library. The full documentation is available at https://danleonte.github.io/Ambit_Stochastics/index.html


pkgId: 71af18668f7ff427e160db495649880dbed6a88a0bf02b47e151e8a07bd7218c
name: python-Amino-new.py
arch: src
version: 5.0
epoch: 0
release: 1
summary: A library to create Amino bots.
url: https://github.com/aminobot22/MAmino.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Amino-new.py-5.0-1.src.rpm
checksum_type: sha256
description:
  [//]: # (**README Improved By ODYSS3EUS**)
  [//]: # (Never Underestimate Presentation)

  <h1 align="center">
    <br>
    <a href="https://github.com/aminobot22/MAmino.py"><img src="https://i.imgur.com/LLzB0nxt.png?size=512" alt="Amino_new.py" width="200"></a>
    <br>
    Amino_new
    <br>
  </h1>



  MAmino.py Is A Python API For Communicating With Amino Servers Whilst Pretending That You're An App User. This Is Mostly Accomplished By Spoofing Device Configuration Headers. It Is Also For Objectifying And Organizing Amino Response Data, So That Actually Doing Anything Is Easier.


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


  You'll Need Python 3 To Use This Library, I Recommend Using Python 3.6 Or Earlier.
  To Install It Just Open The Command Line And Type This Command `python3 -m pip install MAmino.py`
  - **NOTE:** MAKE SURE YOU TYPE `Amino_new` **NOT** `Amino` AS IT WILL INSTALL THE **WRONG** PACKAGE UNINSTALL Amino.py!


  0. Make Sure Pip Is Installed See: [How To Set-Up Pip](https://nitratine.net/blog/post/how-to-setup-pythons-pip/)
  1. Alternatively Download The API [HERE](https://github.com/Slimakoi/Amino.py/archive/refs/heads/master.zip)
  2. Extract The .zip File Either With [Winrar](https://www.win-rar.com/download.html?&L=0) or [7zip](https://www.7-zip.org/download.html)
  3. Open The Extracted Folder In An [IDE](https://visualstudio.microsoft.com/downloads/) Of Your Choosing
  And Navigate To The Folder Named `Amino_new-master`
  4. Select The Python Interpreter
  5. Make A New `*.py` File And Start Creating

  [//]: # (*Verbose Instructions For Those Who Want To Start Programming But Don't Know How.)


pkgId: 3b952240e794aa8500300c40ef204affdede3c005704e97d42b6e90d4ee79c55
name: python-Amino.ed
arch: src
version: 2.8.4.13
epoch: 0
release: 1
summary: A library to create Amino bots.
url: https://github.com/Alert-Aigul/Amino.ed
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Amino.ed-2.8.4.13-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install amino.ed
  ```


  ```py
  import aminoed

  @aminoed.run_with_client()
  async def main(client: aminoed.Client):
      await client.login("email", "password")

  ```


  ```py
  from aminoed import *

  bot = Client(prefix="!")

  @bot.execute() # Runs in the background, after bot.start()
  async def on_start():
      print(f"Bot {bot.auth.user.nickname} working.")

  @bot.command() # Comand name - function name
  async def help(event: Event):
      await event.send_message("[c]Comands\n" \
          "?chatmembers - members count.")

  @bot.command("chatmembers", "?") # Custom command and prefix
  async def chatmembers(event: Event):
      chat = await event.client.get_chat_thread(event.threadId)
      await event.send_message(f"Chat members count: {chat.membersCount}.")

  bot.start("email", "password")


  ```


pkgId: 6ea536ec8f082d39ce9a4c24d1fd876ab803332231337ab7b64dab064581a988
name: python-AmpliconSuiteAggregator
arch: src
version: 2
epoch: 0
release: 1
summary: Aggregator tool for multiple Amplicon Architect outputs
url: https://github.com/AmpliconSuite/AmpliconSuiteAggregator
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AmpliconSuiteAggregator-2-1.src.rpm
checksum_type: sha256
description:
  Aggregates the results from AmpliconSuite
    - Takes in zip files (completed results of individual or grouped Amplicon Suite runs)
    - Aggregates results
      - Packages results into a new file
      - Outputs an aggregated .html and .csv file of results.
    - Result file (in .tar.gz) is the aggregated results of all individual AmpliconSutie runs. It can be directly loaded onto AmpliconRepository.
    - Can also take additional files along with the upload, provided the directory they are in contains a file named `AUX_DIR`.


    - Available at: https://genepattern.ucsd.edu/gp/pages/index.jsf?lsid=urn:lsid:genepattern.org:module.analysis:00429:4.1
    - *Amplicon Architect Results* (required)
      - Compressed (.tar.gz, .zip) files of the results from individual or grouped Amplicon Architect runs.
    - *project_name* (required)
      - Prefix for output .tar.gz. Result will be named: *output_prefix*.tar.gz
    - *Amplicon Repository Email*
      - If wanting to directly transfer results to AmpliconRepository.org, please enter your email.
    - *run amplicon classifier*
      - Option for users to re-run Amplicon Classifier.
    - *reference genome*
      - Reference genome used for Amplicon Architect results in the input.
    - *upload only*
      - If 'Yes', then skip aggregation / classification and upload file to AmpliconRepository as is.
    - *name map*
      - A two column file providing the current identifier for each sample (col 1) and a replacement name (col 2). Enables batch renaming of samples.



    - Option 1: Git Clone
      - Step 1: `git clone https://github.com/genepattern/AmpliconSuiteAggregator.git`
      - Step 2: Install python package dependencies from list below.
      - **If running into dependency issues, please use the docker methods.**
    - Option 2: Docker
      - Step 1: `docker pull genepattern/amplicon-suite-aggregator`


    - List of python package dependencies used: intervaltree, matplotlib, numpy, pandas, Pillow, requests, scipy, urllib3



    - `-flist` / `--filelist`: Text file with files to use (one per line)
      -  Create an `input_list.txt` file in this format where each line is a filepath to compressed aa_results:
             <img width="269" alt="image" src="https://github.com/genepattern/AmpliconSuiteAggregator/assets/43209173/cca8c8af-a58f-4290-a8a8-4dbe82e5941e">

      - Use this file as the input to the `-flist` flag.
    - `--files`: List of files or directories to use. Can specify multiple paths of (.tar.gz, .zip) of Amplicon Architect results.
    - `-o` / `--output_name`: Output Prefix. Will be used as project name for Amplicon Repository upload.
    - `--name_map`: A two column file providing the current identifier for each sample (col 1) and a replacement name (col 2). Enables batch renaming of samples.
    - `-c` / `--run_classifier` (Yes, No): If 'Yes', then run Amplicon Classifier on AA samples. If Amplicon Classifier results are already included in inputs, then they will be removed and samples will be re-classified.
    - `--ref` (hg19, GRCh37, GRCh38, GRCh38_viral, mm10): Reference genome name used for alignment, one of hg19, GRCh37, GRCh38, GRCh38_viral, or mm10.


    - `-u` / `--username`: Email address for Amplicon Repository. If specified, will trigger an attempt to upload the aggregated file to AmpliconRepository.org.
    - `--upload_only` (Yes, No): If 'Yes', then skip aggregation / classification and upload file to AmpliconRepository as is.
    - `-s` / `--server` (dev, prod, local-debug): Which server to send results to. Accepts 'dev' or 'prod' or 'local-debug'. 'prod' is what most users want. 'dev' and 'local-debug' are for development and debugging.


    - If using local CLI:
      -  Running aggregator: `python3 /path/to/AmpliconSuiteAggregator/path/src/AmpliconSuiteAggregator.py **options**`
      -  Using API to upload directly to AmpliconRepository **without aggregation**: `python3 /path/to/AmpliconSuiteAggregator/path/src/AmpliconSuiteAggregator.py --files /path/to/aggregated/file.tar.gz -o projname -u your.amplicon.repository.username@gmail.com --upload_only Yes -s prod`
          -  Log into Amplicon Repository, you should see a new project with the output prefix you specified.

    - If using Docker:
      - To  Running aggregator:
          1. `docker run --rm -it -v PATH/TO/INPUTS/FOLDER:/inputs/ genepattern/amplicon-suite-aggregator python3 /opt/genepatt/AmpliconSuiteAggregator.py **options**`
      - Using API to upload directly to AmpliconRepository **without aggregation**:
          1. `docker run --rm -it -v PATH/TO/INPUTS/FOLDER:/inputs/ genepattern/amplicon-suite-aggregator python3 /opt/genepatt/AmpliconSuiteAggregator.py -flist /path/to/input_list.txt -u YOUR_AMPLICON_REPOSITORY_EMAIL -o projname -u your.amplicon.repository.username@gmail.com --upload_only Yes -s prod`
          2. Log into Amplicon Repository, you should see a new project with the output prefix you specified.


    - Python


  For any issues
    - Edwin Huang, edh021@cloud.ucsd.edu

rpm_license:
  ---------------------------------------------------------------- *** GENEPATTERN LICENSE AGREEMENT ***  ---------------------------------------------------------------- GenePattern is distributed under the following BSD-style license:  Copyright (c) 2003-2022 Regents of the University of California. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  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 names of the Regents of the University of California 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 AS IS.  REGENTS OF THE UNIVERSITY OF CALIFORNIA MAKE NO EXPRESS OR IMPLIED REPRESENTATIONS OR WARRANTIES OF ANY KIND REGARDING THE SOFTWARE AND COPYRIGHT, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, CONFORMITY WITH ANY DOCUMENTATION, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, WHETHER OR NOT DISCOVERABLE. IN NO EVENT SHALL REGENTS OF THE UNIVERSITY OF CALIFORNIA, THE COPYRIGHT HOLDERS, 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, HAVE REASON TO KNOW, OR IN FACT SHALL KNOW OF THE POSSIBILITY OF SUCH DAMAGE.  If, by operation of law or otherwise, any of the aforementioned warranty disclaimers are determined inapplicable, your sole remedy, regardless of the form of action, including, but not limited to, negligence and strict liability, shall be replacement of the software with an updated version if one exists.


pkgId: 745b4ac954d87e41205078f7e2265841311bc44c4dfb4d60b903f600744e7abd
name: python-AmqpConnector
arch: src
version: 0.0.41
epoch: 0
release: 1
summary: Simple library for building a distributed task system over AMQP.
url: http://pypi.python.org/pypi/AmqpConnector/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AmqpConnector-0.0.41-1.src.rpm
checksum_type: sha256
description:
  This is a very minimal library intended for distributed task systems, where the
  AMQP system is used for both task distribution, *and* collation of the task
  results. This seems to be somewhat unusual among most AMQP libraries, where
  a AMQP client is either a pure producer, a pure consumer, or includes everything
  including the kitchen sink, a stove, a backup kitchen sink, and possibly
  an entire house in case you don't have one to put the sink in (*cough* Celery
  *cough*). In this case, each client consumes from one queue, and produces on
  another.

  At it's core, this basically just allows one to put byte-strings into one end,
  they're passed out to the clients, and the clients then return byte-strings,
  which come out the other end.

  Correlation between submitted tasks and responses is entirely left up to the
  responsibility of the end-user code.

  Requires:

   - `amqp` library


pkgId: 1213581584684a852ee4080da969c22444a37474c0866fcf25146d83107d7812
name: python-Amsync
arch: src
version: 0.0.53
epoch: 0
release: 1
summary: An async library to easily create bots for the amino.
url: https://github.com/ellandor/Amsync
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Amsync-0.0.53-1.src.rpm
checksum_type: sha256
description:
  Created with the aim that, anyone with basic knowledge of python, create any bot without much difficulty
  <br>
  <br>



  ```
  pip install Amsync
  ```
  <br>
  <br>



  ```py
  from amsync import Bot, Msg


  bot = Bot('email', 'password', prefix='/')

  @bot.on()
  async def ready():
      print('Ready')

  @bot.add()
  async def hi(m: Msg):
      await bot.send(f'Hi {m.nickname}')

  bot.run()
  ```
  **[Incredible documentation to create beautiful bots](https://github.com/ellandor/Amsync/blob/main/docs/docs.md)**


pkgId: 40846c2b3764947bf07d2fda7687cfb78acc342ccc6c4eb8740f046ac79c5887
name: python-AnPaFinder
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: A basic package to find anagrams and palindromes.
url: https://github.com/AmryAnn/anpaFinder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnPaFinder-1.2.2-1.src.rpm
checksum_type: sha256
description:
  Version 1.2.2 released 04/2022

  A simple package built to find anagrams and palindromes from a webpage.
  Includes functionality to store and process strings and substrings,
  and easily parse text from a webpage.


  `AnPaFinder` can be installed via `pip`:
  ```
  $ python3 -m pip install AnPaFinder
  ```

  -Find the anagrams and palindromes from a webpage in one of three possible ways:
   - Option 1. In python environment:
     ```
     import anpa_tools.anpatools as anp
     anp.find_anpas("<webpage url>")
     ```
   - Option 2. Run anpatools.py from command line:
     ```
     $ python3 anpatools.py --url "<webpage url>"
     ```
   - Option 3. Using the shell script in the **Home Page - anpaFinder GitHub repository** under `/bin`:
     ```
     $ ./AP_finder.bash -w "<webpage url>"
     ```
  -Play with classes and functions in `anpa_tools` package.
   - More info to come


pkgId: 11148528e8cabf6898e00914a319a0f4e67f426950fedbc46e96291c2a93503d
name: python-AnaText
arch: src
version: 2.1.2.dev0
epoch: 0
release: 1
url: https://pypi.org/project/AnaText/
rpm_license: Attribution 4.0 International
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnaText-2.1.2.dev0-1.src.rpm
checksum_type: sha256
summary:
  "The program for solving the problem of exploratory text analysis based on clustering and approximation of the number of clusters."


pkgId: f3d051f3aacf2ec684b7e3c645a55ca4f4f391fc4d545b354af8dd7df8ed34ff
name: python-AnaviInfraredPhat
arch: src
version: 0.0.11
epoch: 0
release: 1
summary: AnaviInfraredPhat
url: https://github.com/KurisuD/AnaviInfraredPhat
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnaviInfraredPhat-0.0.11-1.src.rpm
checksum_type: sha256
description:
  Publishes temperature, pressure, humidity, luminosity and heat index from your Pi over 0MQ.

  ```
  python3 -m AnaviInfraredPhat --verbose
  2019-05-12 10:40:19.192 JST [   DEBUG] __init__ : Logging with global level DEBUG
  2019-05-12 10:40:19.196 JST [   DEBUG] __init__ : Sysout logging with level DEBUG
  2019-05-12 10:40:19.199 JST [   DEBUG] __init__ : Changing sysout format to logfile
  2019-05-12 10:40:19.217 JST [   DEBUG] __init__ : Added TimedRotatingFileHandler to /var/logAnaviInfraredPhat.log with level DEBUG.
  2019-05-12 10:40:19.228 JST [   DEBUG] __init__ : Log rotates every D and keeps 15 logs.
  2019-05-12 10:40:19.233 JST [    INFO] __main__ : Starting
  2019-05-12 10:40:20.093 JST [   DEBUG] __main__ : {"hi": null, "l": 63, "hi_cmt": "No concerns", "h": 42, "p": 1015, "t": 25.8}
  ```



  The module can be used from a different machine than the Raspberry Pi hosting the Anavi Infrared Phat.

  It has a class for each sensor provided with the original Anavi Infrared Phat Kit.

  * BH1750
  * HTU21D
  * BMP180

  As well as a class to emit IR codes.

  * IRSEND (adapted from Joan's script @ http://abyz.co.uk/rpi/pigpio/code/irrp_py.zip. It uses records files which are to be created with irrp.py)

  Some more functions are available as example or boilerplate code:

  * report_tphl
  * report_tphl_average
  * report_tphl_as_text

  Please refer to the code.


pkgId: 61c8e6877729307f30aa5fa39c71bea1169421807088ae7b19794b0339930207
name: python-AndroidTelePorter
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Serializer and deserializer for mobile telegram session
url: https://github.com/batreller/AndroidTelePorter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AndroidTelePorter-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![pypi package](https://img.shields.io/pypi/v/AndroidTelePorter.svg)](https://pypi.python.org/pypi/AndroidTelePorter/)


  Serializer and deserializer for mobile telegram session



  - [Project Name](#project-name)
    - [Table of Contents](#table-of-contents)
    - [Description](#description)
    - [Installation](#installation)
    - [Usage](#usage)



  This tool can be used to serialize and deserialize session on original Telegram client for Android phones.

  It can extract any information stored in files/tgnet.dat and all needed information from shared_prefs/userconfing.xml

  It also can deserialize existing session into object and convert it into other session formats (currently supported tdata, telethon and tgnet)

  And you can serialize session manually into mobile tgnet format, all you need is just auth key, datacenter id and user id, it is minimum information needed for almost any session format



  You can easily set up this package as it is available on pypi by running the following command
  ```bash
  pip install AndroidTelePorter
  ```




  ```python
  from AndroidTelePorter import AndroidSession




  session = AndroidSession.from_tgnet(
      tgnet_path=r'files\tgnet.dat',  # contains auth key and dc id
      userconfig_path=r'shared_prefs\userconfing.xml'  # contains user id
  )

  session.to_tgnet('converted/tgnet')  # will create all needed files right in directory that you specified

  session.to_tdata('converted/pc')  # will create another folder "tdata" inside directory that you specified

  session.to_telethon('converted/telethon.session')  # must end with .session
  ```


  ```python
  from AndroidTelePorter import AndroidSession

  session = AndroidSession.from_manual(
      auth_key=bytes.fromhex('hex auth key'),
      dc_id=0,  # datacenter id (from 1 to 5)
      user_id=12345678  # telegram user id
  )  # can be used to create any session (tgnet / tdata / telethon) from auth key, dc id and user id

  session.to_tgnet('converted/tgnet')  # will create all needed files right in directory that you specified
  ```


pkgId: 2ac5a41e7d60115db772109355b1ae0c0fb637ddd369e0cd6d1cc2572822e1a7
name: python-Angular-Deviation-Diffuser
arch: src
version: 1.0.9
epoch: 0
release: 1
url: https://github.com/AlanYangYi/angular_deviation_diffuser
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Angular-Deviation-Diffuser-1.0.9-1.src.rpm
checksum_type: sha256
summary:
  This is a Transformer-Based diffusion model for Efficient Protein Conformational Ensemble Generation

description:
  If you have any issues or questions, please feel free to open an issue in the repository or contact us directly.

rpm_license:
  MIT License  Copyright (c) [2024] [YI YANG]  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: 550189bb6656a321dc716133cb95c69e33ea2e77c1552e5fec66183ba4557137
name: python-AniMAIRE
arch: src
version: 1.1.10
epoch: 0
release: 1
summary: Python library for running the anisotropic version of MAIRE+
url: https://github.com/ssc-maire/AniMAIRE-public
rpm_license: CC By-NC-SA 4.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AniMAIRE-1.1.10-1.src.rpm
checksum_type: sha256
description:
  ![The AniMAIRE logo](https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/AniMAIRE_logo.svg)

  A Python toolkit for calculating dose rates and aircraft electronics upset rates in Earth's atmosphere based on any incoming proton or alpha particle spectra, with any pitch angle distribution.

  **N.B. Currently this tool only runs on Linux-based machines (not on Windows) and requires a copy of [MAGNETOCOSMICS](http://cosray.unibe.ch/~laurent/magnetocosmics/) to be installed.**

  If you use this software for scientific research, please reference AniMAIRE according to the appropriate journal publication rules.

  A scientific paper about this software is currently in production, and we recently published a preprint, [which can be found here](https://www.researchgate.net/publication/380403797_AniMAIRE_-_A_New_Openly_Available_Tool_for_Calculating_Atmospheric_Ionising_Radiation_Dose_Rates_and_Single_Event_Effects_During_Anisotropic_Conditions), about AniMAIRE and some interesting scientific findings we've made using our work with AniMAIRE so far.

  You can use AniMAIRE to produce dose rate data and maps throughout large space weather events and plot them like this:

  <img src="https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/Ani_GLE_only_timestamp1_with_legend.svg" width="350"/> <img src="https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/Ani_GLE_only_timestamp5_with_legend.svg" width="350"/>

  <!-- ![An example map of dose rates during a large space weather event](https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/Ani_GLE_only_timestamp1_with_legend.svg) | ![An example animation of dose rates during a large space weather event](https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/39kft_heatmap_animation_no_contours_anisotropic.gif) -->



  To install this toolkit using the common pip Python method, run

  ```
  pip install AniMAIRE
  ```

  Otherwise, to install this toolkit from this Github repository, first clone this repository to your local system, and then from the cloned respository, run

  ```
  sudo pip3 install .
  ```

  in the cloned directory.

  Note that there are quite a few sizeable data files within some of the dependencies for this package that get copied during installation (on the order of about several hundred megabytes in total) so installation may take a couple of minutes.

  **To use this package you must have a version of magnetocosmics installed, such that magnetocosmics can be run by typing 'magnetocosmics' the terminal, i.e. typing:**

  ```
  $ magnetocosmics
  ```
  outputs something like the following:
  ```


            
            !!! G4Backtrace is activated !!!
            


  **************************************************************
   Geant4 version Name: geant4-11-00-patch-02 [MT]   (25-May-2022)
                         Copyright : Geant4 Collaboration
                        References : NIM A 506 (2003), 250-303
                                   : IEEE-TNS 53 (2006), 270-278
                                   : NIM A 835 (2016), 186-225
                               WWW : http://geant4.org/
  **************************************************************

  /h n m 1900.0 1905.0 1910.0 1915.0 1920.0 1925.0 1930.0 1935.0 1940.0 1945.0 1950.0 1955.0 1960.0 1965.0 1970.0 1975.0 1980.0 1985.0 1990.0 1995.0   2000.0    2005.0    2010.0    2015.0   2020.0    SV
  mmm1900
  Nyear 25
  1900
  Nyear 25

  ...

  g       8       8
  h       8       8
  g       9       0
  0.0     0       -999
  XGSE in GEI (0.193332,-0.900173,-0.39027)
  (0.0573796,-0.172205,0.983389)
  -19.4809
  Selected index20
  XGSE in GEI (0.17509,-0.903305,-0.391643)
  (0.0590434,-0.175608,0.982688)
  -25.9091
  Test93
  Test97
  Test
  G4CashKarpRKF45 is called
  ```

  While this package is new, it fundamentally relies on Magnetocosmics through the [AsympDirsCalculator package](https://github.com/ssc-maire/AsymptoticDirectionsCalculator-public), and it is likely that the community will eventually create a successor for Magnetocosmics. One attempt to do this is the [OTSO software](https://github.com/NLarsen15/OTSO), which is also designed to be open-source and community oriented. We hope that in the future, AniMAIRE could be integrated with OTSO.



  After installation, to import the toolkit into a particular Python script, run
  ```
  from AniMAIRE import AniMAIRE
  ```
  All of the main useful functions are contained within this `AniMAIRE` module, and all other modules contained in this toolkit are primarily intended to be accessed internally (although don't let that stop you from using or editing them for your own purposes if you wish).

  The rest of the README file describes how to run AniMAIRE to produce dose rates for different input parameters. You can also look at and run the examples present in the `AniMAIRE_examples.ipynb` notebook, and the advanced examples in the `notebooks_and_data_and_figures_for_paper/GLE71_plots_for_paper.ipynb` notebook to learn and see in practice how AniMAIRE can be used.



  To test that AniMAIRE works, you can run:

  ```
  from AniMAIRE import AniMAIRE
  import datetime as dt

  test_isotropic_dose_rates = AniMAIRE.run_from_spectra(
          proton_rigidity_spectrum=lambda x:2.56*(x**-3.41),
          Kp_index=3,
          date_and_time=dt.datetime(2006, 12, 13, 3, 0),
          array_of_lats_and_longs=[[65.0,25.0]],
  )
  ```

  in Python. This should produce some dose rates as output to `test_isotropic_dose_rates` in the format (the meaning of each column is explained later on in this README, under the "Simple isotropic runs and plotting" heading):

  ```
      latitude  longitude  altitude (km)      edose      adose      dosee       tn1       tn2       tn3           SEU           SEL
  0       65.0       25.0         0.0000   0.010434   0.012526   0.010010  0.004431  0.002726  0.001826  2.725682e-16  2.725682e-11
  1       65.0       25.0         3.0480   0.101553   0.117294   0.085010  0.051717  0.033506  0.022912  3.350616e-15  3.350616e-10
  2       65.0       25.0         6.0960   0.669389   0.736989   0.456343  0.324250  0.210297  0.144131  2.102967e-14  2.102967e-09
  3       65.0       25.0         7.6200   1.432404   1.525608   0.966025  0.658130  0.426616  0.292777  4.266156e-14  4.266156e-09
  4       65.0       25.0         8.5344   2.147704   2.220632   1.416257  0.950846  0.614894  0.422072  6.148938e-14  6.148938e-09
  5       65.0       25.0         9.4488   3.108676   3.124392   2.063826  1.319292  0.854931  0.586036  8.549315e-14  8.549315e-09
  6       65.0       25.0        10.3632   4.377677   4.263813   2.692120  1.767081  1.142345  0.782749  1.142345e-13  1.142345e-08
  7       65.0       25.0        11.2776   5.993970   5.643631   3.764450  2.292849  1.480059  1.010255  1.480059e-13  1.480059e-08
  8       65.0       25.0        12.1920   7.953998   7.262904   5.017846  2.881359  1.850446  1.263386  1.850446e-13  1.850446e-08
  9       65.0       25.0        13.1064  10.414874   9.115408   6.247418  3.514676  2.249009  1.532907  2.249009e-13  2.249009e-08
  10      65.0       25.0        14.0208  13.242733  11.101641   7.800097  4.184576  2.665499  1.810092  2.665499e-13  2.665499e-08
  11      65.0       25.0        14.9352  16.603692  13.430864   9.571582  4.865316  3.082233  2.086676  3.082233e-13  3.082233e-08
  12      65.0       25.0        15.8496  20.842479  15.942018  11.573518  5.568722  3.503950  2.361370  3.503950e-13  3.503950e-08
  13      65.0       25.0        16.7640  25.482167  18.658393  13.926003  6.254882  3.914514  2.628245  3.914514e-13  3.914514e-08
  14      65.0       25.0        17.6784  31.020574  21.767530  16.937656  6.902852  4.295149  2.869582  4.295149e-13  4.295149e-08
  15      65.0       25.0        18.5928  37.203113  24.734609  19.638953  7.495669  4.637948  3.081391  4.637948e-13  4.637948e-08
  ```



  The primary function for performing a run to calculate dose rates in `AniMAIRE` is the `run_from_spectra` function, which has the format:

  ```
  def run_from_spectra(
          proton_rigidity_spectrum=None,
          alpha_rigidity_spectrum=None,
          reference_pitch_angle_latitude=None,
          reference_pitch_angle_longitude=None,
          proton_pitch_angle_distribution=isotropicPitchAngleDistribution(),
          alpha_pitch_angle_distribution=isotropicPitchAngleDistribution(),
          altitudes_in_kft=[0,10,20] + [i for i in range(25, 61 + 1, 3)],
          altitudes_in_km=None,
          Kp_index=None,
          date_and_time=dt.datetime.now(),
          array_of_lats_and_longs=default_array_of_lats_and_longs,
          array_of_zeniths_and_azimuths=np.array([[0.0, 0.0]]),
          cache_magnetocosmics_run=True,
          generate_NM_count_rates=False,
          use_default_9_zeniths_azimuths=False,
          **mag_cos_kwargs
  )
  ```

  `run_from_spectra` performs a run at a single date and time and Kp index to calculate dose rates across Earth's atmosphere based on proton, alpha particle, or proton + alpha particle spectra. **Particle spectra here must be described in units of cm-2 s-1 sr-1 (GV/n)-1, and with respect to rigidity in units of GV**.

  Particle spectra and pitch angle distributions can be set as any 'callable' object in Python, i.e., a function, as shown in examples below. At least one particle spectrum must be specified, as well as a Kp index, so this function to execute successfully. For runs designed to simulate dose rates during particular dates and times, the argument `date_and_time` must also be supplied with a Python `datetime` corresponding to the timestamp being investigated (by default, the function assumes that the current date and time should be used).

  Note that while this function can optionally take an alpha particle spectrum as an input, it actually interpolates the dose rates due to alpha particles to those of heavier ions too, so outputted dose rates due to an alpha particle spectrum are in fact the combined total of all ions heavier than protons.

  Several types of runs can be performed with AniMAIRE; for instance, only vertical asymptotic directions are used to calculate dose rates by default. You can optionally set `use_default_9_zeniths_azimuths` to `True` to use the mean of nine different asymptotic directions to calculate dose rates, as was done by [Cramp et al. (1997)](https://doi.org/10.1029/97JA01947), to calculate dose rates during particularly complex events (note that this means calculations will take approximately nine times longer). You can also manually set your own choice of asymptotic directions for taking the average using the `array_of_zeniths_and_azimuths` variable.

  `AniMAIRE` performs runs of the MAGNETOCOSMICS as part of dose rate calculations (using the [AsympDirsCalculator](https://github.com/ssc-maire/AsymptoticDirectionsCalculator) package), and these currently take up by far the majority of `AniMAIRE` runtime - on the order of over half an hour on the developer's computer versus less than 6 minutes for the rest of the program. Therefore if the `cache_magnetocosmics_run` argument is set to `True`, which it is by default, `AniMAIRE` will cache the results of MAGNETOCOSMICS simulations in the directory that `AniMAIRE` is run from in the generated `cachedMagnetocosmicsRunData` and `cacheAsymptoticDirectionOutputs` directories. This significantly speeds up any tasks where users wish to investigate a constant `Kp_index` and `date_and_time`, but wish to vary the spectrum and pitch angle distribution and investigate how dose rates are impacted, as magnetocosmics runs are only performed once.

  You can pass settings and variables to `AsympDirsCalculator` through adding additional keyword arguments to `run_from_spectra` with the same names as the arguments given on the [AsympDirsCalculator Github page](https://github.com/ssc-maire/AsymptoticDirectionsCalculator). These settings and variable get assigned to the `**mag_cos_kwargs` object, and passed to `AsympDirsCalculator` by `AniMAIRE`.



  A basic run of the `run_from_spectra` function might look like this:

  ```
  from AniMAIRE import AniMAIRE
  import datetime as dt

  test_isotropic_dose_rates = AniMAIRE.run_from_spectra(
          proton_rigidity_spectrum=lambda x:2.56*(x**-3.41),
          Kp_index=3,
          date_and_time=dt.datetime(2006, 12, 13, 3, 0),
  )
  ```

  in this example, the proton rigidity spectrum is set to be a power law with a normalisation factor of 2.56 cm-2 s-1 sr-1 (GV/n)-1, and a spectral index of 3.41, using the commonly used `lambda` approach to create a function within a single line. Kp index is set to be 3, and the date and time to simulate are set to be 13th of December 2006, 03:00. This function will likely take at least several minutes to run, depending on the speed of the machine and number of cores, and should output a Pandas DataFrame to `test_isotropic_dose_rates`, giving:

  ```
  	latitude	longitude	altitude (km)	edose	adose	dosee	tn1	tn2	tn3	SEU	SEL
  0	-90.0	0.0	0.0000	0.010442	0.012540	0.010010	0.004437	0.002729	0.001828	2.729229e-16	2.729229e-11
  1	-90.0	0.0	3.0480	0.101786	0.117658	0.085755	0.051895	0.033617	0.022979	3.361684e-15	3.361684e-10
  2	-90.0	0.0	6.0960	0.672702	0.742332	0.457695	0.326731	0.211853	0.145046	2.118530e-14	2.118530e-09
  3	-90.0	0.0	7.6200	1.442377	1.541670	0.975436	0.665785	0.431261	0.295516	4.312608e-14	4.312608e-09
  4	-90.0	0.0	8.5344	2.165860	2.249419	1.426324	0.964791	0.623291	0.426927	6.232913e-14	6.232913e-09
  ...	...	...	...	...	...	...	...	...	...	...	...
  42619	90.0	355.0	14.9352	16.953199	14.033322	9.762795	5.138425	3.234975	2.164808	3.234975e-13	3.234975e-08
  42620	90.0	355.0	15.8496	21.327714	16.796347	11.858681	5.949880	3.711156	2.463976	3.711156e-13	3.711156e-08
  42621	90.0	355.0	16.7640	26.122787	19.802434	14.318360	6.759204	4.182604	2.757482	4.182604e-13	4.182604e-08
  42622	90.0	355.0	17.6784	31.856083	23.278901	17.431863	7.562120	4.638132	3.029771	4.638132e-13	4.638132e-08
  42623	90.0	355.0	18.5928	38.265701	26.680896	20.232603	8.340509	5.067928	3.275415	5.067928e-13	5.067928e-08
  ```

  when `test_isotropic_dose_rates` is printed.

  The outputted dose rate (or flux) labels represent the following dose rate/flux types:

  |label | dose rate/flux type|
  |------|--------------------|
  |adose| ambient dose equivalent in µSv/hr |
  |edose| effective dose in µSv/hr |
  |dosee| dose equivalent in µSv/hr |
  |tn1| >1 MeV neutron flux, in n/cm2/s |
  |tn2| >10 MeV neutron flux, in n/cm2/s |
  |tn3| >60 MeV neutron flux, in n/cm2/s |
  |SEU| single event upset rate for an SRAM device in upsets/second/bit |
  |SEL| single event latch-up rate for an SRAM device in latch-ups/second/device |

  These dose rates are produced by default at every latitude and longitude corresponding to 5 by 5 degree intervals across Earth's surface, and for altitudes of 0 kilofeet, 10 kilofeet, 20 kilofeet and between 25 kilofeet and 61 kilofeet at intervals of 3 kilofeet. This can be altered using the `altitudes_in_kft`, `altitudes_in_km` and `array_of_lats_and_longs`.

  Any particular altitudes the user wants to use can be supplied to `altitudes_in_kft` or `altitudes_in_km` as a `list` or numpy array.

  If you want to perform calculations only at a specific set of latitudes and longitudes you should use the `array_of_lats_and_longs` argument, supplying it as a 2 dimensional `list` or numpy array, where the first column refers to latitudes and the second column refers to longitudes. All longitudes in this case should be specified in terms of longitude east (i.e. 0.00 degrees - 359.99 degrees). **Using the `array_of_lats_and_longs` argument significantly speeds up the running of `AniMAIRE` if you're only interested in a small number of coordinates, so its use is highly recommended in those situations.**

  There are many ways you could plot this data. Several example functions,`plot_dose_map` and `create_single_dose_map_plotly`, have been supplied in `AniMAIRE` that uses matplotlib or plotly to plot the dose rates across Earth (i.e. as a function of latitude and longitude) at a given altitude. Both of these functions are available in the `dose_plotting` submodule supplied with AniMAIRE. Their specifications are the following:
  ```
  def plot_dose_map(map_to_plot,
                    plot_title=None,
                    plot_contours=True,
                    levels=3,
                      **kwargs)
  ```
  for matplotlib plots, where map_to_plot is the Pandas DataFrame outputted by a run of `AniMAIRE`, with only one altitude selected. `plot_contours` can be switched on or off to control whether contours are added to the plot, and `levels` can be used to specify to number of contours and/or dose rates for the contours to correspond to. `hue_range` can also be supplied with a 2-value tuple to specify the limits of the colorbar to be plotted with the plot.

  To generate a plotly plot, you can run
  ```
  def create_single_dose_map_plotly(DF_to_use,
                                  selected_altitude_in_km)
  ```
  where `DF_to_use` is the Pandas DataFrame outputted by a run of `AniMAIRE` and altitude is one of the altitudes in kilometers supplied to/outputted by the run.

  To use the matplotlib function to create a map of the isotropic situation as given as an example above, you could run
  ```
  from AniMAIRE import dose_plotting
  import matplotlib.pyplot as plt

  dose_plotting.plot_dose_map(test_isotropic_dose_rates.query("`altitude (km)` == 12.1920"),
                                           hue_range=(0,9))

  plt.show()
  ```

  which should plot the following figure as a matplotlib plot:
  ![isotropic_test_plot](https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/Isotropic_40kft_example.svg)

  and assign the plot to the `isotropic_dose_rate_map` variable for the user to use as they wish.



  `run_from_spectra` defaults to an isotropic spectrum if no pitch angle distribution is supplied for either protons or alpha particles by the user.

  To run an anisotropic spectrum, differential pitch angle distributions must be supplied to the `proton_pitch_angle_distribution` and/or `alpha_pitch_angle_distribution` arguments in `run_from_spectra` along with a reference location specified in terms of latitude and longitude in the `reference_pitch_angle_latitude` and `reference_pitch_angle_longitude` arguments respectively. The pitch angle distributions must be supplied as 2 dimensional functions, where the first argument is the pitch angle, and the second argument is particle rigidity (in many cases the pitch angle distribution might not depend on rigidity, but for programmatic reasons the function must at least take in rigidity as an argument although it does not need to have a dependence on it). The pitch angle here must be specified in units of **radians**.

  `reference_pitch_angle_latitude` and `reference_pitch_angle_longitude` are the reference latitude and longitude in GEO coordinates representing a pitch angle of 0 in the supplied pitch angle distribution used. `AniMAIRE` currently makes the assumption that incoming particle distributions are cylindrically symmetric about this reference direction, and therefore that only the pitch angle with respect to this latitude and longitude are required to calculate dose rates anisotropically across Earth. Incoming solar particle events are frequently oriented near to the direction of the Interplanetary Magnetic Field (IMF), so you could specify pitch angles relative to the IMF here, and use the latitude and longitude of the IMF as the reference latitude and longitude.

  The pitch angle distributions and rigidity spectrum must be specified in units normalised such that the product of the pitch angle distribution and rigidity spectrum multiplied together is in units of **cm-2 s-1 sr-1 (GV/n)-1**.

  The pitch angle distributions can be specified using the Python `lambda` as with the rigidity spectra, but with 2 dimensions rather than 1. For example, to specify a Gaussian pitch angle distribution you could use:

  ```
  import numpy as np

  sigma = np.sqrt(0.19)

  test_pitch_angle_dist_function = lambda pitch_angle,rigidity:np.exp(-(pitch_angle**2)/(sigma**2))
  ```
  where `sigma` here has arbitrarily been chosen to be the square root of 0.19 for example purposes.

  here `pitch_angle_dist_function` would be a viable input as a pitch angle distribution to `run_from_spectra`. While the function itself does not depend on `rigidity`, `rigidity` is specified as the second argument of the function nonetheless, as required for calculations to work.

  An example of using this might be:

  ```
  import numpy as np
  from AniMAIRE import AniMAIRE
  import datetime as dt

  sigma = np.sqrt(0.19)
  pitch_angle_reference_latitude = -17.0
  pitch_angle_reference_longitude = 148.0

  test_pitch_angle_dist_function = lambda pitch_angle,rigidity:np.exp(-(pitch_angle**2)/(sigma**2))

  test_anisotropic_dose_rates = AniMAIRE.run_from_spectra(
          proton_rigidity_spectrum=lambda x:2.56*(x**-3.41),
          proton_pitch_angle_distribution=test_pitch_angle_dist_function,
          reference_pitch_angle_latitude=pitch_angle_reference_latitude,reference_pitch_angle_longitude=pitch_angle_reference_longitude,
          Kp_index=3,
          date_and_time=dt.datetime(2006, 12, 13, 3, 0),
  )
  ```

  when run this should output a Pandas DataFrame to `test_anisotropic_dose_rates` with the same general output format as given in the previously described isotropic dose rates case.

  In this case printing `test_anisotropic_dose_rates` should output:
  ```
  	latitude	longitude	altitude (km)	edose	adose	dosee	tn1	tn2	tn3	SEU	SEL
  0	-90.0	0.0	0.0000	1.976895e-07	2.027961e-07	3.222401e-07	1.286575e-08	7.877480e-09	5.401425e-09	7.877480e-22	7.877480e-17
  1	-90.0	0.0	3.0480	4.838923e-07	4.869626e-07	7.032983e-07	7.429541e-08	4.866265e-08	3.410940e-08	4.866265e-21	4.866265e-16
  2	-90.0	0.0	6.0960	1.453834e-06	1.411544e-06	2.045308e-06	2.472576e-07	1.611648e-07	1.136527e-07	1.611648e-20	1.611648e-15
  3	-90.0	0.0	7.6200	2.352658e-06	2.382057e-06	3.304989e-06	3.720997e-07	2.420436e-07	1.708843e-07	2.420436e-20	2.420436e-15
  4	-90.0	0.0	8.5344	2.970462e-06	2.791970e-06	4.201789e-06	4.473736e-07	2.919136e-07	2.063902e-07	2.919136e-20	2.919136e-15
  ...	...	...	...	...	...	...	...	...	...	...	...
  42619	90.0	355.0	14.9352	1.062397e-06	7.975138e-07	5.902218e-07	2.766678e-07	1.764588e-07	1.216189e-07	1.764588e-20	1.764588e-15
  42620	90.0	355.0	15.8496	1.289216e-06	9.183397e-07	6.964574e-07	3.063998e-07	1.945207e-07	1.338582e-07	1.945207e-20	1.945207e-15
  42621	90.0	355.0	16.7640	1.525359e-06	1.040969e-06	8.062018e-07	3.339381e-07	2.112220e-07	1.452375e-07	2.112220e-20	2.112220e-15
  42622	90.0	355.0	17.6784	1.777447e-06	1.163693e-06	9.297615e-07	3.568426e-07	2.248452e-07	1.543556e-07	2.248452e-20	2.248452e-15
  42623	90.0	355.0	18.5928	2.036052e-06	1.275021e-06	1.040287e-06	3.755276e-07	2.357292e-07	1.614028e-07	2.357292e-20	2.357292e-15
  ```

  which will produce the following plot when
  ```
  from AniMAIRE import dose_plotting
  import matplotlib.pyplot as plt

  dose_plotting.plot_dose_map(test_anisotropic_dose_rates.query("`altitude (km)` == 12.1920"),
                                           hue_range=(0,9))

  plt.show()
  ```
  is run, as was described previously in this README for isotropic plotting:

  ![anisotropic_test_plot](https://raw.githubusercontent.com/ssc-maire/AniMAIRE-public/main/Anisotropic_40kft_example.svg)


  you can also produce similar plotly plots if you prefer plotly to matplotlib using:
  ```
  from AniMAIRE import dose_plotting

  anisotropic_dose_rate_map = dose_plotting.create_single_dose_map_plotly(test_anisotropic_dose_rates,
                              			      selected_altitude_in_km = 12.1920)
  ```
  which generates the following plot:

  ![anisotropic_test_plot](https://user-images.githubusercontent.com/16866485/223751057-5d0cff98-cf9e-4654-b71f-d1ae55c75602.png)



  In addition to the quite general `run_from_spectra` function, `AniMAIRE` currently contains several functions for running calculations for specific types of spectra and situations, to make it easier for users to perform runs without having to determine and feed in spectra to `run_from_spectra` themselves.

  The `run_from_DLR_cosmic_ray_power_law` function allows users to run full atmospheric dose rate calculations (for cosmic ray only/'quiet' time periods only) from just a date and time, or alternatively from just a single OULU count rate, or just a value of 'W parameter', as well as Kp index. This function utilises the [CosRayModifiedISO package](https://github.com/ssc-maire/CosRayModifiedISO) to determine the spectra due to protons and alpha particles during cosmic ray only time periods, and then runs `run_from_spectra` using both of those spectra under isotropic conditions. The specifications of `run_from_DLR_cosmic_ray_power_law` are:

  ```
  def run_from_DLR_cosmic_ray_model(OULU_count_rate_in_seconds=None,
                                        W_parameter=None,
                                        Kp_index=None,
  				      date_and_time=None,
                                        **kwargs)
  ```

  `**kwargs` here can be used to supply any arguments you wish to `run_from_spectra` as specified previously, such as the list of altitudes and list of coordinates to perform calculations for. Details on what `OULU_count_rate_in_seconds` and `W_parameter` mean can be found at https://github.com/ssc-maire/CosRayModifiedISO . If either `OULU_count_rate_in_seconds` or `W_parameter` are used, only one of them should be specified. Otherwise, `AniMAIRE` will determined their values using the `date_and_time` parameter supplied.

  In addition to running from the DLR-ISO isotropic cosmic ray model, you can also run `AniMAIRE` from a combined power law rigidity spectrum and Gaussian pitch angle distribution. This can be done using the `run_from_power_law_gaussian_distribution` function:

  ```
  def run_from_power_law_gaussian_distribution(J0, gamma, deltaGamma, sigma,
                                               reference_pitch_angle_latitude, reference_pitch_angle_longitude,
                                               Kp_index,date_and_time,
                                               **kwargs)
  ```

  Here `J0`, `gamma`, `deltaGamma`, `sigma`, `reference_pitch_angle_latitude`, `reference_pitch_angle_longitude` are all defined as specified in the format of papers like [Mishev, A., Usoskin, I. Analysis of the Ground-Level Enhancements on 14 July 2000 and 13 December 2006 Using Neutron Monitor Data. Sol Phys 291, 1225–1239 (2016). https://doi.org/10.1007/s11207-016-0877-2](https://link.springer.com/article/10.1007/s11207-016-0877-2).


pkgId: 8747eb8be329ff98c4f89085f1803c4aaae9ccfa5938d32330cd2d75b9dd269b
name: python-AniManga
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: AniManga is a python module which scrapes the web to get information on Anime, Manga (and hentai).
url: https://pypi.org/project/AniManga/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AniManga-0.1.1-1.src.rpm
checksum_type: sha256
description:
  ![pypi_version](https://img.shields.io/pypi/v/AniManga?style=flat-square)
  ![AniManga](https://img.shields.io/pypi/dd/AniManga?style=flat-square)
  ![issues](https://img.shields.io/github/issues/centipede000/AniManga?style=flat-square)
  ![version](https://img.shields.io/pypi/pyversions/AniManga?style=flat-square)
  ![codefactor](https://img.shields.io/codefactor/grade/github/centipede000/AniManga?style=flat-square)



  ![python](https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white)

  AniManga is a python module which scrapes the web to get information on Anime, Manga (and hentai).



  ```
  python3 -m pip install AniManga
  ```


  - Get description, author, cover page and reviews of a Manga by name.



  ```py
  from AniManga import Manga

  manga_description = Manga().get_manga_description("naruto")

  print(manga_description)
  ```

  Output:
  ```
  'Once, the ninja village of Konohagakure was attacked by an evil nine-tailed fox spirit. This demon slaughtered many people until the leader of Konohagakure, the 4th Hokage, sacrificed his life to seal the fox inside a newborn child - Naruto Uzumaki. Now, twelve years later, Naruto is a member of the Ninja Academy; but due to his past Naruto is shunned by the rest of the village, and since he has no friends or family he plays the part of class idiot to get attention. However, he is determined to gain respect by becoming the next Hokage - the most powerful shinobi in the village. With his apparent lack of abilities, will Naruto be able to realize his goal through determination alone?'
  ```

  Detailed docs available [here](https://github.com/centipede000/AniManga/tree/main/docs).



  - [Anime-Planet](https://animeplanet.com)
  - [nhentai](https://nhentai.net)


  <table>
  <thead>
  <tr>
  <th align="center"><a href="https://github.com/centipede000"><img src="https://github.com/centipede000.png?size=115" width="115" style="max-width: 100%;"><br><sub>@centipede000</sub></a></th>
  </tr>
  </thead>
  </table>

  **[Development](https://github.com/centipede000/AniManga/tree/dev) branch recieves updates almost daily.**


pkgId: 9344fe2f705c626a8c049bd21e9642f982a701748d22558dd149b14a6003d506
name: python-AnilistPython
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Anilist Python module for searching up anime, manga, characters info.
url: https://github.com/ReZeroE/AnilistPython
rpm_license: MIT Licence (MIT)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnilistPython-0.1.3-1.src.rpm
checksum_type: sha256
description:
  ![example workflow](https://github.com/ReZeroE/AnilistPython/actions/workflows/github-actions-demo.yml/badge.svg)
  ![downloads](https://img.shields.io/github/workflow/status/ReZeroE/AnilistPython/GitHub%20Actions%20Demo)
  ![downloads](https://img.shields.io/pypi/dm/AnilistPython)
  ![licence](https://img.shields.io/github/license/ReZeroE/AnilistPython)
  ![Test](https://pepy.tech/badge/anilistpython)

  AniList Python library (anilist.co APIv2 wrapper) that allows you to **easily search up and retrieve anime, manga, animation studio, and character information.** This library is both beginner-friendly and offers the freedom for more experienced developers to interact with the retrieved information. Provides bot support.

  ![alt text](https://i.imgur.com/uGzW7vr.jpg)


  This recent update for AnilistPython has resulted in a moderate change in the library's archetecture for increased efficiency and speed. Various features have also been added to the library. Listed below are some of the main additions and alterations made to the library.

  **New features**:
  1. Anime search by genre, year, and/or average score (finally!)
  2. Offline anime retrieval support for anime - BETA
  3. Manga search support
  4. Auto setup feature that help new python programmers to setup required libraries automatically

  Optimization and updates:
  1. The lib now has its own prebuild anime database!
  2. Anime, manga, and character search functions have all been optimized, making searches faster!
  3. Improved the deepsearch feature in `.get_anime()`.
  4. Manually selecting results feature is now a parameter instead of a seperate function (see usage below).



  **Step One:** Library Installation
  ``` python
  pip install AnilistPython==0.1.3
  ```
  **Step Two:** Instance Creation
  ```python
  from AnilistPython import Anilist
  anilist = Anilist()
  ```
  **Step Three**: Usage

  The AnilistPython library has been split into three distinct sections. Each section possess a different set of functions used for retrieving data in that category. Please visit the full documentation for more info or skip to the General Function Overview section for usage.
  - **Anime** - ([Documentation](https://github.com/ReZeroE/AnilistPython/wiki/Anime))
  - **Manga** - ([Documentation](https://github.com/ReZeroE/AnilistPython/wiki/Manga))
  - **Character** - ([Documentation](https://github.com/ReZeroE/AnilistPython/wiki/Character))



  The following functions are supported by AnilistPyhon version 0.1.3. Only the default parameter has been displayed below. For more information, visit the [full documentation](https://github.com/ReZeroE/AnilistPython/wiki).
  ```python

  anilist.get_anime("Owari no Seraph")        # returns a dictionary containing info about owari no seraph
  anilist.get_anime_with_id(126830)           # returns a dictionary with Code Geass (ID:126830) info
  anilist.get_anime_id("ReZero")              # returns Re:Zero's ID on Anilist
  anilist.print_anime_info("Madoka Magica")   # prints all information regarding the anime Madoka Magica


  anilist.search_anime(genre=['Action', 'Adventure', 'Drama'], year=[2016, 2019], score=range(80, 95))


  anilist.get_character("Emilia")             # returns a dictionary containing the info about Emilia-tan
  anilist.get_character_with_id(13701)        # returns a dictionary with Misaka Mikoto (ID:13701) info
  anilist.get_character_id("Milim")           # returns character Milim's ID on Anilist
  anilist.print_anime_info("Kirito")          # prints all information regarding the character Kirito


  anilist.get_manga("Seraph of the End")      # returns a dictionary containing info about seraph of the end
  anilist.get_manga_with_id(113399)           # returns a dictionary with Tearmoon (ID:113399) info
  anilist.get_manga_id("Tearmoon Empire")     # returns Tearmoon Empire's ID on Anilist (manga)
  anilist.print_manga_info("Tensei Slime")    # prints all information regarding the manga Tensei Slime
  ```

  Note: The feature for manully selecting the top three search results in the terminal is now controlled by a parameter (`manual_select`) in .get functions. For more information, please visit the full documentation. A sample program that has manual select enabled would be:

  ```python
  anilist.get_anime("Owari no Seraph", manual_select=True)
  ```



  AnilistPython was originially designed to support various Discord Bot features in relation to anime, but through out the course of its development, more features became available to use by the general programs other than Discord bots. With that been said, the current version of AnilistPython has further optimized its functions for bot support. From the pre-formatted JSON file upon data retrieval to offline database support (see full documentation), it is now able to be implemented in bots with ease.

  Upcoming AnilistPython Version 0.2.0 will provide functions to generate pre-formated Discord embeds (Anime, Manga, Character embeds) as well as other features that make AnilistPython bot implementations easy to use.

  Sample anime discord bot supported by AnilistPython V0.1.3: [Anime C.C. Discord Bot](https://github.com/ReZeroE/Anime-Discord-Bot)

  Note: Please make sure that parameter `manual_select` has not been set to True in bot implementations. (False by default)


  Lead Developer: Kevin L. (ReZeroE)

  Special thanks to AniList's ApiV2 GraphQL Dev team for making this possible.


pkgId: 37e758f1b5354b3fe12588740750d442019095321b2a22af793d78d3ad16bf93
name: python-AnimeGameRemap
arch: src
version: 4.1.1
epoch: 0
release: 1
summary: A library to help remap the mods installed on a character onto the skins of the character
url: https://github.com/nhok0169/Anime-Game-Remap
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnimeGameRemap-4.1.1-1.src.rpm
checksum_type: sha256
description:
  - Amber
  - AmberCN
  - Arlecchino
  - Barbara
  - BarbaraSummertime
  - Ganyu
  - GanyuTwilight
  - Jean
  - JeanCN
  - JeanSea
  - Keqing
  - KeqingOpulent
  - Mona
  - MonaCN
  - Ningguang
  - NingguangOrchid
  - Raiden
  - Rosaria
  - RosariaCN
  - Shenhe


pkgId: 432e3610e29d2e8d0489279c72eb000bab90f13618f75a064f9fd607bdda23d2
name: python-AnimeScraper
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/togashigreat/AnimeScraper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnimeScraper-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  A Simple library to get Anime and Character information. It scrapes all information from Myanimelist website.


pkgId: 13ee043c9b27f09d1ee75b74b1e5108bcf66371b7b76b02929181a2a8d2d7b01
name: python-AnimeScraper
arch: src
version: 1.0.8
epoch: 0
release: 1
url: https://github.com/togashigreat/AnimeScraper
rpm_license: GPL-V3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnimeScraper-1.0.8-1.src.rpm
checksum_type: sha256
summary:
  A Simple library to get Anime and Character information. It scrapes all information from Myanimelist website.

description:
  <div align="center">



  ![AnimeScraper Logo](./docs/assets/icon.svg)


  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/AnimeScraper)


  **AnimeScraper** is an Open Source Python library designed for scraping and parsing anime-related data from MyAnimeList. With support for asynchronous requests, it allows you to fetch detailed information about anime, characters, and more efficiently.

  </div>

  > [!NOTE]
  >
  > Feel free to make any suggestion : )
  >
  > New Features are coming soon....📜




  - Fetch detailed anime information
  - Retrieve character details
  - Asynchronous Fast data retrieval
  - Asynchronous caching
  - Easy-to-use API
  - Fully typed and documented
  - Supports Synchronous as well



  You can install AnimeScraper using pip:

  ```bash
  pip install animescraper
  ```






  **Searching and Fetching Anime**

  ```python
  from AnimeScraper import SyncKunYu

  scraper = SyncKunYu()
  anime = scraper.search_anime("Chuunibyo demo koi ga shita")

  print(anime.title)
  print(anime.stats.rank)

  ```
  **Searching and fetching Character**

  ```python
  from AnimeScraper import SyncKunYu

  scraper = SyncKunYu()
  character = scraper.search_character("Takanashi Rikka")

  print(character.about)
  print(character.description)
  ```





  **Searching Anime**

  ```python
  import asyncio
  from AnimeScraper import KunYu

  async def main():
      scraper = KunYu()
      anime = await scraper.search_anime("violet evergarden")  # Violet Evergarden
      print(anime.title)
      print(anime.synopsis)
      print(anime.characters[0].name)

  asyncio.run(main())
  ```


  **Searching Character**

  ```python
  import asyncio
  from AnimeScraper import KunYu

  async def main():
      scraper = KunYu()
      
      character = await scraper.search_character("Killua Zoldyck")
      print(character.name)
      print(character.url)

  asyncio.run(main())
  ```


  **Fetching Anime details**

  ```python
  import asyncio
  from AnimeScraper import KunYu

  async def main():
      
      async with KunYu() as scraper:
          anime = await scraper.get_anime("32281")  # Fullmetal Alchemist: Brotherhood
          print(anime.stats.score)
          print(anime.characters[0].name)

  asyncio.run(main())

  ```



  Detailed documentation is available. [Check out the Documentation](https://animescraper.readthedocs.io/en/latest/)



  - `KunYu`: Main interface for scraping anime and character data
  - `Anime`: Detailed anime information model
  - `Character`: Comprehensive character details model
  - Asynchronous scraping with `aiohttp`




  - Python 3.10+
  - aiohttp
  - httpx



  ```
  AnimeScraper/
  │
  ├── AnimeScraper/
  │   ├── Scraper.py       # Main scraping interface
  │   ├── _model.py        # Data models
  │   ├── malscraper.py    # HTTP connection handler
  │   └── _parse_anime_data.py  # HTML parsing utilities
  │
  ├── docs/                # Sphinx documentation
  ├── tests/               # Unit tests
  └── pyproject.toml       # Project configuration
  ```


  Distributed under the GPL-V3.0 License. See [LICENSE](./LICENSE.md) for more information.



  [Facebook](https://facebook.com/KiyotakaO.O)
  [Telegram](t.me/togayuuta)


pkgId: bd45bd1b17895007a817708a02734372ca4c537cb3b330635cfd77d197517c35
name: python-AnisoCADO
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Generate off-axis SCAO PSFs for the ELT
url: https://anisocado.readthedocs.io/en/latest/
rpm_license: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnisoCADO-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/AstarVienna/AnisoCADO/actions/workflows/tests.yml/badge.svg)](https://github.com/AstarVienna/AnisoCADO/actions/workflows/tests.yml)
  [![Documentation Status](https://readthedocs.org/projects/anisocado/badge/?version=latest)](https://anisocado.readthedocs.io/en/latest/?badge=latest)

  [![Build Status](http://github-actions.40ants.com/AstarVienna/AnisoCADO/matrix.svg)](https://github.com/AstarVienna/AnisoCADO)

  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)


  A python package to generate off-axis PSFs for the SCAO mode for the ELT

  Please note: this package is not yet finished yet! The code is fine, but the
  documentation is lacking.



  Apropos documentation. It can be found here:
  [https://anisocado.readthedocs.io/en/latest/index.html](https://anisocado.readthedocs.io/en/latest/index.html)


pkgId: 70066193720833320aedd5ab7e65b5b283a30020c70a248e3b72378e3cdcc7cb
name: python-AnkiChinese
arch: src
version: 1.3.7
epoch: 0
release: 1
summary: An ArchChinese scraper for Anki
url: https://github.com/autoelk/AnkiChinese
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnkiChinese-1.3.7-1.src.rpm
checksum_type: sha256
description:
  Asynchronously scrape the ArchChinese dictionary to generate [Anki](https://apps.ankiweb.net/) flashcards

  <div style="display:flex;">
    <table class="table">
      <tr>
        <td>
          <img src="media/文.gif" alt="Online Flashcard Demo" style="width:400px;">
        </td>
      </tr>
      <tr>
        <td class="caption">Online Flashcard</td>
      </tr>
    </table>

    <table class="table">
      <tr>
        <td>
          <img src="media/文.png" alt="Offline Flashcard Demo" style="width:400px;">
        </td>
      </tr>
      <tr>
        <td class="caption">Offline Flashcard</td>
      </tr>
    </table>
  </div>



      pip install ankichinese
      playwright install



      ankichinese

      -h, --help                          Show help message and exit

      --export, -x {anki, csv, update}    Export mode (default: anki)
                                          anki: Generate new AnkiChinese deck
                                          csv: Generate CSV file
                                          update: Update existing deck
      --input, -i INPUT                   Input file with characters to scrape (default: input.txt)
      --output, -o OUTPUT                 Name of output file (do not include extension)
                                          (default: ankichinese_output)

      --definitions, -def NUM             Number of definitions to scrape per character (default: 5)
      --examples, -ex NUM                 Number of example words to scrape per character (default: 5)

      --requests-at-once, -r NUM          Maximum number of requests at once (default: 10)
      --requests-per-second, -rs NUM      Maximum number of requests per second (default: 5)



  How to create an entirely new Anki deck with the name `ankichinese_output.apkg` in the current directory using custom AnkiChinese styling.

  1. Create `input.txt` with the characters you want to scrape.
  2. Run `ankichinese -x anki`.
  3. Open Anki and import `ankichinese_output.apkg`.

  **Updating is Easy!**
  Just run `ankichinese -x anki` again with new characters in `input.txt` and import the new `ankichinese_output.apkg` file into Anki. Anki will automatically update the existing deck without losing progress.



  1. Create `input.txt` with the characters you want to scrape (can be the same as the existing deck).
  2. Run `ankichinese -x update`.
  3. Choose deck and model of cards to update. AnkiChinese will search for and overwrite any fields with the same names as the following.

  | Field Name | Description |
  | --- | --- |
  | Hanzi | Simplified character (**REQUIRED**) |
  | Traditional | Traditional form |
  | Definition | Meaning of character |
  | Pinyin | Most common pinyin |
  | Pinyin 2 | Other possible pinyin |
  | Words | Example words |
  | Formation | Origin / mnemonic for character |
  | HSK | Hanyu Shuiping Kaoshi level |
  | Audio | Audio file name (**required for audio**) |

  4. Import the new `ankichinese_audio.apkg` file into Anki. This will import the audio files (and create an empty deck that can be deleted)


  - Asynchronous I/O: [Asyncio](https://docs.python.org/3/library/asyncio.html)
  - Limit concurrency: [Aiometer](https://github.com/florimondmanca/aiometer)
  - Web automation and HTML interaction: [Playwright](https://playwright.dev/python/)
  - Anki deck generation: [Genanki](https://github.com/kerrickstaley/genanki)
  - Anki database access: [AnkiPandas](https://github.com/klieret/AnkiPandas)
  - Progress bars: [tqdm](https://github.com/tqdm/tqdm)
  - HTML parsing and scraping: [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/)
  - Data manipulation: [Pandas](https://pandas.pydata.org/)


  Character information: [ArchChinese](https://www.archchinese.com/)

  Stroke order diagrams:
  - Online stroke order diagrams: [Hanzi Writer](https://hanziwriter.org/)
  - Offline stroke order font: [Reinaert Albrecht](https://rtega.be/chmn/index.php?subpage=68)

  Chinese audio:
  - Standard tones: [Yoyo Chinese](https://yoyochinese.com/chinese-learning-tools/Mandarin-Chinese-pronunciation-lesson/pinyin-chart-table)
  - Neutral tones: [Purple Culture](https://www.purpleculture.net/chinese_pinyin_chart/)

  MIT License

  Copyright (c) 2023 Luke Tao

  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: cf8a8619849ce447779acb060cd6f8e3c6ebf1a70f69959db055f379737f371f
name: python-AnkiIn
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Import markdown to Anki
url: https://github.com/clouder0/AnkiIn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnkiIn-0.1.7-1.src.rpm
checksum_type: sha256
description:
  To use this lib, you are not required to sacrifice your note readability for compatibility with Anki.
  Here is a quick example:
  ```markdown
  This is a question.
  This is an answer.
  Single line question.
  Multiple line answer.
  The first line of this block is recognized as the question.
  Multiple line question is <br> possible somehow.
  too hacky maybe.
  markdown rendering is supported.
  - use a list!
      - or something like that.
  Clozes are **easy** to **create** too.
  ```

  You can install by pip:
  ```bash
  pip install AnkiIn
  ```

  To use the lib, you need to install [AnkiConnect](https://github.com/FooSoft/anki-connect) extension.
  Code:`2055492159`
  For detailed installation guide, please visit the [anki-connect repo](https://github.com/FooSoft/anki-connect).

  You can review [AnkiLink](https://github.com/Clouder0/AnkiLink) to understand how this works.
  Also, [AnkiIn Wiki](https://github.com/Clouder0/AnkiIn/wiki) is under construction.
  For more syntax examples, see [tests](https://github.com/Clouder0/AnkiIn/tree/main/tests).

  I'd like to list some applications using AnkiIn here.
  If you want to add yours, please create an issue/pull request.
  - [AnkiLink](https://github.com/Clouder0/AnkiLink)

  - [anki](https://github.com/ankitects/anki)
  - [anki-connect](https://github.com/FooSoft/anki-connect)
  - [genanki](https://github.com/kerrickstaley/genanki)
  - [markdown2](https://github.com/trentm/python-markdown2)

  The source code is licensed under MIT.
  License is available [here](https://github.com/Clouder0/AnkiIn/blob/main/LICENSE).
  [contributors-shield]: https://img.shields.io/github/contributors/Clouder0/AnkiIn.svg
  [contributors-url]: https://github.com/Clouder0/AnkiIn/graphs/contributors
  [forks-shield]: https://img.shields.io/github/forks/Clouder0/AnkiIn.svg
  [forks-url]: https://github.com/Clouder0/AnkiIn/network/members
  [stars-shield]: https://img.shields.io/github/stars/Clouder0/AnkiIn.svg
  [stars-url]: https://github.com/Clouder0/AnkiIn/stargazers
  [issues-shield]: https://img.shields.io/github/issues/Clouder0/AnkiIn.svg
  [issues-url]: https://github.com/Clouder0/AnkiIn/issues
  [license-shield]: https://img.shields.io/github/license/Clouder0/AnkiIn.svg
  [license-url]: https://github.com/Clouder0/AnkiIn/blob/main/LICENSE
  [release-shield]: https://img.shields.io/github/release/Clouder0/AnkiIn.svg
  [release-url]: https://github.com/Clouder0/AnkiIn/releases
  [codefactor-shield]: https://www.codefactor.io/repository/github/clouder0/AnkiIn/badge/main
  [codefactor-url]: https://www.codefactor.io/repository/github/clouder0/AnkiIn/overview/main


pkgId: 65566b2675271c642764ffe35bf1cc32e468b92bb003eb55d4607591ded69fdf
name: python-AnkiTools
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: an Anki *.apkg and collection.anki2 reader and editor
url: https://github.com/patarapolw/AnkiTools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnkiTools-0.3.7-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/patarapolw/AnkiTools.svg?branch=master)](https://travis-ci.org/patarapolw/AnkiTools)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/AnkiTools.svg)](https://pypi.python.org/pypi/AnkiTools/)
  [![PyPI license](https://img.shields.io/pypi/l/AnkiTools.svg)](https://pypi.python.org/pypi/AnkiTools/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/AnkiTools.svg)](https://pypi.python.org/pypi/AnkiTools/)

  An Anki *.apkg and collection.anki2 reader and editor to work with in Python. Also included a module on [AnkiConnect](https://github.com/FooSoft/anki-connect).

  I also created a new sync system called AnkiDirect.

  The \*.apkg format specification can be viewed from [Anki decks collaboration Wiki](http://decks.wikia.com/wiki/Anki_APKG_format_documentation) and [AnkiDroid](https://github.com/ankidroid/Anki-Android/wiki/Database-Structure). In my AnkiDirect, I tried to comply with the format specification as much as possible.



  ```commandline
  pip install AnkiTools
  ```





  ```pydocstring
  >>> from AnkiTools import anki_convert
  >>> anki_convert('Chinese.apkg', out_file='Chinese_anki.xlsx')
  >>> anki_convert('my_workbook.xlsx', out_format='.apkg')
  ```

  The supported formats are `.xlsx`, `.apkg` and `.anki2`.



  You can directly edit the Anki app data in user's Application Data path.

  ```python
  from AnkiTools import AnkiDirect
  import json

  with open('payload.json') as f:
      payload = json.load(f)
  with AnkiDirect() as api
      api.add(payload)
  ```

  Some supported payloads include:

  ```json
  {
    "data": {
      "note_type A": [
        {
          "data": {
            "header A": "a",
            "header B": "b"
          },
          "decks": {
            "Forward": "Test Deck::Forward",
            "Backward": "Test Deck::Backward"
          }
        }
      ]
    },
    "definitions": {
      "note_type A": {
        "templates": [
          {
            "name": "Forward",
            "data": {
              "qfmt": "{{header A}}",
              "afmt": "{{FrontSide}}\r\n\r\n<hr id=answer>\r\n\r\n{{header B}}"
            }
          },
          {
            "name": "Backward",
            "data": {
              "qfmt": "{{header B}}",
              "afmt": "{{FrontSide}}\r\n\r\n<hr id=answer>\r\n\r\n{{header A}}"
            }
          }
        ],
        "css": ".card {\r\n font-family: arial;\r\n font-size: 20px;\r\n text-align: center;\r\n color: black;\r\n background-color: white;\r\n}\r\n"
      }
    }
  }
  ```



  ```pydocstring
  >>> from AnkiTools import AnkiConnect
  >>> AnkiConnect.is_online()
  True
  >>> params = {'actions': [{'action': 'deckNames'}, {'action': 'browse', 'params': {'query': 'deck:current'}}]}
  >>> AnkiConnect.post('multi', params=params)
  {'result': [['Default', 'SpoonFed', 'Chinese Hanzi Freq', 'Chinese Vocab'], None], 'error': None}
  ```
  The actual addable actions and parameters can be viewed from [AnkiConnect](https://foosoft.net/projects/anki-connect/).



  - AnkiDirect two-way sync between Excel file and the Anki app.
  - Specifying metadata (e.g. card distribution, decks) in the Excel file and make it convertible and syncable.
  - Add CRUD to `AnkiDirect` ("update" and "remove" pending.)



  - Testing on other OS's, e.g. Windows XP, Windows 10, Ubuntu Linux. (I tested on Mac.)
  - Manual testing of whether the generated `*.apkg` can be opened without subsequent errors in the Anki app.
  - Writing test cases and testing parameters. The current ones are viewable at [/tests/parameters.json](https://github.com/patarapolw/AnkiTools/blob/master/tests/parameters.json) and [/tests/files/](https://github.com/patarapolw/AnkiTools/tree/master/tests/files).
  - Specifying challenging payloads for AnkiDirect.


pkgId: c094fa8cb4533c6f1638b7572fd0948474462df2cc89cae604dbab1d3816a4bc
name: python-Annotatability
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Interpreting single cell data using annotation-trainability analysis
url: https://github.com/nitzanlab/Annotatability
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Annotatability-0.0.5-1.src.rpm
checksum_type: sha256
description:
  Annotatability, a method to identify meaningful patterns in single-cell genomics data through annotation-trainability analysis, which estimates annotation congruence using a rich but often overlooked signal, namely the training dynamics of a deep neural network.


pkgId: 10088c88552db7165a2a284aa56c607a713ea16ead9ff46b84f60f2f03b9299b
name: python-AnnotationCheckerWithStructure
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: A simple bioinformatics script.
url: https://github.com/Andy-B-123/AnnotationCheckerWithStructure
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnnotationCheckerWithStructure-0.1.6-1.src.rpm
checksum_type: sha256
description:
  Structural databases for protein sequences are invaluable tools for informing the validity of gene predictions from annotations.

  Currently, generating structures for all genes at the level of eukaryotic genomes is computationally challenging.

  Recent advances in transformer representations of amino acid sequences using the ProstT5 ...



  You can install the released version of AnnotationCheckerWithStructure from PyPI:

  ```sh
  pip install AnnotationCheckerWithStructure
  ```

  Usage

  ```AnnotationCheckerWithStructure```


pkgId: 2c07877e57a9a936f199adfaea9c7baa6ca70ee24df8b9e87c7f68ba52d089de
name: python-Annotations2Sub
arch: src
version: 2.21.0
epoch: 0
release: 1
summary: Download and convert Youtube Annotations
url: https://github.com/USED255/Annotations2Sub
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Annotations2Sub-2.21.0-1.src.rpm
checksum_type: sha256
description:
  **因为字幕滤镜的行为和怪癖不断变动, 以及 Web 技术和字幕技术上的巨大差异, 本项目无法正确还原注释的行为**
  **Because of the ever-changing behavior and quirks of subtitle filters, and the vast differences between web and subtitle technologies, this project was unable to correctly restore the behavior of annotations.**
  ```bash
  pip install Annotations2Sub
  ```
  ```help
  usage: Annotations2Sub.py [-h] [-l] [-x 100] [-y 100] [-f Arial ] [-o Folder] [-d]
                            [-i invidious.domain] [-p] [-g] [-s] [-n] [-k] [-u] [-v]
                            [-V]
                            File or videoId [File or videoId ...]
  Download and convert Youtube Annotations
  positional arguments:
    File or videoId       File path or video ID of multiple files to be convert
  optional arguments:
    -h, --help            Show this help message and exit
    -x 100, --transform-resolution-x 100
                          Transform resolution X
    -y 100, --transform-resolution-y 100
                          Transform resolution Y
    -f Arial, --font Arial
                          Specify font
    -d, --download-for-archive
                          Try to download the Annotations file from Internet Archive
    -D, --download-annotations-only
                          Download Annotations only
    -p, --preview-video   Preview video, requires mpv(https://mpv.io/)
    -g, --generate-video  Generate video, requires FFmpeg(https://ffmpeg.org/)
    -i invidious-instances.domain, --invidious-instances invidious-instances.domain
                          Specify invidious instances (https://redirect.invidious.io/)
    -n, --no-overwrite-files
                          Do not overwrite files
    -N, --no-keep-intermediate-files
                          Do not keep intermediate files
    -O directory, --output-directory directory
                          Specify the output directory for the converted file
    -o File, --output File
                          Save to this file, if "-" then output to standard output
    -v, --version         Show version
    -V, --verbose         Show more messages


pkgId: 7165adc28ef1583d2e7197d23f490a33ce36ba05a329d34b7cf49789c1fb0d13
name: python-AnomalyLab
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A Python package for empirical asset pricing analysis.
url: https://pypi.org/project/AnomalyLab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnomalyLab-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Chen Haiwei, Deng Haotian



  This Python package implements various empirical methods from the book *Empirical Asset Pricing: The Cross Section of Stock Returns* by Turan G. Bali, Robert F. Engle, and Scott Murray. The package includes functionality for:

  - Summary statistics
  - Correlation analysis
  - Persistence analysis
  - Portfolio analysis
  - Fama-MacBeth regression (FM regression)

  Additionally, we have added several extra features, such as:

  - Missing value imputation
  - Data normalization
  - Leading and lagging variables
  - Winsorization/truncation
  - Transition matrix calculation



  The package can be installed via:

  ```bash
  pip install anomalylab
  ```


pkgId: ea9361dd1172ff56a90dd412e7ec6d13a55c3dcb3ba307bf58c7b0a6f66555de
name: python-Antares-Launcher
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: Antares_Launcher to run Antares on a remote linux machine
url: https://github.com/AntaresSimulatorTeam/antares-launcher.git
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Antares-Launcher-1.4.3-1.src.rpm
checksum_type: sha256
description:
  This program is intended to allow the user to send a list of Antares simulations to
  a remote Linux machine that can run them using *SLURM Workload Manager*.

  Currently, this program:

  - Is configured to work with Antares studies from version 7.0 through 8.5
    (the configuration can be changed in a YAML file).
  - needs a remote UNIX server that uses *SLURM Workload Manager*.

  The main workflow diagram is as follows:

  ![Antares Study Launcher](https://raw.githubusercontent.com/AntaresSimulatorTeam/antares-launcher/main/doc/source/schema/antares_flow_chart_AS-FINAL-withbranch-wait.png)



  See [`setup.py`](https://github.com/AntaresSimulatorTeam/antares-launcher/blob/main/setup.py)

  Minimum version : python 3.8



  The following libraries are required to run the application in a production (or staging) environment:

  - paramiko
  - PyYAML
  - tinydb
  - tqdm

  To install this library on production, you can run:

  ```shell
  pip install Antares-Launcher
  ```



  To start developing, you can clone the repository from GitHub and create a Python virtualenv:

  ```shell
  cd ~/workspace/
  git clone https://github.com/AntaresSimulatorTeam/antares-launcher.git
  cd ~/workspace/antares-launcher/
  python3 -m venv venv
  source venv/bin/activate
  ```

  To run the unit tests, you need to install:

  - pytest
  - pytest-cov
  - pytest-xdist

  To install this library in development mode for testing, you can run:

  ```shell
  pip install -e .[test]
  ```

  Additional dependencies could also be used for development, for instance:

  - black
  - check-manifest
  - isort
  - mypy



  In this project, we use Sphinx to generate the documentation.

  Extra requirements are:

  - m2r
  - recommonmark
  - sphinx
  - sphinx_rtd_theme





  In order to generate the binary file, execute the following command:

  ```
  pyinstaller --additional-hooks-dir=antareslauncher/hooks/ -F antareslauncher/main_launcher.py -n Antares_Launcher
  ```

  In order to generate the binary file of the light version of the launcher (reduced set of options), execute the
  following command:

  ```
  pyinstaller --additional-hooks-dir=antareslauncher/hooks/ -F antareslauncher/main_launcher_light.py -n Antares_Launcher_Light
  ```

  The generated file will be inside the dist directory. Note that pyinstaller does not enable the cross-compilation: e
  binary file generated on windows can only be expected with the windows OS





  **Antares Launcher** can be used by running the executable file

  By default, the program will:

  - look for a configuration file necessary for the connection
  named *ssh_config.json*.
  If no value is given, it will look for it in default location with this order:
    - 1st: current working directory
    - 2nd: $HOME/antares_launcher_settings/ssh_config.json
    - 3rd: default configuration (json file embedded in the data directory if present).

  A default *ssh_config.json* file can be found in this
  repository in the `./data` directory of the project

  - look for an rsa-private ssh-key to access to the remote server.
  The path of the key is specified in the `ssh_config.json` file

  - look for a directory containing
    the Antares studies to be run on the remote machine
    named *STUDIES-IN*.

  - put the results in the directory named
    *FINISHED*

  - create a directory *LOGS* that contains the logs of the programs
    and several directories containing the three log files specific of each simulation.
    Currently **antares_launcher** uses a specific configuration attached to the specific setting of
    `data/launchAntares-${SCRIPT-VERSION}.sh`



  ```
  Antares_Launcher --help
  ```

  will show how to use the program.



  In order to submit new jobs to the *SLURM* queue manager,
  **Antares_Launcher** launches a bash-SLURM script the name of the script is set in `data/configuration.yaml`.
  If Antares_Launcher fails to find this script
  an exception will be raised and the execution will stop.

  The specification of the script can be found in the class
  `SlurmScriptFeatures` in the module `antareslauncher.slurm_script_features.py`.
  See [Deploy Antares Launcher](#deploy-antares-launcher) for specific values.



  Since the addition of the Makefile to the project, one can now easily set a virtual environment, install requirements,
  generate binary file, run tests, generate the doc and deploy it...

  At the root of the directory, all the available commands can be seen with typing: make

  ![Antares Study Launcher](https://raw.githubusercontent.com/AntaresSimulatorTeam/antares-launcher/main/doc/source/schema/make_example.png)

  If for example, you would like to run the test, a simple ``make test`` will do the trick

  ![Antares Study Launcher](https://raw.githubusercontent.com/AntaresSimulatorTeam/antares-launcher/main/doc/source/schema/make_test_example.png)



  Run unit tests:

  ```shell
  pytest -v tests/
  ```

  Run unit tests with code coverage:

  ```shell
  pytest --cov=antareslauncher --cov-report=term-missing --cov-report=html --cov-branch tests/
  open htmlcov/index.html
  ```





  In order to be able to accept jobs from Antares_Launcher, the remote machine needs to be ready:
  the binaries and script expected by **Antares_Launcher** need to be installed and
  the required ssh-public-keys need to be added to the `authorizedkeys` file
  of the account of the remote server.



  - `launchAntares-${SCRIPT-VERSION}.sh` should be copied to the remove server
    and ist path should be set in `data/configuration.yaml`

  - Install the Antares solver binary `antares-x.x-solver` on the remote server.
    set its installation path in `launchAntares-${SCRIPT-VERSION}.sh`

  - The R Xpansion script, `data/XpansionArgsRun.R`,
    has to be copied to the remote server and
    its path should be set in `launchAntares-${SCRIPT-VERSION}.sh`.



  The users currently copy the executable every time they need to use it.
  This is not practical, an alternative should be developed.



  In order to correctly install or update packages to be used on the remote server
  the *R*repositories and installation-destination need to be set.

  The `launchAntares-${SCRIPT-VERSION}.sh` set the variable where the *R*libraries are installed runtime,
  no need to create a `.Renviron` file.


pkgId: f69e3aee7579d793e8d57e3f2f52453c6ea2efec746a47a295618dfa9b4ab194
name: python-AntaresFabricFramework-INTERNAL
arch: src
version: 1.1.41
epoch: 0
release: 1
summary: Microsoft Fabric data ingestion accelerator
url: https://antares.solutions/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AntaresFabricFramework-INTERNAL-1.1.41-1.src.rpm
checksum_type: sha256
description:
  The `AntaresFabricFramework` is an accelerator for Microsoft Fabric data ingestion, validation and transformation. It uses a configuration file to describe each source and destination and includes details for data validation and preprocessing.



  - [Installation](#installation)
  - [Usage](#usage)
  - [Features](#features)
  - [Contributing](#contributing)
  - [License](#license)
  - [Contact Information](#contact-information)


  The following options are available to install the library into a Fabric environment:

  1. <b>PyPi (Recommended):</b>
  To use the latest base version available in the publish repository (PyPi), open fabric and edit or create an environment. Open the environment, click public libraries, click Add from PyPi, in the library text box type AntaresFabricFrameworkBase, then click publish.

  2. <b>Custom Library:</b>
  The dist folder contains the wheel (.whl) file that can be uploaded into the Fabric environment as a custom library. To do that, open fabric and edit or create an environment. Open the environment, click custom libraries, then click Upload and upload the .whl file. Click Publish.
  If changes are required to the base code, follow these steps to deploy the custom library:
  - Fork the repository
  - Create a new branch
  - Edit the code
  - Build the wheel file (eg. `py -m build`)
  - Upload as per above

  To install the base notebooks required for the framework (Constants_py, PreProcessingUtils_py and OrchestrateIngestion), follow these steps:

  1. Clone this repo to the destination (eg. customers devops)
  2. Create a new branch
  3. Create the control workspace in Fabric
  4. Connect the new branch in the repo to the workspace and in the git folder section type 'FabricArtifacts' to point to that folder in the repo (this is where the notebooks and lakehouse are stored).

  After it syncs, the control workspace should contain a control lakehouse and the 3 notebooks as listed earlier.




  In order to run the framework, there are a few key dependencies that need to be in place:

  1. <b>Ingestion Configuration file (or table):</b>
  The ingestion configuration is a json file that contains information about the source of the data, how we want to save the data, and some optional parameters we can use during the ingestion process.
  There is a sample file in the repository [ingestion_configuration.json](SupportingFiles/ingestion_configuration.json) containing all of the attributes used during the data ingestion.
  After the initial execution of the framework, the file will be saved into a fabric table and read from the table each time after that. The table can be edited via SQL commands in a notebook or if the table is deleted, the json file will become the initial source again.
  The ingestgion configuration file and table are both located in the Control Lakehouse.

  2. <b>Keyvault:</b> is used for storing all connection and credential details for all sources (except for Fabric tables and files - these don't require additional keyvault connection details.)
  The Keyvault connection details will need to be included in the aformentioned ingestion configuration file.

  3. <b>Constants notebook:</b> A Constants_py notebook is required to sit in the Control lakehouse and contains global constants to be used during the ingestion. These global constants are generally set once and used throughout the framework.
  Global constants include the names of each stage in the medallion architecture and the Azure Log Monitor details. There is a sample Constants_py notebook in the repository.

  4. <b>Azure Log Monitor (OPTIONAL):</b> If the Azure Monitor Log service is setup, the framework can push logs from anywhere in the preprocessing stage and at predefined stages in the ingestion process.
  The logging is turned on via the Constants notebook, by setting the `LOGGING_LEVEL` to either `INFO` or `DEBUG`. `NONE` will turn off the logging. INFO will provide high level processing information at each major step in the ingestion. DEBUG will provide more detailed logs at higher intervals.
  The schema of the log table that is required to be setup is can also be found in the repository under [AuditLogEntity.json](SupportingFiles/AuditLogEntity.json)

  5. <b>PreProcessing notebook (OPTIONAL):</b> Prior to the ingestion into the first (RAW) stage, a preprocessing function can be run to modify the data coming from the source. Typically, this is used to clean up or validate manually input .csv files or to merge multiple files into a single table.
  This is optional and does not need to exist for the ingestion to work. To create a preprocessing function use the following function definition in the PreProcessing_py notebook:

      def preProcess(source):

      source - will be the ingestion configuration source record for a single sourceID.

  6. <b>Orchestration Notebook:</b> The main notebook that is used to execute the ingestion process code. This note book can also contain a parameters cell that can be used to capture additiona parameters (in the form of global constants).
  For example, if the notebook is executed via a data pipeline in Fabric, the Data Pipeline Run ID can be passed in as a parameter and tracked via the logging module so users can trace back any errors to a specific pipeline.

  To run the ingestion framework, the library can be imported:

      from FabricFramework.FabricFramework import *

  then instantiated as:

      ff = FabricFramework(<location of ingestion_configuration.json>, <location of ingestion configuration table>, <constants>, <pre processing function>)

  The framework ingestion process can be executed as follows:

      ff.runIngestion() - this will run through the entire ingestion configuration (Every source)

  You can also provide 3 parameters for more granual control over that is run as part of the ingestion:

      ff.runIngestion(layer=[LAKEHOUSE_RAW_STAGE_NAME, LAKEHOUSE_TRUSTED_STAGE_NAME], system_code=['Test'], sourceID=[1, 3, 5])

  <b>layer</b> - determines the stage that should be run (eg. RAW and TRUSTED, or just RAW or just TRUSTED). The names of each stage is determines by the constants (eg. LAKEHOUSE_RAW_STAGE_NAME) in the constants notebook

  <b>system_code</b> - determines which specific system code(s) should be run as part of this execution (this can be a list of system codes)

  <b>sourceID</b> - determines which sourceID's should be run on this run (if the ingestion is turned off in the ingestion configuration, the systemID will still be ignored)







  Guidelines for contributing to the project:
  1. Fork the repository
  2. Create a new branch (`git checkout -b feature-branch`)
  3. Commit your changes (`git commit -m 'Add some feature'`)
  4. Push to the branch (`git push origin feature-branch`)
  5. Open a pull request


  This project is licensed under the MIT License - see the [LICENSE](LICENSE.txt) file for details.


  For any questions, please contact [martonm@antaressolutions.com.au](mailto:martonm@antaressolutions.com.au).


pkgId: a69e75c9c26fa8a9e907fe1d32c17cf97ce11cfdeb1045961c06f08de6902b8b
name: python-Antiland
arch: src
version: 0.99.2
epoch: 0
release: 1
summary: A package to create bots on Antiland.com
url: https://github.com/TheUnsocialEngineer/Anti.py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Antiland-0.99.2-1.src.rpm
checksum_type: sha256
description:
  Antiland.py is a python package to turn any antiland user into a fully functioning
  bot account similar to discord.py

  ![GitHub](https://img.shields.io/github/license/TheUnsocialEngineer/Anti.py)
  ![PyPI - Version](https://img.shields.io/pypi/v/Antiland?labelColor=black&color=blue&link=https%3A%2F%2Fpypi.org%2Fproject%2FAntiland.py%2F)
  ![PyPI - Downloads](https://img.shields.io/pypi/dw/Antiland)



  For more examples and documentation read the [Docs](https://antiland.readthedocs.io/en/latest/)




  - Log in to an account
  - send messages/images/videos
  - change profile settings
  - Automate tedious tasks e.g banning/blocking
  - It's python so go nuts





  Antiland requires Python3 to run.

  to install run pip3 install Antiland



  Before you start you need to get the session token which will allow you to log into the account and the dialogue id of the chat you want to listen for commands in

  To get the token and you use developer consoles network tab to look at any outgoing connection such as a sending a message, the session token is stored in the json payload e.g

  ![App Screenshot](https://i.imgur.com/ZkVi80e.png)


  Below is an example of a bot that prints every message it receives

  ```python
  import Antiland
  session_token = ""
  dialogue = ""
  prefix = "!"

  bot = Antiland.Bot(prefix, dialogue, session_token)

  @bot.event
  async def on_message(message):
      
      print(f"Received message from {message.sender_name}: {message.text}")

  bot.start(session_token)
  ```


  Below is a very basic example for logging in and registering a hello command
  which when ran will send hello world into the chat and register a debug command
  which will send a message to the channel of your choice

  ```python
  from Antiland.ext import commands

  session_token = ""
  dialogue = ""
  prefix = "!"

  bot = commands.Bot(prefix, dialogue, session_token)

  @bot.command
  async def say_hello():
      room = await bot.get_dialogue(dialogue, session_token)
      await room.send_message("hello world", session_token, dialogue)

  @bot.command
  async def debug():
      room =await bot.get_dialogue("enter dialogue id here", session_token)
      await room.send_message("BOT IS WORKING", session_token, dialogue)


  bot.start(session_token)
  ````


pkgId: c2938ba485a52c9a45f10d1d0403bbbafad2e570f5c08e84d139eefeea85d091
name: python-Antonina1
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: 安冬妮娜助手1.0.6版本，用于显示具有安冬妮娜图片的提示弹窗，采用网页链接形式避开路径问题
url: https://github.com/Jinqk/Antonina.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Antonina1-1.0.6-1.src.rpm
checksum_type: sha256
description:
  This repo exists to provide [an example setup.py] file, that can be used
  to bootstrap your next Python project. It includes some advanced
  patterns and best practices for `setup.py`, as well as some
  commentedâ€“out niceâ€“toâ€“haves.
  For example, this `setup.py` provides a `$ python setup.py upload`
  command, which creates a *universal wheel* (and *sdist*) and uploads
  your package to [PyPi] using [Twine], without the need for an annoying
  `setup.cfg` file. It also creates/uploads a new git tag, automatically.
  In short, `setup.py` files can be daunting to approach, when first
  starting out â€” even Guido has been heard saying, "everyone cargo cults
  thems". It's true â€” so, I want this repo to be the best place to
  copyâ€“paste from :)
  [Check out the example!][an example setup.py]


pkgId: 3c139f69fa75827fd295cc5ff3e3fa85518fec21102dc75452c9cd854a68b29e
name: python-AnyBlok
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Anyblok is a dynamic injection blok framework
url: https://doc.anyblok.org/en/1.4.0/
rpm_license: MPL2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnyBlok-2.2.0-1.src.rpm
checksum_type: sha256
description:
  AnyBlok is a Python framework allowing to create highly dynamic and modular
  applications on top of SQLAlchemy.
  AnyBlok is released under the terms of the `Mozilla Public License`.
  AnyBlok is hosted on `github <https://github.com>`_ - the main project
  page is at https://github.com/anyblok/anyblok or
  http://code.anyblok.org. source code is tracked here
  using `git <https://git-scm.com>`_.
  Releases and project status are available on Pypi at
  https://pypi.python.org/pypi/anyblok.
  The most recent published version of the documentation should be at
  https://doc.anyblok.org.
  There is a tutorial to teach you how to develop applications with AnyBlok at
  https://anyblok.gitbooks.io/anyblok-book/content/en/


pkgId: 426126925913f91e5e886c9a4bde9742976b0ef4a4044a314aa606e1079c4970
name: python-AnyQt
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: PyQt5/PyQt6 compatibility layer.
url: https://github.com/ales-erjavec/anyqt
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnyQt-0.2.0-1.src.rpm
checksum_type: sha256
description:
  PyQt/PySide compatibility layer.
  Features:
  * At the top level AnyQt exports a Qt5 compatible module namespace along with
    some minimal renames to better support portability between different
    versions
  * Which Qt api/backend is chosen can be controlled by a QT_API env variable
  * The api can be chosen/forced programmatically (as long as no
    PyQt4/PyQt5/PySide/PySide2 was already imported)
  * provides an optional compatibility import hook, that denys imports from
    conflicting Qt api, or intercepts and fakes a Qt4 api imports, to use a Qt5
    compatible API (some monkey patching is involved).
  The documentation is hosted at https://anyqt.readthedocs.io/en/stable/


pkgId: 17f2c941a1c9a3bbed752e37113359b7f8c92fc9d8b733cd24ea55dafb32a643
name: python-AnyRobot
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: This is a data service module that solves test data problems.
url: https://mp.weixin.qq.com/s/v6FS96ifCoMvp_rwrhzhKw
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AnyRobot-1.5.4-1.src.rpm
checksum_type: sha256
description:
  This is a data service module that solves test data problems. You can use it.

  [Contact author](https://pypi.org/user/Evan.hu/)


pkgId: ff4f3f29f4cfaf0c0f816dbf53714fbc27ba2a3ff4a73752f903fac94d97bb11
name: python-AoE2ScenarioParser
arch: src
version: 0.2.12
epoch: 0
release: 1
url: https://github.com/KSneijders/AoE2ScenarioParser
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AoE2ScenarioParser-0.2.12-1.src.rpm
checksum_type: sha256
summary:
  This is a project for editing parts of an 'aoe2scenario' file from Age of Empires 2 Definitive Edition

description:
  `AoE2ScenarioParser` is a [Python] library that allows you to edit `aoe2scenario` files from **every** version of
   **Age of Empires 2 Definitive Edition**.

  [Python]: https://www.python.org/





  Documentation for installation, usage, examples, cheatsheets and API docs can be found on **[GitHub Pages]**.

  [GitHub Pages]: https://ksneijders.github.io/AoE2ScenarioParser/



  - **[Installing]** → A quick guide on how to install `AoE2ScenarioParser`
  - **[Hello World Example]** → Step-by-step guide to get you going
  - **[Discord Server]** → For questions about `AoE2ScenarioParser`, [Python] or scenarios in general.
  - **[API Docs]** → Technical documentation for all exposed functions & classes

  [Installing]: https://ksneijders.github.io/AoE2ScenarioParser/installation/
  [Hello World Example]: https://ksneijders.github.io/AoE2ScenarioParser/hello_world/
  [Discord Server]: https://discord.gg/DRUtmugXT3
  [API Docs]: https://ksneijders.github.io/AoE2ScenarioParser/api_docs/aoe2_scenario/



  If you have any questions regarding `AoE2ScenarioParser`? [Join the discord]!

  [Join the discord]: https://discord.gg/DRUtmugXT3



  **Every Single Scenario Version from Age of Empires 2 Definitive Edition is SUPPORTED!**

  > Support: `1.36` _Version at Release (November 14th, 2019)_ → `1.54` _Current Version (Since: October 14, 2024)_

  Every single version of **Age of Empires 2 Definitive Edition** is supported!
  If a new version of **Age of Empires 2 Definitive Edition** just released it can take a bit for it to be able to be read.
  Check the [Discord Server] for more up-to-date information if this is the case.

  If you find a scenario which can be opened by the game itself, but results in an error when using `AoE2ScenarioParser`,
  please report it as an issue or in the **#bug‑reports** channel in the [Discord Server].

  > ⚠️ To view the full-blown support table previously shown in this README, visit: [support].

  [support]: https://github.com/KSneijders/AoE2ScenarioParser/blob/master/resources/md/support.md



  Every related change to the library is documented and can be found in the [CHANGELOG].

  [changelog]: https://github.com/KSneijders/AoE2ScenarioParser/blob/dev/CHANGELOG.md



  `AoE2ScenarioParser` allows you to edit **anything** inside a scenario.
  For general usability "managers" have been created to make working with the files easier.
  These managers allow you to quickly change aspects of units, triggers, the map, player data and more!

  Below is a simplified overview of some of the features:

  |            | Inspect           | Add | Edit | Remove |
  |------------|-------------------|-----|------|--------|
  | Triggers   | ✔️                | ✔️  | ✔️   | ✔️     |
  | Conditions | ✔️                | ✔️  | ✔️   | ✔️     |
  | Effects    | ✔️                | ✔️  | ✔️   | ✔️     |
  | Units      | ✔️                | ✔️  | ✔️   | ✔️     |
  | Map        | n/a *<sup>1</sup> | ✔️  | ✔️   | ✔️     |
  | Players    | n/a *<sup>1</sup> | ✔️* | ✔️   | ✔️*    |
  | Messages   | n/a               | ✔️  | ✔️   | ✔️     |

  *: You can disable or enable players like in the in-game editor (min 1, max 8).
  *<sup>1</sup>: There's no specific inspection function. Though, they can still be printed with clean formatting.



  - [Kerwin Sneijders](https://github.com/KSneijders) (Main Author)
  - [Alian713](https://github.com/Divy1211) (Dataset Wizard)



  MIT License: Please see the [LICENSE file].

  [license file]: https://github.com/KSneijders/AoE2ScenarioParser/blob/dev/LICENSE


pkgId: 272bcde1a786519594f4166d3d2d542b57899d84c5be97ca94bd137abcf60551
name: python-AoE2ScenarioRms
arch: src
version: 0.2.21
epoch: 0
release: 1
summary: Add replay-ability to scenarios through random resource placement using triggers & XS!
url: https://github.com/KSneijders/AoE2ScenarioRms
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AoE2ScenarioRms-0.2.21-1.src.rpm
checksum_type: sha256
description:
  **Suggestions are always welcome!**

  - Kerwin Sneijders (Main Author)

  MIT License: Please see the [LICENSE file].
  [license file]: https://github.com/KSneijders/AoE2ScenarioRms/blob/main/LICENSE


pkgId: c18187a58c91fddd394f4ef4676c5855e531ded715f6146f9c565332fb26b93a
name: python-ApReusable
arch: src
version: 1.3.3
epoch: 0
release: 1
url: https://pypi.org/project/ApReusable/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ApReusable-1.3.3-1.src.rpm
checksum_type: sha256
summary:
  AP-Reusable-Package is a versatile and powerful Python package that contains many useful functions and classes for a wide range of projects.

description:
  AP-Reusable-Package is a versatile and powerful Python package that contains many useful functions and classes for a wide range of projects. Some of the key features of this package include:

  <li><b>Get Client IP:</b> A function that retrieves the IP address of the client making a request to a server. This can be useful for logging and security purposes.</li>
  <br>
  <li><b>Get Client Host:</b> A function that retrieves the hostname of the client making a request to a server. This can be useful for identifying the origin of a request.</li>
  <br>
  <li><b>Fernet Encryption/Decryption:</b> A set of functions that provide easy-to-use encryption and decryption functionality using the Fernet encryption algorithm. This can be useful for protecting sensitive data in transit or at rest.</li>
  <br>
  <li><b>Extended Enumerator:</b> A class that extends the built-in Python Enumerator class, providing additional functionality and convenience methods. This can be useful for working with large sets of data.</li>
  <br>
  <li><b>Custom Renderer for Rest Framework:</b> A custom renderer that provides additional flexibility and customization options for rendering RESTful API responses. This can be useful for building complex APIs that require a high degree of control over the output format.</li>

  Overall, AP-Reusable-Package is a valuable resource for developers working on a wide range of projects. Its many features and convenient classes make it easy to build robust and secure applications quickly and efficiently.



  Options are major, minor, patch

  ```
  bumpversion [option] --allow-dirty
  ```


pkgId: 9a5763561ae6ed5f366c2924009836160b1b08abdf362b3797fcb61e89405b0d
name: python-Apache-TrafficControl
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Python API Client for Traffic Control
url: https://trafficcontrol.apache.org/
rpm_license: http://www.apache.org/licenses/LICENSE-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Apache-TrafficControl-3.1.0-1.src.rpm
checksum_type: sha256
description:
  The official installation method is to use ``pip`` to install directly from from GitHub.
  	pip install git+https://github.com/apache/trafficcontrol.git#"egg=trafficops&subdirectory=traffic_control/clients/python"


pkgId: feefed622481b3fecb5a9f45d774b52d5326f1173aa7446baf73d684c5724882
name: python-ApiNyaEr
arch: src
version: 1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/ApiNyaEr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ApiNyaEr-1.1-1.src.rpm
checksum_type: sha256
description:
  Welcome to the **ErApi**! This library allows you to easily interact with the API using both **synchronous** and **asynchronous** options.
  - **Sync**: `from ApiNyaEr.sync import apinya`
  - **Async**: `from ApiNyaEr import apinya`
  Below, we’ll cover each function, providing examples and expected results so you can get started quickly! Let’s dive in 🚀

  | Function           | Status |
  |--------------------|--------|
  | [1. Ambil Doa](#1-ambil-doa) | ✅
  | [2. Carbon](#2-carbon) | ✅
  | [3. Cat](#3-cat) | ❌
  | [4. Cohere](#4-cohere) | ✅
  | [5. Dog](#5-dog) | ❌
  | [6. Github Search](#6-github-search) | ✅
  | [7. Hug](#7-hug) | ✅


  **Description**:
  Mengambil data doa dari API ItzPire berdasarkan nama doa.
  **Args:**
    - **nama_doa (str)**: Nama doa yang ingin diambil.
  **Returns:**
    - **str**: Teks doa yang diformat dengan rapi termasuk doa, ayat, latin, dan artinya.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.ambil_doa(nama_doa='Tidur')
  print(result)
  ```

  ```text
  Doa sebelum tidur
  Ayat: بِسْمِكَ االلّٰهُمَّ اَحْيَا وَبِاسْمِكَ اَمُوْتُ
  Latin: Bismikallaahumma ahyaa wa ammuut
  Artinya: Dengan menyebut nama Allah, aku hidup dan aku mati
  ```

  **Description**:
  Generates a code snippet image using the Carbon API, saves it to the downloads folder, uploads it, and returns the URL of the uploaded image.
  **Args:**
    - **query (str)**: The code snippet to be rendered as an image.
  **Returns:**
    - **FilePath**: The file path of the saved image.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.carbon(query='Tidur')
  print(result)
  ```

  ```text
  /home/runner/work/ApiNyaEr/ApiNyaEr/downloads/carbon_ixlijjhX.png
  ```

  **Description**:
  Fetches a random cat image URL.
  **Returns:**
    - **str or None**: The URL of a random cat image if available; None if no response is received.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.cat()
  print(result)
  ```

  ```text
  'cat'
  ```

  **Description**:
  Mengambil respons dari API AI ItzPire berdasarkan pertanyaan yang diberikan.
  **Args:**
    - **pertanyaan (str)**: Teks pertanyaan yang akan dikirim ke AI.
  **Returns:**
    - **str**: Respons yang dihasilkan oleh AI.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.cohere(pertanyaan='Tidur')
  print(result)
  ```

  ```json
  {
      "error": "Request failed with status code 429"
  }
  ```

  **Description**:
  Fetches a random dog image URL.
  **Returns:**
    - **str or None**: The URL of a random dog image if available; None if no response is received.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.dog()
  print(result)
  ```

  ```text
  'dog'
  ```

  **Description**:
  Searches GitHub for various types of content.
  **Args:**
    - **query (str)**: The search query.
    - **search_type (str, optional)**: The type of search. Can be one of:
      - "repositories"
      - "users"
      - "organizations"
      - "issues"
      - "pull_requests"
      - "commits"
      - "topics"
  **Description**:
  Defaults to "repositories". max_results (int, optional): The maximum number of results to return. Defaults to 3.
  **Returns:**
    - **list**: A list of search results or an error message.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.github_search(query='Tidur', search_type='repositories', max_results=3)
  print(result)
  ```

  ```json
  [
      {
          "name": "rs-bed-covid-indo-api",
          "full_name": "satyawikananda/rs-bed-covid-indo-api",
          "description": "API ketersediaan rumah sakit dan tempat tidur rumah sakit untuk pasien covid-19 ataupun non-covid yang berada di Indonesia",
          "url": "https://github.com/satyawikananda/rs-bed-covid-indo-api",
          "language": "TypeScript",
          "stargazers_count": 112,
          "forks_count": 25
      },
      {
          "name": "bed-covid-rs-indo",
          "full_name": "hendraaagil/bed-covid-rs-indo",
          "description": "Website yang memberikan informasi terkait ketersediaan rumah sakit dan tempat tidur rumah sakit untuk pasien covid-19 ataupun non-covid di Indonesia.",
          "url": "https://github.com/hendraaagil/bed-covid-rs-indo",
          "language": "JavaScript",
          "stargazers_count": 23,
          "forks_count": 3
      },
      {
          "name": "hobikoding.github.io",
          "full_name": "hobikoding/hobikoding.github.io",
          "description": ":rose: Hobikoding - Mari ngoding sambil tidur",
          "url": "https://github.com/hobikoding/hobikoding.github.io",
          "language": "Makefile",
          "stargazers_count": 3,
          "forks_count": 0
      }
  ]
  ```

  **Description**:
  Fetches a specified number hug gif from the Nekos.Best API.
  **Args:**
    - **amount (int)**: The number of neko images to fetch. Defaults to 1.
  **Returns:**
    - **list**: A list of dictionaries containing information about each fetched neko image or GIF.
      Each dictionary typically includes:
      - anime_name (str): The name of the anime.
      - url (str): The URL of the GIF.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.hug(amount=1)
  print(result)
  ```

  ```json
  [
      {
          "anime_name": "Hibike! Euphonium",
          "url": "https://nekos.best/api/v2/hug/f8702ca1-e7d8-44e1-a2aa-221f10749498.gif"
      }
  ]
  ```
  This Project is Licensed under [MIT License](https://github.com/ErRickow/ApiNyaEr/blob/main/LICENSE)


pkgId: b1f4ad9d58129beb6b3cd8d5c73dee9ad8f45a70be12ba519a26895b38601cb3
name: python-ApiNyaEr
arch: src
version: 1.3
epoch: 0
release: 1
summary: An Api Compile for another source
url: https://pypi.org/project/ApiNyaEr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ApiNyaEr-1.3-1.src.rpm
checksum_type: sha256
description:
  Welcome to the **ErApi**! This library allows you to easily interact with the API using both **synchronous** and **asynchronous** options.
  - **Sync**: `from ApiNyaEr.sync import apinya`
  - **Async**: `from ApiNyaEr import apinya`
  Below, we’ll cover each function, providing examples and expected results so you can get started quickly! Let’s dive in 🚀

  | Function           | Status |
  |--------------------|--------|
  | [1. Ai](#1-ai) | ✅
  | [2. Bing Image](#2-bing-image) | ✅
  | [3. Blackbox](#3-blackbox) | ✅
  | [4. Carbon](#4-carbon) | ✅
  | [5. Cat](#5-cat) | ✅
  | [6. Dare](#6-dare) | ✅
  | [7. Doa](#7-doa) | ✅
  | [8. Dog](#8-dog) | ✅
  | [9. Fakta Unik](#9-fakta-unik) | ✅
  | [10. Gemini](#10-gemini) | ✅
  | [11. Github Search](#11-github-search) | ✅
  | [12. Hug](#12-hug) | ✅
  | [13. Kapan Libur](#13-kapan-libur) | ✅
  | [14. Nama Epep](#14-nama-epep) | ✅
  | [15. Password](#15-password) | ✅
  | [16. Pypi](#16-pypi) | ❌
  | [17. Qanime](#17-qanime) | ✅
  | [18. Qhacker](#18-qhacker) | ✅
  | [19. Qislam](#19-qislam) | ✅
  | [20. Qpubg](#20-qpubg) | ✅
  | [21. Truth](#21-truth) | ✅
  | [22. Wibu](#22-wibu) | ✅


  **Description**:
  Interaksi dengan AI Basis Text.
  **Args:**
  **Description**:
  tanya (str): Text inputnya.
  **Returns:**
  **Description**:
  str: Respon chatbotnya.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.ai(tanya='Tidur')
  print(result)
  ```

  ```text
  Ni dah pagi lah.
  ```

  **Description**:
  Cari bing images based om teks.
  **Args:**
    - **teks (str)**: Teks quesy yang ingin di cari gambarnya.
    - **limit (int, optional)**: Maximum number photonya. Defaults nya 1.
  **Returns:**
    - **list**: List image url yang di terima.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.bing_image(teks='Tidur', limit=1)
  print(result)
  ```

  ```text
  https://d1vbn70lmn1nqe.cloudfront.net/prod/wp-content/uploads/2023/03/14044059/Kenali-Pola-Tidur-yang-Baik-untuk-Kesehatan.jpg
  ```

  **Description**:
  Berinteraksi dengan Blackbox AI untuk menghasilkan konten. 🧠
  **Args:**
    - **tanya (str)**: Teks masukan untuk berinteraksi dengan API obrolan Blackbox AI.
  **Returns:**
    - **requests.Response**: Objek respons dari permintaan API.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.blackbox(tanya='Tidur')
  print(result)
  ```

  ```json
  {
      "results": "Generated by BLACKBOX.AI, try unlimited chat https://www.blackbox.ai\n\nTidur adalah proses fisiologis yang penting bagi kesehatan dan kesejahteraan manusia. Selama tidur, tubuh melakukan berbagai pemulihan dan regenerasi, termasuk pemulihan otot, penguatan sistem kekebalan tubuh, dan pengolahan informasi yang diperoleh selama hari. Tidur yang cukup dan berkualitas juga berperan dalam kesehatan mental dan emosional.\n\nAda beberapa tips untuk mendapatkan tidur yang lebih baik:\n\n1. **Tetapkan Jadwal Tidur**: Cobalah untuk tidur dan bangun pada waktu yang sama setiap hari, bahkan di akhir pekan.\n2. **Ciptakan Lingkungan Tidur yang Nyaman**: Pastikan kamar tidur gelap, tenang, dan sejuk.\n3. **Batasi Paparan Layar**: Hindari penggunaan perangkat elektronik setidaknya satu jam sebelum tidur.\n4. **Hindari Kafein dan Makanan Berat**: Konsumsi kafein dan makanan berat menjelang waktu tidur dapat mengganggu kualitas tidur.\n5. **Relaksasi Sebelum Tidur**: Lakukan aktivitas yang menenangkan, seperti membaca atau meditasi, sebelum tidur.\n\nJika Anda memiliki masalah tidur yang berkepanjangan, sebaiknya konsultasikan dengan profesional kesehatan.",
      "join": "@Er_Support_Group",
      "success": true
  }
  ```

  **Args:**
    - **query (str)**: Potongan kode yang akan dirender sebagai gambar.
  **Description**:
  Return: FilePath: Jalur file dari gambar yang disimpan.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.carbon(query='Tidur')
  print(result)
  ```

  ```text
  /home/runner/work/ApiNyaEr/ApiNyaEr/downloads/carbon_XMxFlBi8.png
  ```

  **Description**:
  Generate random gambar kucing.
  **Returns:**
    - **str or None**: Url random kucing ataupun None; None jika response
      tidak di terima.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.cat()
  print(result)
  ```

  ```text
  https://cdn2.thecatapi.com/images/25d.jpg
  ```

  **Description**:
  Dapatkan Kata kata dare
  **Returns:**
    - **str**: Random kata dare
  ```python
  from ApiNyaEr import apinya
  result = await apinya.dare()
  print(result)
  ```

  ```text
  Beli makanan paling murah di kantin (atau beli sebotol aqua) dan bilang sambil tersedu-sedu pada teman sekelasmu 'Ini.. adalah makanan yang paling mahal yang pernah kubeli.. Hiks'
  ```

  **Description**:
  Mengambil data doa dari API ItzPire berdasarkan nama doa.
  **Args:**
    - **nama_doa (str)**: Nama doa yang ingin diambil.
  **Returns:**
    - **str**: Teks doa yang diformat dengan rapi termasuk doa, ayat, latin, dan artinya.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.doa(nama_doa='Tidur')
  print(result)
  ```

  ```text
  Doa sebelum tidur
  Ayat: بِسْمِكَ االلّٰهُمَّ اَحْيَا وَبِاسْمِكَ اَمُوْتُ
  Latin: Bismikallaahumma ahyaa wa ammuut
  Artinya: Dengan menyebut nama Allah, aku hidup dan aku mati
  ```

  **Description**:
  Dapatkan random foto anjing.
  **Returns:**
    - **str or None**: Url Random anjing jika tersedia; None jika tidak ada
      response yang di terima.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.dog()
  print(result)
  ```

  ```text
  https://random.dog/938d494d-71d1-4d76-9187-bcaa5c23c57d.PNG
  ```

  **Description**:
  Dapatkan random Seputar Fakta Unik
  **Returns:**
    - **str**: Random Fakta
  ```python
  from ApiNyaEr import apinya
  result = await apinya.fakta_unik()
  print(result)
  ```

  ```text
  🌾 **Titik diatas huruf i disebut ‘title’**
  ```

  **Description**:
  Berinteraksi dengan Gemini AI. ✨
  **Args:**
    - **tanya (str)**: Teks yang di berikan.
  **Returns:**
    - **dict**: dictionaries yang berisi konten ai nya.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.gemini(tanya='Tidur')
  print(result)
  ```

  ```json
  {
      "results": "**Definisi Tidur**\n\nTidur adalah keadaan kesadaran yang menurun yang ditandai dengan berkurangnya respons terhadap stimulus eksternal dan perubahan aktivitas otak.\n\n**Jenis-Jenis Tidur**\n\n* **Tidur NREM (Non-Rapid Eye Movement)**\n    * Tahap 1: Transisi dari terjaga ke tidur, pikiran masih aktif.\n    * Tahap 2: Tidur ringan, aktivitas otak melambat.\n    * Tahap 3 dan 4: Tidur nyenyak, aktivitas otak sangat lambat.\n* **Tidur REM (Rapid Eye Movement)**\n    * Tahap tidur yang disertai dengan gerakan cepat mata dan aktivitas otak yang tinggi.\n    * Bermimpi terjadi selama tidur REM.\n\n**Tahapan Tidur**\n\nSiklus tidur biasanya terdiri dari empat atau lima tahapan:\n\n* Tahap 1 dan 2 (Tidur NREM)\n* Tahap 3 dan 4 (Tidur NREM)\n* Tahap REM\n\n**Fungsi Tidur**\n\n* **Pemulihan Fisik:** Tidur memungkinkan tubuh memperbaiki dan memulihkan sel dan jaringan.\n* **Konsolidasi Memori:** Tidur membantu memperkuat dan menyimpan ingatan.\n* **Pengaturan Emosi:** Tidur membantu mengatur hormon stres dan emosi.\n* **Peningkatan Kognitif:** Tidur meningkatkan perhatian, konsentrasi, dan fungsi kognitif lainnya.\n* **Kesehatan Jantung:** Tidur yang cukup mengurangi risiko penyakit kardiovaskular.\n* **Imunitas:** Tidur yang cukup memperkuat sistem kekebalan tubuh.\n\n**Gangguan Tidur Umum**\n\n* Insomnia\n* Apnea tidur\n* Sindrom kaki gelisah\n* Narkolepsi\n* Tidur berjalan\n\n**Tips untuk Mendapatkan Tidur yang Berkualitas**\n\n* Tetapkan waktu tidur dan bangun yang teratur.\n* Ciptakan lingkungan tidur yang gelap, tenang, dan sejuk.\n* Hindari konsumsi kafein dan alkohol sebelum tidur.\n* Lakukan rutinitas santai sebelum tidur, seperti mandi air hangat atau membaca.\n* Pastikan tempat tidur Anda nyaman dan mendukung.\n* Berolahraga secara teratur, tetapi hindari berolahraga terlalu dekat dengan waktu tidur.\n* Hindari penggunaan perangkat elektronik di tempat tidur.\n* Jika Anda kesulitan tidur, hindari berbaring di tempat tidur terlalu lama. Bangun dan lakukan sesuatu yang menenangkan sampai Anda merasa mengantuk.",
      "author": "@chakszzz",
      "success": true
  }
  ```

  **Description**:
  Pencarian GitHub untuk beberapa tipe konten.
  **Args:**
    - **cari (str)**: untuk Pencarian.
    - **tipe (str, optional)**: Type pencarian, terdiri dari:
      - "repositories"
      - "users"
      - "organizations"
      - "issues"
      - "pull_requests"
      - "commits"
      - "topics"
  **Description**:
  Defaults ke "repositories". max_results (int, optional): Maximum nomor dari results untuk return. Defaultnya 3.
  **Returns:**
    - **list**: List dari pencarian results atau pesan error.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.github_search(cari='Tidur', tipe='repositories', max_results=3)
  print(result)
  ```

  ```json
  [
      {
          "name": "rs-bed-covid-indo-api",
          "full_name": "satyawikananda/rs-bed-covid-indo-api",
          "description": "API ketersediaan rumah sakit dan tempat tidur rumah sakit untuk pasien covid-19 ataupun non-covid yang berada di Indonesia",
          "url": "https://github.com/satyawikananda/rs-bed-covid-indo-api",
          "language": "TypeScript",
          "stargazers_count": 112,
          "forks_count": 25
      },
      {
          "name": "bed-covid-rs-indo",
          "full_name": "hendraaagil/bed-covid-rs-indo",
          "description": "Website yang memberikan informasi terkait ketersediaan rumah sakit dan tempat tidur rumah sakit untuk pasien covid-19 ataupun non-covid di Indonesia.",
          "url": "https://github.com/hendraaagil/bed-covid-rs-indo",
          "language": "JavaScript",
          "stargazers_count": 23,
          "forks_count": 3
      },
      {
          "name": "hobikoding.github.io",
          "full_name": "hobikoding/hobikoding.github.io",
          "description": ":rose: Hobikoding - Mari ngoding sambil tidur",
          "url": "https://github.com/hobikoding/hobikoding.github.io",
          "language": "Makefile",
          "stargazers_count": 3,
          "forks_count": 0
      }
  ]
  ```

  **Description**:
  Dapatkan gif Random pelukan dari Nekos.Best API.
  **Args:**
    - **amount (int)**: amount gambar nya, Defaultnya 1.
  **Returns:**
    - **list**: List dari dictionaries tentang informasi neko image atau GIF.
      Type dictionaries:
      - anime_name (str): Nama anime.
      - url (str): Url gif nya.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.hug(amount=1)
  print(result)
  ```

  ```json
  [
      {
          "anime_name": "Cuckoo no Iinazuke",
          "url": "https://nekos.best/api/v2/hug/f45aad5e-e82f-4cac-b071-9b6f67752e0e.gif"
      }
  ]
  ```

  **Description**:
  Dapatkan informasi Hari libur kedepan.
  **Returns:**
    - **str**: Hari Libur Berikutnya.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.kapan_libur()
  print(result)
  ```

  ```text
  Hari liburberikutnya adalah Hari Natal yang jatuh di hari Rabu, 25 Desember 2024 (35 hari lagi)
  ```

  **Description**:
  Dapatkan random nama ep ep
  **Returns:**
    - **str**: Random nama ep epnya
  ```python
  from ApiNyaEr import apinya
  result = await apinya.nama_epep()
  print(result)
  ```

  ```text
  『NOB』вαℓα∂σяヅ™
  ```

  **Description**:
  Fungsi ini menghasilkan kata sandi acak dengan menggabungkan huruf besar, huruf kecil, tanda baca, dan digit.
  **Description**:
  Parameters: - num (int): Panjang kata sandi yang dihasilkan. Default adalah 12 jika tidak ditentukan.
  **Returns:**
  **Description**:
  - str: Kata sandi yang dihasilkan secara acak yang terdiri dari karakter dari string.ascii_letters, string.punctuation, dan string.digits.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.password(num=12)
  print(result)
  ```

  ```text
  1'jL(Rk&xBYw
  ```

  **Description**:
  Mengambil informasi metadata tentang paket Python tertentu dari API PyPI.
  **Args:**
    - **namanya (str)**: Nama paket yang dicari di PyPI.
  **Returns:**
    - **dict atau None**: Sebuah kamus dengan informasi relevan tentang paket jika ditemukan, yang berisi:
      - name (str): Nama paket.
      - version (str): Versi terbaru paket.
      - summary (str): Deskripsi singkat tentang paket.
      - author (str): Penulis paket.
      - author_email (str): Email penulis paket.
      - license (str): Jenis lisensi.
      - home_page (str): URL halaman utama paket.
      - package_url (str): URL paket di PyPI.
      - requires_python (str): Versi Python minimum yang dibutuhkan.
      - keywords (str): Kata kunci yang terkait dengan paket.
      - classifiers (list): Daftar pengklasifikasi PyPI.
      - project_urls (dict): URL proyek tambahan (misalnya, kode sumber, dokumentasi).
  **Description**:
  Returns None jika paket tidak ditemukan atau terjadi kesalahan.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.pypi(namanya='Tidur')
  print(result)
  ```

  ```text
  Request failed: 404, message='Not Found', url='https://pypi.org/pypi/Tidur/json'
  ```

  **Description**:
  Dapatkan Kata kata anime
  **Returns:**
    - **str**: Random kata anime
  ```python
  from ApiNyaEr import apinya
  result = await apinya.qanime()
  print(result)
  ```

  ```json
  {
      "\ud83c\udf81 **Quotes": "Yusa-san mencoba membuatku berhenti menyukaimu dan berkata kalau aku akan menyesal nantinya. Tapi, aku menyukaimu dengan kemauanku sendiri. Maka dari itu, suka ataupun tidak suka, aku sendiri yang memutuskannya.**",
      "\ud83c\udf39 **Character": "Chiho Sasaki**",
      "\ud83c\udf41 **Anime": "Hataraku Maou-sama!**",
      "\ud83c\udf41 **Episode": "Episode 8**"
  }
  ```

  **Description**:
  Dapatkan random Quotes Hacker
  **Returns:**
    - **str**: Random Quotes Hacker
  ```python
  from ApiNyaEr import apinya
  result = await apinya.qhacker()
  print(result)
  ```

  ```text
  🃏 **Hackers are becoming more sophisticated in conjuring up new ways to hijack your system by exploiting technical vulnerabilities or human nature. Don't become the next victim of unscrupulous cyberspace intruders.**
  ```

  **Description**:
  Dapatkan random Quotes Islamic
  **Returns:**
    - **str**: Random Quotes Islam
  ```python
  from ApiNyaEr import apinya
  result = await apinya.qislam()
  print(result)
  ```

  ```text
  📖 **Jangan pernah merasa lebih baik daripada orang lain karena kita tidak tahu seberapa banyak amal kebaikan yang ia tutupi**
  ```

  **Description**:
  Dapatkan random Quotes pubg
  **Returns:**
    - **str**: Random Quotes Pubg
  ```python
  from ApiNyaEr import apinya
  result = await apinya.qpubg()
  print(result)
  ```

  ```text
  🏆 **Tempat Favoritku untuk berkendara adalah Miramar**
  ```

  **Description**:
  Dapatkan Kata kata truth
  **Returns:**
    - **str**: Random kata truth
  ```python
  from ApiNyaEr import apinya
  result = await apinya.truth()
  print(result)
  ```

  ```text
  Bagian tubuhmu mana yang paling kamu benci?
  ```

  **Description**:
  Fetch spesifik Gambar/Gif Anime.
  **Args:**
    - **endpoint (str)**: Kategori endpoin gambar/Gif animenya. Defaultnya
      "kiss".
      Valid Format endpoints:
      - "husbando", "kitsune", "neko", "waifu"
      Valid GIF endpoints:
      - "baka", "bite", "blush", "bored", "cry", "cuddle", "dance", "facepalm",
      "feed", "handhold", "handshake", "happy", "highfive", "hug", "kick",
      "kiss", "laugh", "lurk", "nod", "nom", "nope", "pat", "peck", "poke",
      "pout", "punch", "shoot", "shrug", "slap", "sleep", "smile", "smug",
      "stare", "think", "thumbsup", "tickle", "wave", "wink", "yawn", "yeet"
      amount (int): amount item gambarnya. Default 1.
  **Returns:**
    - **dict**: Dictionary konten yang di request. Dictionarynya memiliki kata
      kunci`"results"`,
      yang menampung limit.
  **Raises:**
    - **ValueError**: Jika endpoint tidak valid.
  ```python
  from ApiNyaEr import apinya
  result = await apinya.wibu(endpoint='kiss', amount=1)
  print(result)
  ```

  ```json
  {
      "results": [
          {
              "anime_name": "Kuzu no Honkai",
              "url": "https://nekos.best/api/v2/kiss/3385ca97-b64b-4798-a4c4-292a7eb5a15e.gif"
          }
      ]
  }
  ```
  This Project is Licensed under [GNU General Public License](https://github.com/ErRickow/ApiNyaEr/blob/Er/LICENSE)


pkgId: 02bd1eb6a7d845aa62fed2a8fe2a179bad6f7a4cbccf260998e38a3fafe3fa1a
name: python-AppLogger
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: A simple application logger
url: UNKNOWN
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AppLogger-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Basic usage

  from AppLogger import AppLogger


  config = {
      'log_folder': 'log'
  }
  AppLogger(config)

  AppLogger.start("App Log start")
  AppLogger.info("This is info message")
  AppLogger.warning("This is warning message")
  AppLogger.exception("This is exception message")
  AppLogger.debug("This is debug message")
  AppLogger.error("This is error message")
  AppLogger.end("App Log end")


pkgId: 03b013299b7e2db422c9f6f4b204617a0056dbc2769be93e27090ee8d09d3dac
name: python-AppMetrics
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Application metrics collector
url: https://github.com/avalente/appmetrics
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AppMetrics-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Install ``AppMetrics`` into your python environment::
      pip install appmetrics
  or, if you don't use ``pip``, download and unpack the package an then::
      python setup.py install
  Once you have installed ``AppMetrics`` you can access it by the ``metrics`` module::
      >>> from appmetrics import metrics
      >>> histogram = metrics.new_histogram("test")
      >>> histogram.notify(1.0)
      True
      >>> histogram.notify(2.0)
      True
      >>> histogram.notify(3.0)
      True
      >>> histogram.get()
      {'arithmetic_mean': 2.0, 'kind': 'histogram', 'skewness': 0.0, 'harmonic_mean': 1.6363636363636365, 'min': 1.0, 'standard_deviation': 1.0, 'median': 2.0, 'histogram': [(3.0, 3), (5.0, 0)], 'percentile': [(50, 2.0), (75, 2.0), (90, 3.0), (95, 3.0), (99, 3.0), (99.9, 3.0)], 'n': 3, 'max': 3.0, 'variance': 1.0, 'geometric_mean': 1.8171205928321397, 'kurtosis': -2.3333333333333335}
  Basically you create a new metric by using one of the ``metrics.new_*`` functions. The metric will be stored into
  an internal registry, so you can access it in different places in your application::
      >>> test_histogram = metrics.metric("test")
      >>> test_histogram.notify(4.0)
      True
  The ``metrics`` registry is thread-safe, you can safely use it in multi-threaded web servers.
  Using the ``with_histogram`` decorator we can time a function::
      >>> import time, random
      >>> @metrics.with_histogram("test")
      >>> my_worker()
      >>> my_worker()
      >>> my_worker()
  and let's see the results::
      >>> metrics.get("test")
      {'arithmetic_mean': 0.41326093673706055, 'kind': 'histogram', 'skewness': 0.2739718270714368, 'harmonic_mean': 0.14326954591313346, 'min': 0.0613858699798584, 'standard_deviation': 0.4319169569113129, 'median': 0.2831099033355713, 'histogram': [(1.0613858699798584, 3), (2.0613858699798584, 0)], 'percentile': [(50, 0.2831099033355713), (75, 0.2831099033355713), (90, 0.895287036895752), (95, 0.895287036895752), (99, 0.895287036895752), (99.9, 0.895287036895752)], 'n': 3, 'max': 0.895287036895752, 'variance': 0.18655225766752892, 'geometric_mean': 0.24964828731906127, 'kurtosis': -2.3333333333333335}
  It is also possible to time specific sections of the code by using the ``timer`` context manager::
      >>> import time, random
  Let's print the metrics data on the screen every 5 seconds::
      >>> from appmetrics import reporter
      >>> def stdout_report(metrics):
      >>> reporter.register(stdout_report, reporter.fixed_interval_scheduler(5))
      '5680173c-0279-46ec-bd88-b318f8058ef4'
      >>> {'test': {'arithmetic_mean': 0.0, 'kind': 'histogram', 'skewness': 0.0, 'harmonic_mean': 0.0, 'min': 0, 'standard_deviation': 0.0, 'median': 0.0, 'histogram': [(0, 0)], 'percentile': [(50, 0.0), (75, 0.0), (90, 0.0), (95, 0.0), (99, 0.0), (99.9, 0.0)], 'n': 0, 'max': 0, 'variance': 0.0, 'geometric_mean': 0.0, 'kurtosis': 0.0}}
      >>> my_worker()
      >>> my_worker()
      >>> {'test': {'arithmetic_mean': 0.5028266906738281, 'kind': 'histogram', 'skewness': 0.0, 'harmonic_mean': 0.2534044030939462, 'min': 0.14868521690368652, 'standard_deviation': 0.50083167520453, 'median': 0.5028266906738281, 'histogram': [(1.1486852169036865, 2), (2.1486852169036865, 0)], 'percentile': [(50, 0.14868521690368652), (75, 0.8569681644439697), (90, 0.8569681644439697), (95, 0.8569681644439697), (99, 0.8569681644439697), (99.9, 0.8569681644439697)], 'n': 2, 'max': 0.8569681644439697, 'variance': 0.2508323668881758, 'geometric_mean': 0.35695727672917066, 'kurtosis': -2.75}}
      >>> reporter.remove('5680173c-0279-46ec-bd88-b318f8058ef4')
      <Timer(Thread-1, started daemon 4555313152)>
  Decorators
  **********
  The ``metrics`` module also provides a couple of decorators: ``with_histogram`` and ``with_meter`` which are
  an easy and fast way to use ``AppMetrics``: just decorate your functions/methods and you will have metrics
  collected for them. You can decorate multiple functions with the same metric's name, as long as the decorator's
  type and parameters are the same, or a ``DuplicateMetricError`` will be raised.
  See the documentation for `Histograms`_ and `Meters`_ for more details.


pkgId: c916ae2802688a2883c4d6bd6230d987128682169f0cb98c0b53a5d791f514bf
name: python-Appengine-Fixture-Loader
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Appengine fixture loader
url: http://github.com/rbanffy/appengine-fixture-loader/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Appengine-Fixture-Loader-0.1.9-1.src.rpm
checksum_type: sha256
description:
  A simple way to load Django-like fixtures into the local development datastore, originally intended to be used by `testable_appengine <https://github.com/rbanffy/testable_appengine>`_.


pkgId: e9c608573649dc85ad1c68dc0bf9a831007a2815d2f4ed2a7703c5761982ff8f
name: python-Appium-Flutter-Finder
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: An extension of finder for Appium flutter
url: https://github.com/appium-userland/appium-flutter-driver
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Appium-Flutter-Finder-0.7.0-1.src.rpm
checksum_type: sha256
description:
  There are three ways to install and use the Appium Flutter Finder.
  Supported Python version follows appium python client.

  1. Install from [PyPi](https://pypi.org), as ['Appium-Flutter-Finder'](https://pypi.org/project/Appium-Flutter-Finder/).

      ```shell
      pip install Appium-Flutter-Finder
      ```

  2. Install from source, via [PyPi](https://pypi.org). From ['Appium-Flutter-Finder'](https://pypi.org/project/Appium-Flutter-Finder/),
  download and unarchive the source tarball (Appium-Flutter-Finder-X.X.tar.gz).

      ```shell
      tar -xvf Appium-Flutter-Finder-X.X.tar.gz
      cd Appium-Flutter-Finder-X.X
      python setup.py install
      ```

  3. Install from source via [GitHub](https://github.com/appium/python-client).

      ```shell
      git clone git@github.com:appium/python-client.git
      cd python-client
      python setup.py install
      ```


  Examples can be found out [here](../../example/python/example.py).



  ```
  pip install twine
  ```

  ```
  python setup.py sdist
  twine upload dist/Appium-Flutter-Finder-X.X.tar.gz
  ```


  - 0.7.0
      - Update the limit of python appium client version
  - 0.6.1
      - Fix package
  - 0.6.0
      - Fix type of `match_root` and `first_match_only` in `by_ancestor` and `by_descendant
  - 0.5.0
      - Allow Appium-Python-Client to be v3
  - 0.4.0
      - Bump base Appium-Python-Client to v2
  - 0.3.1
      - Use Appium-Python-Client 1.x
  - 0.3.0
      - Add `first_match_only` option in `by_ancestor` and `by_descendant`
  - 0.2.0
      - Support over Python 3.6
  - 0.1.5
      - Fix `by_ancestor` and `by_descendant`
          - https://github.com/truongsinh/appium-flutter-driver/pull/165#issuecomment-877928553
  - 0.1.4
      - Remove whitespaces from the decoded JSON
      - Fix `by_ancestor` and `by_descendant`
  - 0.1.3
      - Allow `from appium_flutter_finder import FlutterElement, FlutterFinder`
  - 0.1.2
      - Fix b64encode error in Python 3
  - 0.1.1
      - Initial release


pkgId: 6af94572f4e2d37e7beae572fceb6d2e0d70ec596091638371ea5585705c4f74
name: python-Appium-Python-Client
arch: src
version: 4.2.0
epoch: 0
release: 1
summary: Python client for Appium
url: http://appium.io/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Appium-Python-Client-4.2.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/Appium-Python-Client.svg)](https://badge.fury.io/py/Appium-Python-Client)
  [![Downloads](https://pepy.tech/badge/appium-python-client)](https://pepy.tech/project/appium-python-client)

  [![Functional Tests](https://github.com/appium/python-client/actions/workflows/functional-test.yml/badge.svg)](https://github.com/appium/python-client/actions/workflows/functional-test.yml)

  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  An extension library for adding [WebDriver Protocol](https://www.w3.org/TR/webdriver/) and Appium commands to the Selenium Python language binding for use with the mobile testing framework [Appium](https://appium.io).



  There are three ways to install and use the Appium Python client.

  1. Install from [PyPi](https://pypi.org), as
  ['Appium-Python-Client'](https://pypi.org/project/Appium-Python-Client/).

      ```shell
      pip install Appium-Python-Client
      ```

      You can see the history from [here](https://pypi.org/project/Appium-Python-Client/#history)

  2. Install from source, via [PyPi](https://pypi.org). From ['Appium-Python-Client'](https://pypi.org/project/Appium-Python-Client/),
  download and unarchive the source tarball (Appium-Python-Client-X.X.tar.gz).

      ```shell
      tar -xvf Appium-Python-Client-X.X.tar.gz
      cd Appium-Python-Client-X.X
      python setup.py install
      ```

  3. Install from source via [GitHub](https://github.com/appium/python-client).

      ```shell
      git clone git@github.com:appium/python-client.git
      cd python-client
      python setup.py install
      ```



  |Appium Python Client| Selenium binding| Python version |
  |----|----|----|
  |`3.0.0`+ |`4.12.0`+ | 3.8+ |
  |`2.10.0` - `2.11.1` |`4.1.0` - `4.11.2` | 3.7+ |
  |`2.2.0` - `2.9.0` |`4.1.0` - `4.9.0` | 3.7+ |
  |`2.0.0` - `2.1.4` |`4.0.0` | 3.7+ |
  |`1.0.0` - `1.3.0` |`3.x`| 3.7+ |
  |`0.52` and below|`3.x`| 2.7, 3.4 - 3.7 |

  The Appium Python Client depends on [Selenium Python binding](https://pypi.org/project/selenium/), thus
  the Selenium Python binding update might affect the Appium Python Client behavior.
  For example, some changes in the Selenium binding could break the Appium client.

  > **Note**
  > We strongly recommend you manage dependencies with version management tools such as Pipenv and requirements.txt
  > to keep compatible version combinations.



  - Removal
      - `MultiAction` and `TouchAction` are removed. Please use W3C WebDriver actions or `mobile:` extensions
          - [appium/webdriver/extensions/action_helpers.py](appium/webdriver/extensions/action_helpers.py)
          - https://www.selenium.dev/documentation/webdriver/actions_api/
          - https://www.youtube.com/watch?v=oAJ7jwMNFVU
          - https://appiumpro.com/editions/30-ios-specific-touch-action-methods
          - https://appiumpro.com/editions/29-automating-complex-gestures-with-the-w3c-actions-api
      - Deprecated `AppiumBy.WINDOWS_UI_AUTOMATION`, which has no usage right now.


  - `options` keyword argument in the `webdriver.Remote` constructor such as `XCUITestOptions` instead of `desired_capabilities`
      - Available options are https://github.com/appium/python-client/tree/master/appium/options
          - Please check the [Usage](#usage) below as an example.
      - Not a "new" change, but the `desired_capabilities` argument has been removed since v3.
  - Replacement
      - `start_activity` method: Please use [`mobile: startActivity`](https://github.com/appium/appium-uiautomator2-driver?tab=readme-ov-file#mobile-startactivity)
      - `launch_app`, `close_app` and `reset` methods: Please refer to https://github.com/appium/appium/issues/15807
      - `available_ime_engines`, `is_ime_active`, `activate_ime_engine`, `deactivate_ime_engine` and `active_ime_engine` methods: Please use [`mobile: shell`](https://github.com/appium/appium-uiautomator2-driver?tab=readme-ov-file#mobile-shell)
      - `set_value` and `set_text` methods: Please use `element.send_keys` or `send_keys` by W3C Actions
  - Removal
      - `end_test_coverage` method is no longer available
      - `session` property is no longer available
      - `all_sessions` property is no longer available


  - Enhancement
      - Updated base Selenium Python binding version to v4
          - Removed `forceMjsonwp` since Selenium v4 and Appium Python client v2 expect only W3C WebDriver protocol
      - Methods `ActionHelpers#scroll`, `ActionHelpers#drag_and_drop`, `ActionHelpers#tap`, `ActionHelpers#swipe` and `ActionHelpers#flick` now call W3C actions as its backend
          - Please check each behavior. Their behaviors could slightly differ.
      - Added `strict_ssl` to relax SSL errors such as self-signed ones
  - Deprecated
      - `MultiAction` and `TouchAction` are deprecated. Please use W3C WebDriver actions or `mobile:` extensions
      - `launch_app`, `close_app`, and `reset` are deprecated. Please read [issues#15807](https://github.com/appium/appium/issues/15807) for more details



  Some elements can be handled with `touch` pointer action instead of the default `mouse` pointer action in the Selenium Python client.
  For example, the below action builder is to replace the default one with the `touch` pointer action.

  ```python
  from selenium.webdriver import ActionChains
  from selenium.webdriver.common.actions import interaction
  from selenium.webdriver.common.actions.action_builder import ActionBuilder
  from selenium.webdriver.common.actions.pointer_input import PointerInput

  actions = ActionChains(driver)

  actions.w3c_actions = ActionBuilder(driver, mouse=PointerInput(interaction.POINTER_TOUCH, "touch"))
  actions.w3c_actions.pointer_action.move_to_location(start_x, start_y)
  actions.w3c_actions.pointer_action.pointer_down()
  actions.w3c_actions.pointer_action.pause(2)
  actions.w3c_actions.pointer_action.move_to_location(end_x, end_y)
  actions.w3c_actions.pointer_action.release()
  actions.perform()
  ```

  - [appium/webdriver/extensions/action_helpers.py](appium/webdriver/extensions/action_helpers.py)
  - https://www.selenium.dev/documentation/webdriver/actions_api/



  The Appium Python Client is fully compliant with the WebDriver Protocol
  including several helpers to make mobile testing in Python easier.

  To use the new functionality now, and to use the superset of functions, instead of
  including the Selenium `webdriver` module in your test code, use that from
  Appium instead.

  ```python
  from appium import webdriver
  ```

  From there much of your test code will work with no change.

  As a base for the following code examples, the following set up the [UnitTest](https://docs.python.org/3/library/unittest.html)
  environment:

  ```python

  import pytest

  from appium import webdriver



  from appium.options.android import UiAutomator2Options
  from appium.options.ios import XCUITestOptions
  from appium.webdriver.appium_service import AppiumService
  from appium.webdriver.common.appiumby import AppiumBy

  APPIUM_PORT = 4723
  APPIUM_HOST = '127.0.0.1'




  @pytest.fixture(scope='session')
  def appium_service():
      service = AppiumService()
      service.start(
          
          
          args=['--address', APPIUM_HOST, '-p', str(APPIUM_PORT)],
          timeout_ms=20000,
      )
      yield service
      service.stop()


  def create_ios_driver(custom_opts = None):
      options = XCUITestOptions()
      options.platformVersion = '13.4'
      options.udid = '123456789ABC'
      if custom_opts is not None:
          options.load_capabilities(custom_opts)
      
      return webdriver.Remote(f'http://{APPIUM_HOST}:{APPIUM_PORT}', options=options)


  def create_android_driver(custom_opts = None):
      options = UiAutomator2Options()
      options.platformVersion = '10'
      options.udid = '123456789ABC'
      if custom_opts is not None:
          options.load_capabilities(custom_opts)
      
      return webdriver.Remote(f'http://{APPIUM_HOST}:{APPIUM_PORT}', options=options)


  @pytest.fixture
  def ios_driver_factory():
      return create_ios_driver


  @pytest.fixture
  def ios_driver():
      
      driver = create_ios_driver()
      yield driver
      driver.quit()


  @pytest.fixture
  def android_driver_factory():
      return create_android_driver


  @pytest.fixture
  def android_driver():
      
      driver = create_android_driver()
      yield driver
      driver.quit()


  def test_ios_click(appium_service, ios_driver_factory):
      
      
      with ios_driver_factory({
          'appium:app': '/path/to/app/UICatalog.app.zip'
      }) as driver:
          el = driver.find_element(by=AppiumBy.ACCESSIBILITY_ID, value='item')
          el.click()


  def test_android_click(appium_service, android_driver_factory):
      
      
      with android_driver_factory({
          'appium:app': '/path/to/app/test-app.apk',
          'appium:udid': '567890',
      }) as driver:
          el = driver.find_element(by=AppiumBy.ACCESSIBILITY_ID, value='item')
          el.click()
  ```



  If your Selenium/Appium server decorates the new session capabilities response with the following keys:

  - `directConnectProtocol`
  - `directConnectHost`
  - `directConnectPort`
  - `directConnectPath`

  Then python client will switch its endpoint to the one specified by the values of those keys.

  ```python
  from appium import webdriver



  from appium.options.ios import XCUITestOptions



  options = XCUITestOptions().load_capabilities({
      'platformVersion': '13.4',
      'deviceName': 'iPhone Simulator',
      'app': '/full/path/to/app/UICatalog.app.zip',
  })

  driver = webdriver.Remote(
      
      'http://127.0.0.1:4723',
      options=options,
      direct_connection=True
  )
  ```



  `strict_ssl` option allows you to send commands to an invalid certificate host like a self-signed one.

  ```python
  from appium import webdriver



  from appium.options.common import AppiumOptions

  options = AppiumOptions()
  options.platform_name = 'mac'
  options.automation_name = 'safari'


  options.set_capability('browser_name', 'safari')


  driver = webdriver.Remote('http://127.0.0.1:4723', options=options, strict_ssl=False)
  ```



  The first argument of `webdriver.Remote` can set an arbitrary command executor for you.

  1. Set init arguments for the pool manager Appium Python client uses to manage HTTP requests.

  ```python
  from appium import webdriver
  from appium.options.ios import XCUITestOptions

  import urllib3
  from appium.webdriver.appium_connection import AppiumConnection


  init_args_for_pool_manage = {
      'retries': urllib3.util.retry.Retry(total=3, connect=3, read=False)
  }
  appium_executor = AppiumConnection(
      remote_server_addr='http://127.0.0.1:4723',
      init_args_for_pool_manage=init_args_for_pool_manage
  )

  options = XCUITestOptions()
  options.platformVersion = '13.4'
  options.udid = '123456789ABC'
  options.app = '/full/path/to/app/UICatalog.app.zip'
  driver = webdriver.Remote(appium_executor, options=options)
  ```


  2. Define a subclass of `AppiumConnection`

  ```python
  from appium import webdriver
  from appium.options.ios import XCUITestOptions

  from appium.webdriver.appium_connection import AppiumConnection

  class CustomAppiumConnection(AppiumConnection):
      
      pass

  custom_executor = CustomAppiumConnection(remote_server_addr='http://127.0.0.1:4723')

  options = XCUITestOptions().load_capabilities({
      'platformVersion': '13.4',
      'deviceName': 'iPhone Simulator',
      'app': '/full/path/to/app/UICatalog.app.zip',
  })
  driver = webdriver.Remote(custom_executor, options=options)

  ```




  - https://appium.github.io/python-client-sphinx/ is detailed documentation
  - [functional tests](test/functional) also may help to see concrete examples.



  - Code Style: [PEP-0008](https://www.python.org/dev/peps/pep-0008/)
    - Apply `black`, `isort` and `mypy` as pre commit hook
    - Run `make` command for development. See `make help` output for details
  - Docstring style: [Google Style](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html)
  - `gitchangelog` generates `CHANGELOG.rst`



  - `pip install --user pipenv`
  - `python -m pipenv lock --clear`
    - If you experience `Locking Failed! unknown locale: UTF-8` error, then refer [pypa/pipenv#187](https://github.com/pypa/pipenv/issues/187) to solve it.
  - `python -m pipenv install --dev --system`
  - `pre-commit install`



  You can run all of the tests running on CI via `tox` in your local.

  ```bash
  $ tox
  ```

  You also can run particular tests like below.



  ```bash
  $ pytest test/unit
  ```

  Run with `pytest-xdist`

  ```bash
  $ pytest -n 2 test/unit
  ```



  ```bash
  $ pytest test/functional/ios/search_context/find_by_ios_class_chain_tests.py
  ```



  1. Create simulators named 'iPhone X - 8100' and 'iPhone X - 8101'
  2. Install test libraries via pip, `pip install pytest pytest-xdist`
  3. Run tests

  ```bash
  $ pytest -n 2 test/functional/ios/search_context/find_by_ios_class_chain_tests.py
  ```



  Follow the below steps.

  ```bash
  $ pip install twine
  $ pip install git+git://github.com/vaab/gitchangelog.git # Getting via GitHub repository is necessary for Python 3.7


  $ DRY_RUN=1 ./release.sh
  $ ./release.sh # release
  ```

  If the `pypi` was not able to publish with user name and password, please try out `-u` and `-p` option by yourself with `twine` such as `twine upload -u <name> -p <pass> dist/Appium-Python-Client-4.1.0.tar.gz`.



  Apache License v2


pkgId: 25967b1ee621304ccb7c124cb69ed10f1b05d17384c9dc96f3f9e323c66cfdbc
name: python-Appium-Python-Client
arch: src
version: 4.4.0
epoch: 0
release: 1
summary: Python client for Appium
url: http://appium.io/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Appium-Python-Client-4.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/Appium-Python-Client.svg)](https://badge.fury.io/py/Appium-Python-Client)
  [![Downloads](https://pepy.tech/badge/appium-python-client)](https://pepy.tech/project/appium-python-client)

  [![Functional Tests](https://github.com/appium/python-client/actions/workflows/functional-test.yml/badge.svg)](https://github.com/appium/python-client/actions/workflows/functional-test.yml)

  An extension library for adding [WebDriver Protocol](https://www.w3.org/TR/webdriver/) and Appium commands to the Selenium Python language binding for use with the mobile testing framework [Appium](https://appium.io).



  There are three ways to install and use the Appium Python client.

  1. Install from [PyPi](https://pypi.org), as
  ['Appium-Python-Client'](https://pypi.org/project/Appium-Python-Client/).

      ```shell
      pip install Appium-Python-Client
      ```

      You can see the history from [here](https://pypi.org/project/Appium-Python-Client/#history)

  2. Install from source, via [PyPi](https://pypi.org). From ['Appium-Python-Client'](https://pypi.org/project/Appium-Python-Client/),
  download and unarchive the source tarball (Appium-Python-Client-X.X.tar.gz).

      ```shell
      tar -xvf Appium-Python-Client-X.X.tar.gz
      cd Appium-Python-Client-X.X
      python setup.py install
      ```

  3. Install from source via [GitHub](https://github.com/appium/python-client).

      ```shell
      git clone git@github.com:appium/python-client.git
      cd python-client
      python setup.py install
      ```



  |Appium Python Client| Selenium binding| Python version |
  |----|----|----|
  |`4.3.0`+ |`4.26.0`+ | 3.8+ |
  |`3.0.0` - `4.2.1` |`4.12.0` - `4.25.0` | 3.8+ |
  |`2.10.0` - `2.11.1` |`4.1.0` - `4.11.2` | 3.7+ |
  |`2.2.0` - `2.9.0` |`4.1.0` - `4.9.0` | 3.7+ |
  |`2.0.0` - `2.1.4` |`4.0.0` | 3.7+ |
  |`1.0.0` - `1.3.0` |`3.x`| 3.7+ |
  |`0.52` and below|`3.x`| 2.7, 3.4 - 3.7 |

  The Appium Python Client depends on [Selenium Python binding](https://pypi.org/project/selenium/), thus
  the Selenium Python binding update might affect the Appium Python Client behavior.
  For example, some changes in the Selenium binding could break the Appium client.

  > **Note**
  > We strongly recommend you manage dependencies with version management tools such as Pipenv and requirements.txt
  > to keep compatible version combinations.



  - Removal
      - `MultiAction` and `TouchAction` are removed. Please use W3C WebDriver actions or `mobile:` extensions
          - [appium/webdriver/extensions/action_helpers.py](appium/webdriver/extensions/action_helpers.py)
          - https://www.selenium.dev/documentation/webdriver/actions_api/
          - https://www.youtube.com/watch?v=oAJ7jwMNFVU
          - https://appiumpro.com/editions/30-ios-specific-touch-action-methods
          - https://appiumpro.com/editions/29-automating-complex-gestures-with-the-w3c-actions-api
      - Deprecated `AppiumBy.WINDOWS_UI_AUTOMATION`, which has no usage right now.


  - `options` keyword argument in the `webdriver.Remote` constructor such as `XCUITestOptions` instead of `desired_capabilities`
      - Available options are https://github.com/appium/python-client/tree/master/appium/options
          - Please check the [Usage](#usage) below as an example.
      - Not a "new" change, but the `desired_capabilities` argument has been removed since v3.
  - Replacement
      - `start_activity` method: Please use [`mobile: startActivity`](https://github.com/appium/appium-uiautomator2-driver?tab=readme-ov-file#mobile-startactivity)
      - `launch_app`, `close_app` and `reset` methods: Please refer to https://github.com/appium/appium/issues/15807
      - `available_ime_engines`, `is_ime_active`, `activate_ime_engine`, `deactivate_ime_engine` and `active_ime_engine` methods: Please use [`mobile: shell`](https://github.com/appium/appium-uiautomator2-driver?tab=readme-ov-file#mobile-shell)
      - `set_value` and `set_text` methods: Please use `element.send_keys` or `send_keys` by W3C Actions
  - Removal
      - `end_test_coverage` method is no longer available
      - `session` property is no longer available
      - `all_sessions` property is no longer available


  - Enhancement
      - Updated base Selenium Python binding version to v4
          - Removed `forceMjsonwp` since Selenium v4 and Appium Python client v2 expect only W3C WebDriver protocol
      - Methods `ActionHelpers#scroll`, `ActionHelpers#drag_and_drop`, `ActionHelpers#tap`, `ActionHelpers#swipe` and `ActionHelpers#flick` now call W3C actions as its backend
          - Please check each behavior. Their behaviors could slightly differ.
      - Added `strict_ssl` to relax SSL errors such as self-signed ones
  - Deprecated
      - `MultiAction` and `TouchAction` are deprecated. Please use W3C WebDriver actions or `mobile:` extensions
      - `launch_app`, `close_app`, and `reset` are deprecated. Please read [issues#15807](https://github.com/appium/appium/issues/15807) for more details



  Some elements can be handled with `touch` pointer action instead of the default `mouse` pointer action in the Selenium Python client.
  For example, the below action builder is to replace the default one with the `touch` pointer action.

  ```python
  from selenium.webdriver import ActionChains
  from selenium.webdriver.common.actions import interaction
  from selenium.webdriver.common.actions.action_builder import ActionBuilder
  from selenium.webdriver.common.actions.pointer_input import PointerInput

  actions = ActionChains(driver)

  actions.w3c_actions = ActionBuilder(driver, mouse=PointerInput(interaction.POINTER_TOUCH, "touch"))
  actions.w3c_actions.pointer_action.move_to_location(start_x, start_y)
  actions.w3c_actions.pointer_action.pointer_down()
  actions.w3c_actions.pointer_action.pause(2)
  actions.w3c_actions.pointer_action.move_to_location(end_x, end_y)
  actions.w3c_actions.pointer_action.release()
  actions.perform()
  ```

  - [appium/webdriver/extensions/action_helpers.py](appium/webdriver/extensions/action_helpers.py)
  - https://www.selenium.dev/documentation/webdriver/actions_api/



  The Appium Python Client is fully compliant with the WebDriver Protocol
  including several helpers to make mobile testing in Python easier.

  To use the new functionality now, and to use the superset of functions, instead of
  including the Selenium `webdriver` module in your test code, use that from
  Appium instead.

  ```python
  from appium import webdriver
  ```

  From there much of your test code will work with no change.

  As a base for the following code examples, the following set up the [UnitTest](https://docs.python.org/3/library/unittest.html)
  environment:

  ```python

  import pytest

  from appium import webdriver



  from appium.options.android import UiAutomator2Options
  from appium.options.ios import XCUITestOptions
  from appium.webdriver.appium_service import AppiumService
  from appium.webdriver.common.appiumby import AppiumBy

  APPIUM_PORT = 4723
  APPIUM_HOST = '127.0.0.1'




  @pytest.fixture(scope='session')
  def appium_service():
      service = AppiumService()
      service.start(
          
          
          args=['--address', APPIUM_HOST, '-p', str(APPIUM_PORT)],
          timeout_ms=20000,
      )
      yield service
      service.stop()


  def create_ios_driver(custom_opts = None):
      options = XCUITestOptions()
      options.platformVersion = '13.4'
      options.udid = '123456789ABC'
      if custom_opts is not None:
          options.load_capabilities(custom_opts)
      
      return webdriver.Remote(f'http://{APPIUM_HOST}:{APPIUM_PORT}', options=options)


  def create_android_driver(custom_opts = None):
      options = UiAutomator2Options()
      options.platformVersion = '10'
      options.udid = '123456789ABC'
      if custom_opts is not None:
          options.load_capabilities(custom_opts)
      
      return webdriver.Remote(f'http://{APPIUM_HOST}:{APPIUM_PORT}', options=options)


  @pytest.fixture
  def ios_driver_factory():
      return create_ios_driver


  @pytest.fixture
  def ios_driver():
      
      driver = create_ios_driver()
      yield driver
      driver.quit()


  @pytest.fixture
  def android_driver_factory():
      return create_android_driver


  @pytest.fixture
  def android_driver():
      
      driver = create_android_driver()
      yield driver
      driver.quit()


  def test_ios_click(appium_service, ios_driver_factory):
      
      
      with ios_driver_factory({
          'appium:app': '/path/to/app/UICatalog.app.zip'
      }) as driver:
          el = driver.find_element(by=AppiumBy.ACCESSIBILITY_ID, value='item')
          el.click()


  def test_android_click(appium_service, android_driver_factory):
      
      
      with android_driver_factory({
          'appium:app': '/path/to/app/test-app.apk',
          'appium:udid': '567890',
      }) as driver:
          el = driver.find_element(by=AppiumBy.ACCESSIBILITY_ID, value='item')
          el.click()
  ```



  Appium Python Client has a common options class named `AppiumOptions` but the available commands are minimal.
  It does not have driver/automationName specific commands unless adding commands with `add_command` method.

  Available options for each automation name below will help to check what options are already defined.
  Please use proper options for your automaiton usage.

  `automationName` | Package path
  |:---|:-----|
  any | `appium.options.common.base.AppiumOptions`
  `uiautomator2` | `appium.options.android.Uiautomator2Options`
  `espresso` | `appium.options.android.EspressoOptions`
  `xcuitest` | `appium.options.ios.XCUITestOptions`
  `safari` | `appium.options.ios.SafariOptions`
  `mac2` | `appium.options.mac.Mac2Options`
  `windows` | `appium.options.WindowsOptions`
  `gecko` | `appium.options.GeckoOptions`
  `flutterintegration` | `appium.options.flutter_integration.FlutterOptions`



  If your Selenium/Appium server decorates the new session capabilities response with the following keys:

  - `directConnectProtocol`
  - `directConnectHost`
  - `directConnectPort`
  - `directConnectPath`

  Then python client will switch its endpoint to the one specified by the values of those keys.

  ```python
  from appium import webdriver



  from appium.options.ios import XCUITestOptions



  options = XCUITestOptions().load_capabilities({
      'platformVersion': '13.4',
      'deviceName': 'iPhone Simulator',
      'app': '/full/path/to/app/UICatalog.app.zip',
  })

  driver = webdriver.Remote(
      
      'http://127.0.0.1:4723',
      options=options,
      direct_connection=True
  )
  ```



  `strict_ssl` option allows you to send commands to an invalid certificate host like a self-signed one.

  ```python
  from appium import webdriver



  from appium.options.common import AppiumOptions

  options = AppiumOptions()
  options.platform_name = 'mac'
  options.automation_name = 'safari'


  options.set_capability('browser_name', 'safari')


  driver = webdriver.Remote('http://127.0.0.1:4723', options=options, strict_ssl=False)
  ```

  Since Appium Python client v4.3.0, we recommend using `selenium.webdriver.remote.client_config.ClientConfig`
  instead of giving `strict_ssl` as an argument of `webdriver.Remote` below to configure the validation.

  ```python
  from appium import webdriver

  from selenium.webdriver.remote.client_config import ClientConfig

  client_config = ClientConfig(
      remote_server_addr='http://127.0.0.1:4723',
      ignore_certificates=True
  )
  driver = webdriver.Remote(client_config.remote_server_addr, options=options, client_config=client_config)
  ```



  The first argument of `webdriver.Remote` can set an arbitrary command executor for you.

  1. Set init arguments for the pool manager Appium Python client uses to manage HTTP requests.

  ```python
  from appium import webdriver
  from appium.options.ios import XCUITestOptions

  import urllib3
  from appium.webdriver.appium_connection import AppiumConnection


  init_args_for_pool_manage = {
      'retries': urllib3.util.retry.Retry(total=3, connect=3, read=False)
  }
  appium_executor = AppiumConnection(
      remote_server_addr='http://127.0.0.1:4723',
      init_args_for_pool_manage=init_args_for_pool_manage
  )

  options = XCUITestOptions()
  options.platformVersion = '13.4'
  options.udid = '123456789ABC'
  options.app = '/full/path/to/app/UICatalog.app.zip'
  driver = webdriver.Remote(appium_executor, options=options)
  ```


  2. Define a subclass of `AppiumConnection`

  ```python
  from appium import webdriver
  from appium.options.ios import XCUITestOptions

  from appium.webdriver.appium_connection import AppiumConnection

  class CustomAppiumConnection(AppiumConnection):
      
      pass

  custom_executor = CustomAppiumConnection(remote_server_addr='http://127.0.0.1:4723')

  options = XCUITestOptions().load_capabilities({
      'platformVersion': '13.4',
      'deviceName': 'iPhone Simulator',
      'app': '/full/path/to/app/UICatalog.app.zip',
  })
  driver = webdriver.Remote(custom_executor, options=options)

  ```

  The `AppiumConnection` can set `selenium.webdriver.remote.client_config.ClientConfig` as well.



  Appium Python Client has `120` seconds read timeout on each HTTP request since the version v4.3.0 because of
  the corresponding selenium binding version.
  You have two methods to extend the read timeout.

  1. Set `GLOBAL_DEFAULT_TIMEOUT` environment variable
  2. Configure timeout via `selenium.webdriver.remote.client_config.ClientConfig`
      - `timeout` argument, or
      - `init_args_for_pool_manager` argument for `urllib3.PoolManager`



  - https://appium.github.io/python-client-sphinx/ is detailed documentation
  - [functional tests](test/functional) also may help to see concrete examples.



  - Code Style: [PEP-0008](https://www.python.org/dev/peps/pep-0008/)
    - Apply `ruff` as pre commit hook
    - Run `make` command for development. See `make help` output for details
  - Docstring style: [Google Style](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html)
  - `gitchangelog` generates `CHANGELOG.rst`



  - `pip install --user pipenv`
  - `python -m pipenv lock --clear`
    - If you experience `Locking Failed! unknown locale: UTF-8` error, then refer [pypa/pipenv#187](https://github.com/pypa/pipenv/issues/187) to solve it.
  - `python -m pipenv install --dev --system`
  - `pre-commit install`



  You can run all of the tests running on CI via `tox` in your local.

  ```bash
  $ tox
  ```

  You also can run particular tests like below.



  ```bash
  $ pytest test/unit
  ```

  Run with `pytest-xdist`

  ```bash
  $ pytest -n 2 test/unit
  ```



  ```bash
  $ pytest test/functional/ios/search_context/find_by_ios_class_chain_tests.py
  ```



  1. Create simulators named 'iPhone X - 8100' and 'iPhone X - 8101'
  2. Install test libraries via pip, `pip install pytest pytest-xdist`
  3. Run tests

  ```bash
  $ pytest -n 2 test/functional/ios/search_context/find_by_ios_class_chain_tests.py
  ```



  Follow the below steps.

  ```bash
  $ pip install twine
  $ pip install git+git://github.com/vaab/gitchangelog.git # Getting via GitHub repository is necessary for Python 3.7


  $ DRY_RUN=1 ./release.sh
  $ ./release.sh # release
  ```

  If the `pypi` was not able to publish with user name and password, please try out `-u` and `-p` option by yourself with `twine` such as `twine upload -u <name> -p <pass> dist/Appium-Python-Client-4.1.0.tar.gz`.



  Apache License v2


pkgId: 457fa3a8c9ca0949face011d6c6a868cd0e7c1b51097fb26d7622ec9b9e1195d
name: python-Appium-UIAutomation
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/ayshrimali/Appium-UIAutomation
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Appium-UIAutomation-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  A handy tool based on Appium-Python to write common UIAutomation test cases (for both iOS and Android) easily.


pkgId: 744c68d1326e72b67b5322c786366fd06ded1516f7c5c8b816cb9c5bc41c4551
name: python-AppiumExtended
arch: src
version: 0.16.156
epoch: 0
release: 1
summary: An extension library for adding ease of use Appium-Python-Client
url: https://github.com/molokov-klim/appium_extended
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AppiumExtended-0.16.156-1.src.rpm
checksum_type: sha256
description:
  Представляем вам библиотеку расширяющую возможности фреймворка [Appium-Python-Client](https://github.com/appium/python-client). С AppiumExtended вам будут доступны новые удобные функции и возможности, которые позволят более эффективно и легко автоматизировать ваши тесты. Позвольте вашим разработчикам сосредоточиться на более сложных задачах, а наша библиотека облегчит взаимодействие с Appium и сделает процесс автоматизации более приятным и эффективным. Дайте вашим тестам возможность раскрыть свой полный потенциал с помощью этого интуитивного расширения для [Appium-Python-Client](https://pypi.org/project/Appium-Python-Client/).



  **Вероятно библиотека не установится с первого раза,** из за **Pillow** и его зависимости **zlib**. Попробуйте ввести команду:
  ```
  pip cache purge
  ```
  И повторить установку.


  Для успешной установки и работы с AppiumExtended вам могут понадобиться некоторые системные зависимости.


  Требуется установить [Appium](https://github.com/appium/appium) с плагинами: appium-device-farm, appium-dashboard.

  ```
  npm i -g appium@next
  appium driver install uiautomator2
  appium plugin install --source=npm appium-device-farm
  appium plugin install --source=npm appium-dashboard
  ```



  Существует три способа установки AppiumExtended.

  1. Установка из [PyPi](https://pypi.org/), как ['AppiumExtended'](https://pypi.org/project/AppiumExtended/).

      ```shell
      pip install AppiumExtended
      ```

      Историю выпусков можно посмотреть [здесь](https://pypi.org/project/AppiumExtended/#history)

  2. Установка исходного кода, через [PyPi](https://pypi.org/). Из ['AppiumExtended'](https://pypi.org/project/AppiumExtended/), скачайте и разархивируйте исходный архив (AppiumExtended-X.X.tar.gz).

      ```shell
      tar -xvf AppiumExtended-X.X.tar.gz
      cd AppiumExtended-X.X
      python setup.py install
      ```

  3. Установка исходного кода из [GitHub](https://github.com/molokov-klim/appium_extended).

      ```shell
      git clone https://github.com/molokov-klim/appium_extended.git
      cd appium_extended
      python setup.py install
      ```





  - [connect](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-connect)
  - [disconnect](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-disconnect)
  - [is_running](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_running)
  - [get_element](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_element)
  - [find_and_get_element](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-find_and_get_element)
  - [get_elements](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_elements)
  - [get_image_coordinates](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_image_coordinates)
  - [get_inner_image_coordinates](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_inner_image_coordinates)
  - [get_many_coordinates_of_image](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_many_coordinates_of_image)
  - [get_text_coordinates](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_text_coordinates)
  - [get_screenshot_as_base64_decoded](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_screenshot_as_base64_decoded)
  - [get_element_contains](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_element_contains)
  - [get_elements_contains](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_elements_contains)
  - [is_element_within_screen](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_element_within_screen)
  - [is_text_on_screen](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_text_on_screen)
  - [is_image_on_the_screen](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_image_on_the_screen)
  - [tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-tap)
  - [swipe](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe)
  - [swipe_top_to_bottom](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe_top_to_bottom)
  - [swipe_bottom_to_top](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe_bottom_to_top)
  - [swipe_right_to_left](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe_right_to_left)
  - [swipe_left_to_right](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe_left_to_right)
  - [wait_for](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-wait_for)
  - [wait_for_not](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-wait_for_not)
  - [wait_return_true](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-wait_return_true)
  - [draw_by_coordinates](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-draw_by_coordinates)
  - [input_by_virtual_keyboard](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_by_virtual_keyboard)



  - [get_element](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_element-1)
  - [get_attributes](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_attributes)
  - [click](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-click)
  - [double_click](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-double_click)
  - [click_and_move](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-click_and_move)
  - [adb_tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-adb_tap)
  - [adb_multi_tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-adb_multi_tap)
  - [adb_swipe](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-adb_swipe)
  - [tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-tap-1)
  - [double_tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-double_tap)
  - [tap_and_move](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-tap_and_move)
  - [get_elements](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_elements-1)
  - [scroll_down](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-scroll_down)
  - [scroll_up](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-scroll_up)
  - [scroll_to_bottom](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-scroll_to_bottom)
  - [scroll_to_top](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-scroll_to_top)
  - [scroll_until_find](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-scroll_until_find)
  - [get_parent](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_parent)
  - [get_parents](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_parents)
  - [get_sibling](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_sibling)
  - [get_siblings](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_siblings)
  - [get_cousin](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_cousin)
  - [get_cousins](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_cousins)
  - [is_contains](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_contains)
  - [zoom](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-zoom)
  - [unzoom](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-unzoom)
  - [get_center](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_center)
  - [get_coordinates](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_coordinates)



  - [start](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-start)
  - [is_alive](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_alive)
  - [stop](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-stop)
  - [wait_until_alive](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-wait_until_alive)



  - [add_page](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-add_page)
  - [navigate](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-navigate)
  - [find_path](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-find_path)
  - [perform_navigation](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-perform_navigation)



  - [get_package_name](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_package_name)
  - [get_launchable_activity](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_launchable_activity)



  - [adb_shell](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-adb_shell)
  - [push](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-push)
  - [pull](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-pull)
  - [start_activity](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-start_activity)
  - [get_current_app_package](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_current_app_package)
  - [close_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-close_app)
  - [reboot_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-reboot_app)
  - [uninstall_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-uninstall_app)
  - [is_app_installed](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_app_installed)
  - [press_home](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-press_home)
  - [press_back](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-press_back)
  - [press_menu](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-press_menu)
  - [input_keycode_num](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_keycode_num_)
  - [input_keycode](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_keycode)
  - [input_by_virtual_keyboard](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_by_virtual_keyboard-1)
  - [input_text](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_text)
  - [tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-tap-2)
  - [swipe](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe-1)
  - [check_vpn](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-check_vpn)
  - [stop_logcat](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-stop_logcat)
  - [know_pid](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-know_pid)
  - [is_process_exist](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_process_exist)
  - [run_background_process](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-run_background_process)
  - [kill_by_pid](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-kill_by_pid)
  - [kill_all](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-kill_all)
  - [delete_files_from_internal_storage](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-delete_files_from_internal_storage)
  - [delete_file_from_internal_storage](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-delete_file_from_internal_storage)
  - [record_video](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-record_video)
  - [stop_video](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-stop_video)
  - [reboot](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-reboot)
  - [get_screen_resolution](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_screen_resolution)




  1. [install_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-install_app-1)
  2. [is_app_installed](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_app_installed-1)
  3. [uninstall_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-uninstall_app-1)
  4. [get_device_model](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_device_model)
  5. [push](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-push-1)
  6. [pull](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-pull-1)
  7. [start_activity](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-start_activity-1)
  8. [close_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-close_app-1)
  9. [reboot_app](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-reboot_app-1)
  10. [press_home](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-press_home-1)
  11. [press_back](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-press_back-1)
  12. [press_menu](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-press_menu-1)
  13. [input_keycode_num](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_keycode_num_-1)
  14. [input_keycode](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_keycode-1)
  15. [input_by_virtual_keyboard](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_by_virtual_keyboard-2)
  16. [input_text](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-input_text-1)
  17. [tap](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-tap-3)
  18. [swipe](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-swipe-2)
  19. [get_current_app_package](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_current_app_package-1)
  20. [check_vpn](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-check_vpn-1)
  21. [stop_logcat](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-stop_logcat-1)
  22. [reload_adb](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-reload_adb)
  23. [know_pid](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-know_pid-1)
  25. [is_process_exist](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-is_process_exist-1)
  26. [run_background_process](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-run_background_process-1)
  27. [kill_by_pid](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-kill_by_pid-1)
  28. [kill_by_name](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-kill_by_name)
  29. [kill_all](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-kill_all-1)
  30. [delete_files_from_internal_storage](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-delete_files_from_internal_storage-1)
  31. [pull_video](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-pull_video)
  32. [stop_video](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-stop_video-1)
  33. [record_video](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-record_video-1)
  34. [reboot](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-reboot-1)
  35. [get_screen_resolution](https://github.com/molokov-klim/appium_extended#%D0%BC%D0%B5%D1%82%D0%BE%D0%B4-get_screen_resolution-1)


  Основной класс расширяющий Appium-Python-Client.



  Метод `connect` выполняет подключение к устройству на основе заданных возможностей или свойств, передаваемых в формате словаря.



  `capabilities`: Словарь, который содержит набор возможностей устройства, к которому производится подключение. Этот словарь может включать такие параметры, как имя устройства, версию операционной системы, путь к приложению и пр.



  ```python
  app = AppiumExtended()

  capabilities_with_install = {
  "platformName": "android",
  "appium:automationName": "uiautomator2",
  "appium:deviceName": device_model,
  "appium:udid": device_uuid,
  "appium:app": path_to_apk,
  "appium:appPackage": package,
  "appium:appWaitActivity": activity_launchable,
  "appium: autoGrantPermissions": True,
  }

  capabilities_without_install = {
  "platformName": "android",
  "appium:automationName": "uiautomator2",
  "appium:deviceName": device_model,
  "appium:udid": device_uuid,
  "appium:noReset": True,
  "appium: autoGrantPermissions": True,
  }

  app.connect(capabilities=self.capabilities_without_install)
  ```



  Метод включает следующие основные этапы:

  1. Сохранение переданных возможностей в свойстве объекта `self.capabilities`.
  2. Запуск локального сервера Appium, если не используется прокси и сервер ещё не запущен. Для запуска сервера используется задержка в 10 секунд, чтобы дать ему время для инициализации.
  3. Инициализация драйвера `webdriver.Remote` с заданными возможностями и адресом сервера. Сохранение драйвера в свойстве объекта `self.driver`.
  4. Инициализация объекта `AppiumImage` с созданным драйвером.
  5. Запись в лог информации о подключении и номере сессии драйвера.



  Метод не генерирует исключения напрямую, но может пробросить исключения, сгенерированные внутренними вызовами, такими как ошибка запуска сервера Appium или ошибки, связанные с `webdriver.Remote`.



  В связи с использованием appium-device-farm указывать device udid необязательно.
  ```python
  capabilities = {
  "platformName": "android",
  "appium:automationName": "uiautomator2",
  }
  ```




  Метод `disconnect` отвечает за отключение от устройства.



  ```python
  app.disconnect()
  ```



  1. Проверка, установлен ли драйвер (`self.driver`). Если драйвер установлен, то выполняется его завершение с помощью метода `quit()` и затем драйвер обнуляется. В процессе выполнения этих операций в лог записывается информация о номере сессии, от которой происходит отключение.
  2. Если не установлено значение `self.keep_alive_server`, то останавливается работа сервера с помощью метода `stop()`.



  Метод не генерирует исключения напрямую, но может пробросить исключения, сгенерированные внутренними вызовами, например, при ошибке остановки сервера.




  Метод `is_running` проверяет, активна ли текущая сессия драйвера.



  Возвращает `True` если текущая сессия драйвера активна, и `False` в противном случае.



  ```python
  if device.is_running():
      print("Устройство активно")
  else:
      print("Устройство не активно")
  ```



  Метод может генерировать исключения, в случае если `self.driver` не инициализирован. Также исключения могут быть сгенерированы внутренними вызовами метода `is_running` из объекта `self.driver`, например, при проблемах сети или сервера.




  Этот метод обеспечивает поиск элемента в текущей структуре DOM. Метод должен получать либо локатор, либо значения `by` и `value`.



  `locator`: Определяет локатор элемента. Это может быть:
  - кортеж - локатор в виде ('стратегия поиска', 'значение')
  - объект WebElement
  - словарь, содержащий пары атрибут: значение искомого элемента
  - строка - путь до файла с изображением элемента.

  `by`: Тип локатора для поиска элемента (всегда в связке с `value`). Может быть типом MobileBy, AppiumBy, By, или строкой.

  `value`: Значение локатора, если используется AppiumBy.XPATH. Может быть строкой, словарём или `None`.

  `timeout_elem`: Время ожидания элемента в секундах.

  `timeout_method`: Время ожидания метода поиска элемента в секундах.

  `elements_range`: Ограничивает поиск элемента в указанном диапазоне. Используется при поиске по изображению. Может быть кортежем, списком, словарём или `None`.

  `contains`: Используется для поиска по словарю. Если `True`, ищет элемент, содержащий фрагмент значения.



  Возвращает объект WebElementExtended или `None`, если элемент не был найден.



  ```python
  element = app.get_element(locator=("id", "foo"))
  element = app.get_element(element)
  element = app.get_element(locator={'text': 'foo'})
  element = app.get_element(locator='/path/to/file/pay_agent.png')
  element = app.get_element(locator=part_image, elements_range={'class':'android.widget.FrameLayout', 'package':'ru.app.debug'})
  element = app.get_element(by="id", value="ru.sigma.app.debug:id/backButton")
  element = app.get_element(by=MobileBy.ID, value="ru.sigma.app.debug:id/backButton")
  element = app.get_element(by=AppiumBy.ID, value="ru.sigma.app.debug:id/backButton")
  element = app.get_element(by=By.ID, value="ru.sigma.app.debug:id/backButton")
  ```



  Метод может генерировать исключения, в случае если введены некорректные аргументы или возникают ошибки при обработке элементов (например, `NoSuchElementException`, `TimeoutException` или `WebDriverException`).



  Этот метод используется для поиска элемента. Если элемент не найден, метод будет скроллить все скроллируемые элементы, пока не найдет искомый элемент или пока не будет проскроллено все доступное пространство.



  - `locator` (Union[Tuple, WebElement, 'WebElementExtended', Dict[str, str], str]): Это местоположение или определение элемента, который нужно найти. Это может быть кортеж, экземпляр WebElement, словарь или строка.

  - `timeout` (int, опционально): Это максимальное время ожидания для поиска элемента. По умолчанию это 10 секунд.



  Метод возвращает экземпляр `WebElementExtended`, если элемент найден. Если элемент не найден после прокрутки всей доступной страницы, возвращается `None`.



  ```python
  element = app.find_and_get_element(locator={'id': 'element_id'})
  ```



  Внутри этого метода сначала проверяется, виден ли элемент на экране с помощью `is_element_within_screen()`. Если это так, то элемент возвращается с помощью `get_element()`.

  Если элемент не виден на экране, то метод производит поиск во всех доступных для прокрутки элементах страницы. Если элемент найден в каком-то из этих элементов, он возвращается. Если элемент не найден после прокрутки всей доступной страницы, метод возвращает `None`.





  Этот метод обеспечивает поиск элементов в текущей структуре DOM. Метод может получать либо локатор, либо пару значений `by` и `value`.



  - `locator`: Определяет локатор элементов. Это может быть:
    - Кортеж - локатор в виде ('атрибут', 'значение')
    - Список объектов WebElement
    - Словарь, содержащий пары атрибут: значение
    - Строка - путь до файла с изображением элемента.
  - `by`: Тип локатора для поиска элемента (всегда используется в связке с `value`). Может быть типом MobileBy, AppiumBy, By, или строкой.
  - `value`: Значение локатора или словарь аргументов, если используется AppiumBy.XPATH. Может быть строкой, словарём или `None`.
  - `timeout_elements`: Время ожидания в секундах для появления каждого элемента.
  - `timeout_method`: Общее время ожидания в секундах для выполнения всего метода.
  - `elements_range`: Ограничивает поиск элементов в указанном диапазоне. Используется при поиске по изображению. Может быть кортежем, списком, словарём или `None`.
  - `contains`: Используется для поиска по словарю. Если `True`, ищет элементы, содержащие фрагмент значения.



  Возвращает список объектов WebElementExtended, или `None`, если элементы не были найдены.



  ```python
  elements = app.get_elements(locator=("id", "foo"))
  elements = app.get_elements(locator={'text': 'foo'})
  elements = app.get_elements(locator='/path/to/file/pay_agent.png')
  elements = app.get_elements(locator=part_image, elements_range={'class':'android.widget.FrameLayout', 'package':'ru.app.debug'})
  elements = app.get_elements(by="id", value="ru.sigma.app.debug:id/backButton")
  elements = app.get_elements(by=MobileBy.ID, value="ru.sigma.app.debug:id/backButton")
  elements = app.get_elements(by=AppiumBy.ID, value="ru.sigma.app.debug:id/backButton")
  elements = app.get_elements(by=By.ID, value="ru.sigma.app.debug:id/backButton")
  ```



  Метод может генерировать исключения, в случае если введены некорректные аргументы или возникают ошибки при обработке элементов (например, `NoSuchElementException`, `TimeoutException` или `WebDriverException`).




  Этот метод находит координаты наиболее вероятного совпадения частичного изображения в полном изображении. Используется для поиска элементов или участков интерфейса на экране по изображению.



  - `image`: Путь к файлу частичного изображения, которое нужно найти внутри полного изображения. Может быть байтами, массивом `np.ndarray`, объектом `Image.Image`, или строкой (путь к файлу).

  - `full_image`: Путь к файлу полного изображения. Может быть байтами, массивом `np.ndarray`, объектом `Image.Image`, или строкой (путь к файлу). Если `None`, то будет использовано текущее скриншотное изображение.

  - `threshold`: Минимальный порог совпадения, необходимый для считывания совпадения допустимым. По умолчанию равно 0.7.




  Возвращает кортеж с координатами наиболее вероятного совпадения в формате (x1, y1, x2, y2) или `None`, если совпадение не найдено.



  ```python
  coords = app.get_image_coordinates(image="/path/to/partial/image.png", full_image="/path/to/full/image.png", threshold=0.8)
  ```



  Этот метод использует декоратор `retry`, который выполняет функцию до тех пор, пока она не вернет результат, отличный от `None` или `False`, или пока не будет достигнуто максимальное количество попыток (3 попытки по умолчанию). После каждой неудачной попытки происходит пауза на 1 секунду.



  Метод может генерировать исключения при обработке изображений или при работе с файлами.



  Этот метод сначала находит изображение на экране (внешнее изображение), а затем находит другое изображение (внутреннее изображение) внутри обнаруженного изображения.



  - `outer_image_path`: Путь к файлу с изображением, которое нужно найти на экране. Может быть байтами, массивом `np.ndarray`, объектом `Image.Image`, или строкой (путь к файлу).

  - `inner_image_path`: Путь к файлу с изображением, которое нужно найти внутри внешнего изображения. Может быть байтами, массивом `np.ndarray`, объектом `Image.Image`, или строкой (путь к файлу).

  - `threshold`: Пороговое значение сходства для шаблонного сопоставления. По умолчанию 0.9.



  Возвращает координаты внутреннего изображения относительно экрана в формате ((x1, y1), (x2, y2)). Если внутреннее изображение не найдено, возвращает `None`.



  ```python
  coords = app.get_inner_image_coordinates(outer_image_path="/path/to/outer/image.png", inner_image_path="/path/to/inner/image.png", threshold=0.8)
  ```



  Этот метод использует декоратор `retry`, который выполняет функцию до тех пор, пока она не вернет результат, отличный от `None` или `False`, или пока не будет достигнуто максимальное количество попыток (3 попытки по умолчанию). После каждой неудачной попытки происходит пауза на 1 секунду.



  Метод может генерировать исключения при обработке изображений или при работе с файлами.




  Этот метод находит все вхождения частичного изображения внутри полного изображения.



  - `image`: Путь к файлу частичного изображения, которое нужно найти внутри полного изображения. Может быть байтами, массивом `np.ndarray`, объектом `Image.Image`, или строкой (путь к файлу).

  - `full_image`: Путь к файлу полного изображения. Может быть байтами, массивом `np.ndarray`, объектом `Image.Image`, или строкой (путь к файлу). Если `None`, то будет сделан скриншот экрана и использован как полное изображение.

  - `cv_threshold`: Минимальный порог совпадения, необходимый для считывания совпадения допустимым. По умолчанию равно 0.7.

  - `coord_threshold`: Целое число, представляющее максимальное различие между значениями x и y двух кортежей, чтобы они считались слишком близкими друг к другу. По умолчанию равно 5.



  Возвращает список кортежей, содержащий расположение каждого найденного совпадения. Если совпадений не найдено, возвращается `None`.



  ```python
  matches = app.get_many_coordinates_of_image(image="/path/to/image.png", full_image="/path/to/full/image.png", cv_threshold=0.7, coord_threshold=5)
  ```



  Этот метод использует декоратор `retry`, который выполняет функцию до тех пор, пока она не вернет результат, отличный от `None` или `False`, или пока не будет достигнуто максимальное количество попыток (3 попытки по умолчанию). После каждой неудачной попытки происходит пауза на 1 секунду.




  Метод может генерировать исключения при обработке изображений или при работе с файлами.




  Этот метод возвращает координаты области, содержащей указанный текст на предоставленном изображении или снимке экрана.



  - `text`: Искомый текст.

  - `language`: Язык для распознавания текста. По умолчанию 'rus'.

  - `image`: Изображение, на котором осуществляется поиск текста. Может быть байтами, строкой (путь к файлу), объектом `Image.Image` или массивом `np.ndarray`. Если не указано, будет использован снимок экрана. По умолчанию `None`.

  - `ocr`: Булев флаг, определяющий, следует ли использовать распознавание оптических символов (OCR) для извлечения текста из изображения. По умолчанию `True`.



  Возвращает кортеж из четырех целых чисел, представляющих координаты области с текстом (верхний левый угол и нижний правый угол). Если текст не найден, возвращается `None`.



  ```python
  coordinates = app.get_text_coordinates(text="Hello, world!", language="eng", image="/path/to/image.png", ocr=True)
  ```



  Если флаг `ocr` установлен в `False`, метод будет использовать внутреннюю реализацию поиска элемента для извлечения координат области, содержащей искомый текст.




  Этот метод возвращает текущий снимок экрана в браузере, декодированный из формата base64 в байты.



  Метод не требует никаких параметров.



  Возвращает байты, представляющие снимок экрана. Эти байты могут быть использованы для создания изображения.



  ```python
  screenshot = app._get_screenshot_as_base64_decoded()
  ```



  Этот метод используется внутри других методов класса для получения текущего снимка экрана при работе с изображениями.





  Этот метод пока не реализован. Ожидается, что он будет использоваться для поиска и возврата родительского элемента, который содержит определённый дочерний элемент.



  На данный момент в методе нет параметров.



  На данный момент метод возвращает ошибку `NotImplementedError` при вызове, так как он ещё не реализован.



  ```python

  ```



  В текущей реализации метод возвращает исключение `NotImplementedError` с сообщением "This method is not implemented yet". Это означает, что метод ещё не реализован. Предполагается, что в будущем он будет реализован для поиска и возврата родительского элемента, содержащего определённый дочерний элемент.





  Этот метод пока не реализован. Ожидается, что он будет использоваться для поиска и возврата всех родительских элементов, которые содержат определённые дочерние элементы.



  На данный момент в методе нет параметров.



  На данный момент метод возвращает ошибку `NotImplementedError` при вызове, так как он ещё не реализован.



  ```python

  ```



  В текущей реализации метод возвращает исключение `NotImplementedError` с сообщением "This method is not implemented yet". Это означает, что метод ещё не реализован. Предполагается, что в будущем он будет реализован для поиска и возврата всех родительских элементов, содержащих определённые дочерние элементы.




  Этот метод проверяет, находится ли заданный элемент полностью на экране.



  - `locator` (`Union[Tuple, WebElement, 'WebElementExtended', Dict[str, str], str]`): Локатор или элемент, который нужно проверить. Может быть кортежем, объектом WebElement, объектом WebElementExtended, словарем или строкой.
  - `timeout` (`int`, необязательный): Время ожидания появления элемента в секундах. По умолчанию равно 10.



  - `bool`: Возвращает `True`, если элемент находится на видимой части экрана, и `False` в противном случае.



  ```python

  is_visible = app.is_element_within_screen(locator=('id', 'some_id'))
  ```



  Метод сначала получает размеры экрана, затем ищет элемент с помощью предоставленного локатора. Если элемент не найден или не отображается, метод возвращает `False`. Если элемент найден и отображается, метод проверяет, находятся ли координаты элемента в пределах размеров экрана. Если элемент находится за пределами экрана, метод возвращает `False`. В противном случае, если элемент находится в пределах видимой области экрана, метод возвращает `True`.




  Этот метод проверяет, присутствует ли заданный текст на экране.



  - `text` (`str`): Текст, который нужно найти на экране.
  - `ocr` (`bool`, необязательный): Определяет, производить ли поиск текста на изображении или в DOM. Если `True`, распознавание текста производится с помощью библиотеки `pytesseract`. Если `False`, производится поиск элемента по xpath. Значение по умолчанию: `True`.
  - `language` (`str`, необязательный): Язык для распознавания текста. По умолчанию 'rus'.



  - `bool`: Возвращает `True`, если заданный текст найден на экране. В противном случае возвращает `False`.



  ```python

  is_present = app.is_text_on_screen(text='Hello')
  ```



  Метод использует разные подходы в зависимости от значения параметра `ocr`. Если `ocr=True`, то он использует библиотеку `pytesseract` для распознавания текста на изображении экрана. Если `ocr=False`, то он производит поиск элемента по xpath, используя текст как значение атрибута 'text' элемента.




  Этот метод сравнивает, присутствует ли заданное изображение на экране.



  - `image` (`Union[bytes, np.ndarray, Image.Image, str]`): Изображение для поиска. Это может быть имя файла, байтовый поток, массив numpy или объект PIL Image.
  - `threshold` (`float`, необязательный): Пороговое значение схожести части изображения со снимком экрана. По умолчанию 0.9.



  - `bool`: Возвращает `True`, если изображение найдено на экране. В противном случае возвращает `False`.



  ```python

  is_present = app._is_image_on_the_screen(image='button.png')
  ```



  Метод сначала делает снимок текущего экрана, затем преобразует его и искомое изображение в оттенки серого для лучшего сопоставления. Затем используется метод `cv2.matchTemplate` для сопоставления мелкого изображения и снимка экрана. Затем используется `cv2.minMaxLoc` для извлечения максимального коэффициента схожести и его координат. Если максимальное значение превышает заданный порог, метод возвращает `True`, в противном случае `False`.



  Этот метод выполняет действие "тап" или "клик" по определенным координатам, элементу или изображению на экране.



  - `locator` (`Union[Tuple[str, str], WebElementExtended, WebElement, Dict[str, str], str]`, необязательный): Элемент или локатор, на который нужно нажать.
  - `x` (`int`, необязательный): X координата точки, по которой следует нажать.
  - `y` (`int`, необязательный): Y координата точки, по которой следует нажать.
  - `image` (`Union[bytes, np.ndarray, Image.Image, str]`, необязательный): Изображение, на котором следует нажать.
  - `duration` (`Optional[int]`, необязательный): Продолжительность нажатия в миллисекундах.
  - `timeout` (`int`, необязательный): Время ожидания в секундах перед тем как метод вернет `None`, если изображение не найдено на экране. По умолчанию равно 5.



  - `Union['AppiumExtended', None]`: Возвращает экземпляр класса `AppiumExtended`, если действие "тап" или "клик" успешно выполнено. В противном случае возвращает `None`.



  ```python

  app.tap(locator=('id', 'button'))


  app.tap(x=100, y=200)


  app.tap(image='button.png')
  ```



  Этот метод использует внутренний метод `_extract_point_coordinates_by_typing()` для получения координат точки, по которой следует нажать, если был передан `locator` или `image`. Если указано изображение, метод будет ожидать его появления на экране в течение указанного времени ожидания, прежде чем выполнить действие "тап". Затем вызывается внутренний метод `_tap()` для выполнения действия "тап" по заданным координатам.



  Этот метод выполняет свайп (перетаскивание) элемента или изображения на экране.



  - `start_position`: Позиция начала свайпа. Может быть задана в различных форматах:
    - Если `start_position` является кортежем и оба его элемента являются строками, то он представляет собой локатор элемента. В этом случае будет выполнен поиск элемента и используется его позиция.
    - Если `start_position` является словарем, то считается, что это локатор элемента, основанный на атрибутах. Например, {'text': 'some text'} или {'class': 'SomeClass', 'visible': 'true'}. В этом случае будет выполнен поиск элемента по указанным атрибутам, и используется его позиция.
    - Если `start_position` является экземпляром класса WebElement или WebElementExtended, то используется его позиция.
    - Если `start_position` является строкой, массивом байтов (bytes), массивом NumPy (np.ndarray) или объектом класса Image.Image, то считается, что это изображение. В этом случае будет вычислен центр изображения и используется его позиция.
    - Если `start_position` является кортежем, и оба его элемента являются целыми числами, то считается, что это координаты в формате (x_coordinate, y_coordinate).
  - `end_position`: Позиция конца свайпа. Принимает те же форматы, что и `start_position`. По умолчанию None.
  - `direction`: Направление свайпа. Принимает значения от 0 до 360 градусов. Если указано направление, то будет вычислена конечная точка свайпа на основе текущего размера окна и указанного расстояния. По умолчанию None.
  - `distance`: Расстояние свайпа. Принимается в пикселях. Используется только в сочетании с параметром `direction`. По умолчанию None.
  - `duration`: Продолжительность свайпа в миллисекундах. По умолчанию 0.



  - `AppiumExtended`: Экземпляр класса AppiumExtended.



  - В качестве конечной позиции свайпа должен быть указан `end_position` или пара `direction, distance`.
  - `str` принимается как путь к изображению на экране и вычисляется его центр, а не как локатор элемента



  ```python

  app.swipe(start_position=(100, 200), end_position=(300, 400))


  app.swipe(start_position=('xpath', '//button[@id="submit"]'), direction=90, distance=100)


  app.swipe(start_position='image.png', end_position=(300, 400))
  ```



  Метод обязательно должен принимать либо end_postition, либо direction и distance



  Этот метод выполняет свайп (перетаскивание) с верхней части экрана к нижней.



  Метод не принимает параметров.



  - `None`



  - Метод использует функцию `adb.get_screen_resolution()` для определения размера экрана.
  - Позиция начала свайпа (`start_position`) вычисляется как 10% от высоты экрана.
  - Позиция конца свайпа (`end_position`) вычисляется как 90% от высоты экрана.



  ```python

  app.swipe_top_to_bottom()
  ```



  Этот метод выполняет свайп (перетаскивание) с нижней части экрана к верхней.



  Метод не принимает параметров.



  - `None`



  - Метод использует функцию `adb.get_screen_resolution()` для определения размера экрана.
  - Позиция начала свайпа (`start_position`) вычисляется как 90% от высоты экрана.
  - Позиция конца свайпа (`end_position`) вычисляется как 10% от высоты экрана.
  - Может использоваться для выдвигания шторки.



  ```python

  app.swipe_bottom_to_top()
  ```




  Этот метод выполняет свайп (перетаскивание) с правой части экрана к левой.



  Метод не принимает параметров.



  - `None`



  - Метод использует функцию `adb.get_screen_resolution()` для определения размера экрана.
  - Позиция начала свайпа (`start_position`) вычисляется как 90% от ширины экрана.
  - Позиция конца свайпа (`end_position`) вычисляется как 10% от ширины экрана.



  ```python

  app.swipe_right_to_left()
  ```



  Этот метод выполняет свайп (перетаскивание) с левой части экрана к правой.



  Метод не принимает параметров.



  - `None`



  - Метод использует функцию `adb.get_screen_resolution()` для определения размера экрана.
  - Позиция начала свайпа (`start_position`) вычисляется как 10% от ширины экрана.
  - Позиция конца свайпа (`end_position`) вычисляется как 90% от ширины экрана.



  ```python

  app.swipe_left_to_right()
  ```




  Этот метод ожидает появления на экране указанного локатора или изображения.



  - `locator`: Локатор(ы), которые нужно ожидать. Может быть одним локатором или списком локаторов. Принимает форматы, аналогичные `start_position` в методе `swipe()`. По умолчанию None.
  - `image`: Изображение(я), которые нужно ожидать. Может быть одним изображением или списком изображений. Принимает строку, массив байтов (bytes), массив NumPy (np.ndarray) или объект класса Image.Image. По умолчанию None.
  - `timeout`: Максимальное время ожидания в секундах. По умолчанию 10.
  - `contains`: Если True, проверяет, содержит ли элемент указанный локатор. Если False, проверяет, точно ли соответствует элемент указанному локатору. По умолчанию True.
  - `full_image`: Основное изображение, на котором будет искаться `image`. Принимает строку, массив байтов (bytes), массив NumPy (np.ndarray) или объект класса Image.Image. По умолчанию None.



  - `bool`: True, если элемент(ы) или изображение(я) найдены в течение периода ожидания, иначе False.



  - Этот метод использует приватный метод `_wait_for()`, который реализует основную логику ожидания.



  ```python

  app.wait_for(locator=('xpath', '//button[@id="submit"]'), timeout=30)


  app.wait_for(image='image.png', timeout=20)


  app.wait_for(locator=[('id', 'button1'), ('id', 'button2')], image=['image1.png', 'image2.png'], timeout=40)
  ```




  Этот метод ожидает, пока указанный локатор или изображение не исчезнет с экрана или из DOM.



  - `locator`: Локатор(ы), которые нужно ожидать. Может быть одним локатором или списком локаторов. Принимает форматы, аналогичные `start_position` в методе `swipe()`. По умолчанию None.
  - `image`: Изображение(я), которые нужно ожидать. Может быть одним изображением или списком изображений. Принимает строку, массив байтов (bytes), массив NumPy (np.ndarray) или объект класса Image.Image. По умолчанию None.
  - `timeout`: Максимальное время ожидания в секундах. По умолчанию 10.
  - `contains`: Если True, проверяет, содержит ли элемент указанный локатор. Если False, проверяет, точно ли соответствует элемент указанному локатору. По умолчанию True.



  - `bool`: True, если элемент(ы) или изображение(я) исчезли в течение периода ожидания, иначе False.



  ```python

  app.wait_for_not(locator=('xpath', '//button[@id="submit"]'), timeout=30)


  app.wait_for_not(image='image.png', timeout=20)


  app.wait_for_not(locator=[('id', 'button1'), ('id', 'button2')], image=['image1.png', 'image2.png'], timeout=40)
  ```




  Этот метод ожидает, когда другой метод вернет True.



  - `method`: ссылка на метод, который мы ожидаем.
  - `timeout`: максимальное время ожидания в секундах. По умолчанию равно 10.



  - `bool`: возвращает True, если метод возвращает True в течение периода времени, указанного в timeout. В противном случае возвращает False.



  ```python

  result = AppiumExtended.wait_return_true(obj.check_login_status, timeout=20)



  app.wait_return_true(obj.is_connected, timeout=30)
  ```

  Обратите внимание, что это статический метод, что означает, что он принадлежит классу, а не экземпляру класса. Это значит, что вам не нужен экземпляр класса, чтобы вызвать этот метод. Вы можете просто вызвать его на самом классе, как показано в примере выше.




  Этот метод рисует прямоугольник на указанном изображении или скриншоте экрана. Прямоугольник задается координатами или верхней левой и нижней правой точками. Результирующее изображение сохраняется по указанному пути.



  - `image`: Изображение, на котором будет рисоваться прямоугольник. Может быть представлено в форматах bytes, str (путь к файлу) или PIL Image. Если не указано, используется скриншот экрана. По умолчанию равно None.
  - `coordinates`: Координаты прямоугольника в виде кортежа (x1, y1, x2, y2). По умолчанию равно None.
  - `top_left`: Координаты верхней левой точки прямоугольника в виде кортежа (x, y). По умолчанию равно None.
  - `bottom_right`: Координаты нижней правой точки прямоугольника в виде кортежа (x, y). По умолчанию равно None.
  - `path`: Путь для сохранения результирующего изображения. По умолчанию равно None.



  - `AppiumExtended`: Возвращает экземпляр класса `AppiumExtended` для дальнейших вызовов методов.



  ```python
  appium_extended = AppiumExtended(driver)
  image = driver.get_screenshot_as_base64().encode('utf-8')
  appium_extended.draw_by_coordinates(image=image, coordinates=(123, 123, 123, 123), path='pictures')
  ```

  В этом примере мы делаем скриншот экрана, рисуем на нем прямоугольник с указанными координатами и сохраняем полученное изображение в директории "pictures".




  Этот метод пока не реализован. Ожидается, что он будет использоваться для поиска и возврата родительского элемента, который содержит определённый дочерний элемент.



  На данный момент в методе нет параметров.



  На данный момент метод возвращает ошибку `NotImplementedError` при вызове, так как он ещё не реализован.



  ```python

  ```



  В текущей реализации метод возвращает исключение `NotImplementedError` с сообщением "This method is not implemented yet". Это означает, что метод ещё не реализован. Предполагается, что в будущем он будет реализован для ввода данных с помощью виртуальной клавиатуры.




  `WebElementExtended` - это класс, расширяющий базовый класс `WebElement` дополнительными возможностями. Он объединяет несколько классов, предоставляя различные методы взаимодействия с веб-элементами.
  Инициализируется в AppiumExtended.



  Этот метод извлекает элемент из другого элемента. Должен принимать как минимум либо локатор, либо значения параметров by и value.



  - `locator`: Определяет локатор элемента. Может быть кортежем, WebElement, словарем или строкой.
      - Кортеж: Локатор в форме ('стратегия', 'значение'), например, ('xpath', '//*'), ('id', 'elem_id') и т.д.
      - WebElement / WebElementExtended: Объект веб-элемента.
      - Словарь: Содержит пары атрибут: значение элемента, например, {'text':'foo', 'enabled':'true'}.
      - Строка: Путь до файла с изображением элемента.
      - По умолчанию: None.
  - `by`: Тип локатора для поиска элемента. Используется в связке с параметром `value`. Может быть MobileBy, AppiumBy, By или строкой. По умолчанию: None.
  - `value`: Значение локатора или словарь аргументов, если используется AppiumBy.XPATH. Может быть строкой, словарем или None. По умолчанию: None.
  - `timeout_elem`: Максимальное время ожидания элемента в секундах. По умолчанию: 10.
  - `timeout_method`: Максимальное время ожидания выполнения метода поиска элемента в секундах. По умолчанию: 600.
  - `elements_range`: Ограничивает поиск элемента в указанном диапазоне (для поиска по изображению). Может быть кортежем, списком, словарем или None. По умолчанию: None.
  - `contains`: Если True, проверяет, содержит ли элемент указанные атрибуты. Если False, проверяет, точно ли соответствует элемент указанным атрибутам. По умолчанию: True.



  - `WebElementExtended` или `None`: Возвращает WebElementExtended, если элемент был найден в течение указанного времени ожидания, в противном случае возвращает None.



  - Этот метод использует внутренний метод для реализации основной логики поиска элементов.



  ```python

  inner_element = element.get_element(locator=("id", "foo"), timeout_elem=30)


  inner_element = element.get_element(locator=element, timeout_elem=20)


  inner_element = element.get_element(locator={'text': 'foo'}, elements_range={'class':'android.widget.FrameLayout', 'package':'ru.app.debug'}, timeout_elem=40)
  ```



  Этот метод получает атрибуты элемента. Если хотя бы один из желаемых атрибутов не найден, метод возвращает все атрибуты элемента.



  - `desired_attributes`: Список названий атрибутов, которые нужно получить. Если параметр не указан, метод вернет все атрибуты элемента. По умолчанию: None.



  - `dict`: Словарь, содержащий атрибуты элемента и их значения. Если указан `desired_attributes` и соответствующие атрибуты найдены у элемента, возвращает словарь только с запрашиваемыми атрибутами. Если `desired_attributes` не указан или желаемый атрибут не найден, возвращает словарь со всеми атрибутами.



  ```python

  attributes = element.get_attributes(['text', 'bounds', 'class'])


  all_attributes = element.get_attributes()
  ```



  Этот метод осуществляет нажатие на заданный элемент.



  - `duration`: Время нажатия в секундах. Если параметр равен нулю, осуществляется обычное нажатие, иначе происходит нажатие с удержанием на указанное количество секунд. По умолчанию равно 0.
  - `decorator_args`: Параметры для декоратора, включая время ожидания нового окна (`timeout_window`) и количество попыток нажатия (`tries`). Используется только при `wait = True`. По умолчанию None.
  - `wait`: Флаг, указывающий, следует ли ожидать изменения окна после нажатия. Если `True`, будет использован метод `_click_to_element_and_wait()`, иначе `_click_to_element()`. По умолчанию False.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  - В случае, если указан `wait = True` и не предоставлены `decorator_args`, используются стандартные параметры декоратора: `timeout_window` равно 5 и `tries` равно 5.



  ```python

  decorator_args = {"timeout_window": 5, "tries": 5}
  element.click(duration=0, wait=True, decorator_args=decorator_args)
  ```



  Этот метод выполняет двойное нажатие (double click) на заданный элемент.



  - `decorator_args`: Параметры для декоратора, включая время ожидания нового окна (`timeout_window`) и количество попыток нажатия (`tries`). Используется только при `wait = True`. По умолчанию `timeout_window` равно 5 и `tries` равно 5.
  - `wait`: Флаг, указывающий, следует ли ожидать изменения окна после нажатия. Если `True`, будет использован метод `_double_click_to_element_and_wait()`, иначе `_double_click_to_element()`. По умолчанию False.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  - В случае, если указан `wait = True` и не предоставлены `decorator_args`, используются стандартные параметры декоратора: `timeout_window` равно 5 и `tries` равно 5.



  ```python

  element.double_click(wait=False)


  decorator_args = {"timeout_window": 7, "tries": 3}
  element.double_click(wait=True, decorator_args=decorator_args)
  ```



  Этот метод нажимает левую кнопку мыши, перемещает курсор к указанной цели и отпускает кнопку.



  - `locator`: Локатор для поиска целевого элемента на веб-странице. Он может быть кортежем, `WebElement`, `WebElementExtended`, словарем или строкой. Не обязательный параметр.
  - `x`: Абсолютная координата по оси X для перемещения курсора. Не обязательный параметр.
  - `y`: Абсолютная координата по оси Y для перемещения курсора. Не обязательный параметр.
  - `direction`: Направление в градусах для перемещения курсора, где 0/360 - вверх, 90 - вправо, 180 - вниз, 270 - влево. Не обязательный параметр.
  - `distance`: Расстояние в пикселях для перемещения курсора. Не обязательный параметр.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.click_and_move(locator="//button[@id='submit']")


  element.click_and_move(x=100, y=200)


  element.click_and_move(direction=90, distance=100)
  ```



  Целью перемещения может быть WebElement, абсолютные координаты (x, y) или направление и расстояние. Если предоставлены направление и расстояние, функция вычисляет целевую позицию на основе вектора, определенного этими значениями. Если предоставлены абсолютные координаты (x, y), курсор перемещается в указанные позиции. Если предоставлен локатор, функция перемещается к найденному элементу на веб-странице.



  Deprecated!
  Метод устарел. Будет удален в следующих версиях.
  Вместо него будет реализован метод выполняющий нажатие через driver.execute_script()

  Этот метод выполняет нажатие на элемент, используя ADB (Android Debug Bridge).




  - `decorator_args`: Дополнительные аргументы для использования в декораторе. Это словарь, который может содержать следующие ключи:
    - `timeout_window`: Время ожидания нового окна (умножается на количество попыток).
    - `tries`: Количество попыток нажатия (по умолчанию 3).
    Этот параметр не обязателен.
  - `wait`: Флаг, указывающий, нужно ли ожидать изменения окна. Необязательный параметр, по умолчанию False.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.adb_tap()


  element.adb_tap(wait=True)


  element.adb_tap(decorator_args={"timeout_window": 5, "tries": 5}, wait=True)
  ```



  ADB (Android Debug Bridge) - это инструмент командной строки, который используется для взаимодействия с устройством. В данном контексте он используется для симуляции взаимодействия пользователя с интерфейсом Android.



  Этот метод выполняет многократные нажатия (обычно два или три) на элемент, используя ADB (Android Debug Bridge).



  - `decorator_args (dict, optional)`: Дополнительные аргументы для декоратора. Если `None`, то будут преобразованы в `decorator_args = {"timeout_window": 5, "tries": 5}`, где `timeout_window` - время ожидания изменения окна в секундах, а `tries` - количество попыток выполнения метода для изменения окна.
  - `wait (bool, optional)`: Флаг, указывающий, нужно ли ожидать изменение окна после нажатия. По умолчанию `False`.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.adb_multi_tap(decorator_args={"timeout_window": 10, "tries": 3}, wait=True)
  ```



  ADB (Android Debug Bridge) - это инструмент командной строки, который используется для взаимодействия с устройством. В данном контексте он используется для симуляции взаимодействия пользователя с интерфейсом Android. Многократные нажатия могут быть полезны для выделения текста или активации специальных функций в приложении.



  Этот метод выполняет свайп (прокрутку) на элементе или по определенному направлению, используя ADB (Android Debug Bridge).



  - `locator (Union[Tuple, WebElement, 'WebElementExtended', Dict[str, str], str], optional)`: Локатор элемента, к которому необходимо прокрутить. Это может быть `Tuple`, `WebElement`, `WebElementExtended`, словарь с `str` или просто `str`. Если `None`, прокрутка производится от центра корневого элемента.
  - `x (int, optional)`: Координата X целевой позиции прокрутки.
  - `y (int, optional)`: Координата Y целевой позиции прокрутки.
  - `direction (int, optional)`: Направление прокрутки в градусах (от 0 до 360).
  - `distance (int, optional)`: Расстояние прокрутки в пикселях.
  - `duration (int, optional)`: Длительность прокрутки в секундах. По умолчанию равна 1.
  - `contains (bool, optional)`: Флаг, указывающий, должен ли локатор содержать текст элемента. По умолчанию `True`.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.adb_swipe(locator="Submit", duration=2)


  element.adb_swipe(direction=180, distance=500, duration=1)
  ```



  ADB (Android Debug Bridge) - это инструмент командной строки, который используется для взаимодействия с устройством. В данном контексте он используется для симуляции взаимодействия пользователя с интерфейсом Android. Прокрутка может быть полезной для навигации по странице или меню приложения.



  Этот метод выполняет нажатие (tap) на центре данного веб-элемента.



  - `duration (int, optional)`: Длительность нажатия в миллисекундах. По умолчанию равна 0 (моментальное нажатие).
  - `decorator_args (dict, optional)`: Дополнительные аргументы для использования в декораторе. По умолчанию равно `None`. Если необходимо ожидание результата после нажатия, в словаре можно указать "timeout_window" - время ожидания изменения окна, и "tries" - количество попыток для изменения окна.
  - `wait (bool, optional)`: Флаг, указывающий, следует ли ожидать результат после нажатия. По умолчанию равно `False`.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.tap()


  element.tap(duration=500)


  element.tap(duration=500, decorator_args={"timeout_window": 5, "tries": 5}, wait=True)
  ```



  Методы `_tap`, `_tap_to_element_and_wait`, `_tap_to_element` и `__tap` используются внутри этого метода для выполнения нажатия и обработки различных сценариев, связанных с ожиданием результатов и обработкой исключений.



  Этот метод выполняет двойное нажатие (double tap) на центре данного веб-элемента.



  - `decorator_args (dict, optional)`: Дополнительные аргументы для использования в декораторе. По умолчанию равно `None`. Если необходимо ожидание результата после нажатия, в словаре можно указать "timeout_window" - время ожидания изменения окна, и "tries" - количество попыток для изменения окна.
  - `wait (bool, optional)`: Флаг, указывающий, следует ли ожидать результат после нажатия. По умолчанию равно `False`.
  - `pause (float, optional)`: Пауза между двумя нажатиями в секундах. По умолчанию равно 0.2.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.double_tap(pause=0.3)


  element.double_tap(decorator_args={"timeout_window": 5, "tries": 5}, wait=True, pause=0.3)
  ```



  Методы `_double_tap`, `_double_tap_to_element_and_wait`, `_double_tap_to_element` и `__double_tap` используются внутри этого метода для выполнения двойного нажатия и обработки различных сценариев, связанных с ожиданием результатов и обработкой исключений.



  Этот метод выполняет операцию "нажать и переместить" на веб-элементе или на указанных координатах.



  - `locator (Union[Tuple, WebElement, 'WebElementExtended', Dict[str, str], str], optional)`: Локатор элемента, на который будет выполнено нажатие и перемещение. По умолчанию равно `None`.
  - `x (int, optional)`: Координата X для нажатия и перемещения. По умолчанию равно `None`.
  - `y (int, optional)`: Координата Y для нажатия и перемещения. По умолчанию равно `None`.
  - `direction (int, optional)`: Направление перемещения в градусах (0 - вверх, 90 - вправо, 180 - вниз, 270 - влево). По умолчанию равно `None`.
  - `distance (int, optional)`: Расстояние перемещения в пикселях. По умолчанию равно `None`.



  - Возвращает экземпляр `WebElementExtended`, представляющий элемент, на котором было произведено действие.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  element.tap_and_move(locator=("xpath", "//div[@class='target']"))


  element.tap_and_move(x=50, y=100)


  element.tap_and_move(direction=180, distance=200)
  ```



  Метод `_tap_and_move` используется внутри этого метода для выполнения нажатия и перемещения, обработки различных сценариев в зависимости от предоставленных аргументов и обработки исключений.



  Этот метод обеспечивает поиск элементов в элементе.



  - `locator (Union[Tuple, List[WebElement], Dict[str, str], str], optional)`: Локатор элементов. Может быть кортежем, списком Веб-Элементов, словарем с атрибутом и значением, или строкой как путь до файла с изображением элемента. По умолчанию равно `None`.
  - `by (Union[MobileBy, AppiumBy, By, str], optional)`: Тип локатора для поиска элемента (всегда в связке с `value`). По умолчанию равно `None`.
  - `value (Union[str, Dict, None], optional)`: Значение локатора или словарь аргументов, если используется `AppiumBy.XPATH`. По умолчанию равно `None`.
  - `timeout_elements (int, optional)`: Время ожидания для поиска каждого отдельного элемента. По умолчанию равно `10`.
  - `timeout_method (int, optional)`: Общее время ожидания метода. По умолчанию равно `600`.
  - `elements_range (Union[Tuple, List[WebElement], Dict[str, str], None], optional)`: Диапазон для поиска элементов. По умолчанию равно `None`.
  - `contains (bool, optional)`: Если `True`, то поиск будет осуществляться по фрагменту текста или атрибута, а не их полному соответствию. По умолчанию равно `True`.



  - Возвращает список экземпляров `WebElementExtended`, представляющих найденные элементы. В случае, если элементы не найдены, возвращает пустой список.



  ```python

  elements = app.get_elements(locator=("id", "foo"))


  elements = app.get_elements(locator={'text': 'foo'})


  elements = app.get_elements(locator='/path/to/file/pay_agent.png')


  elements = app.get_elements(by="id", value="ru.sigma.app.debug:id/backButton")
  ```



  Этот метод выполняет скроллинг элемента вниз. Тап и ведение от нижнего внутреннего элемента до верхнего внутреннего элемента.



  - `locator (Union[Tuple, WebElementExtended, Dict[str, str], str], optional)`: Локатор или элемент для прокрутки. Может быть кортежем, экземпляром `WebElementExtended`, словарем с атрибутом и значением, или строкой. Если не указан, то будет вычислен автоматически. По умолчанию равно `None`.
  - `duration (int, optional)`: Продолжительность прокрутки в миллисекундах. Если не указана, прокрутка будет произведена без задержки. По умолчанию равно `None`.



  - Возвращает экземпляр `WebElementExtended`, если скроллинг выполнен успешно.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  app.scroll_down(locator=("id", "foo"), duration=1000)


  element = app.get_element(locator=("id", "foo"))
  app.scroll_down(locator=element, duration=1000)


  app.scroll_down(locator={'class': 'foo'}, duration=1000)
  ```



  Этот метод выполняет скроллинг элемента вверх.  Тап и ведение от верхнего внутреннего элемента до нижнего внутреннего элемента.



  - `locator (Union[Tuple, WebElementExtended, Dict[str, str], str], optional)`: Локатор или элемент для прокрутки. Может быть кортежем, экземпляром `WebElementExtended`, словарем с атрибутом и значением, или строкой. Если не указан, то будет вычислен автоматически. По умолчанию равно `None`.
  - `duration (int, optional)`: Продолжительность прокрутки в миллисекундах. Если не указана, прокрутка будет произведена без задержки. По умолчанию равно `None`.



  - Возвращает экземпляр `WebElementExtended`, если скроллинг выполнен успешно.
  - В случае, если не удалось выполнить действие, генерируется AssertionError.



  ```python

  app.scroll_up(locator=("id", "foo"), duration=1000)


  element = app.get_element(locator=("id", "foo"))
  app.scroll_up(locator=element, duration=1000)


  app.scroll_up(locator={'class': 'foo'}, duration=1000)
  ```



  Этот метод выполняет скроллинг элемента до самого нижнего положения.



  - `locator (Union[Tuple, WebElementExtended, Dict[str, str], str], optional)`: Локатор или элемент для прокрутки. Может быть кортежем, экземпляром `WebElementExtended`, словарем с атрибутом и значением, или строкой. По умолчанию равно `None`.
  - `timeout_method (int, optional)`: Время ожидания выполнения метода в секундах. Если время ожидания истекает, а скроллинг не достигает нижнего положения, метод возвращает ошибку. По умолчанию равно `120`.



  - Возвращает экземпляр `WebElementExtended`, если скроллинг выполнен успешно. В случае ошибки выбрасывает исключение AsserionError.



  ```python

  app.scroll_to_bottom(locator=("id", "foo"), timeout_method=120)


  element = app.get_element(locator=("id", "foo"))
  app.scroll_to_bottom(locator=element, timeout_method=120)


  app.scroll_to_bottom(locator={'class': 'foo'}, timeout_method=120)
  ```



  Этот метод выполняет скроллинг элемента до самого верхнего положения.



  - `locator (Union[Tuple, WebElementExtended, Dict[str, str], str], optional)`: Локатор или элемент для прокрутки. Может быть кортежем, экземпляром `WebElementExtended`, словарем с атрибутом и значением, или строкой. По умолчанию равно `None`.
  - `timeout_method (int, optional)`: Время ожидания выполнения метода в секундах. Если время ожидания истекает, а скроллинг не достигает верхнего положения, метод возвращает ошибку. По умолчанию равно `120`.



  - Возвращает экземпляр `WebElementExtended`, если скроллинг выполнен успешно. В случае ошибки выбрасывает исключение AssertionError.



  ```python

  app.scroll_to_top(locator=("id", "foo"), timeout_method=120)


  element = app.get_element(locator=("id", "foo"))
  app.scroll_to_top(locator=element, timeout_method=120)


  app.scroll_to_top(locator={'class': 'foo'}, timeout_method=120)
  ```




  Этот метод выполняет скроллинг элемента вниз и вверх, пока не найдет элемент, указанный в аргументе `locator`, или пока не истечет таймаут.



  - `locator (Union[Tuple, WebElementExtended, Dict[str, str], str])`: Локатор или элемент, который следует найти. Может быть кортежем, экземпляром `WebElementExtended`, словарем с атрибутом и значением, или строкой.
  - `roll_locator (Union[Tuple, WebElementExtended, Dict[str, str], str], optional)`: Локатор или элемент, который следует прокручивать. Если не указан, прокручивается первый дочерний элемент. Может быть кортежем, экземпляром `WebElementExtended`, словарем с атрибутом и значением, или строкой. По умолчанию равно `None`.
  - `timeout_method (int, optional)`: Время ожидания выполнения метода в секундах. Если время ожидания истекает, а элемент не найден, метод возвращает `None`. По умолчанию равно `120`.



  - Возвращает экземпляр `WebElementExtended`, если элемент найден. Возвращает `None`, если элемент не найден в течение заданного времени.



  ```python

  app.scroll_until_find(locator=("id", "target"), roll_locator=("id", "foo"), timeout_method=120)


  element_to_find = app.get_element(locator=("id", "target"))
  element_to_scroll = app.get_element(locator=("id", "foo"))
  app.scroll_until_find(locator=element_to_find, roll_locator=element_to_scroll, timeout_method=120)


  app.scroll_until_find(locator={'class': 'target'}, roll_locator={'class': 'foo'}, timeout_method=120)
  ```



  Этот метод возвращает первый родительский элемент текущего элемента в дереве DOM.



  Метод не принимает никаких аргументов.



  - Возвращает экземпляр `WebElementExtended`, который представляет родительский элемент.



  ```python

  parent_element = app.get_parent()
  ```



  Этот метод возвращает все родительские элементы текущего элемента в дереве DOM, начиная от ближайшего и до корневого элемента.



  Метод не принимает никаких аргументов.



  - Возвращает список экземпляров `WebElementExtended`, каждый из которых представляет родительский элемент на различных уровнях вверх по дереву DOM.



  ```python

  parent_elements = app.get_parents()
  ```



  Этот метод возвращает соседний (родственный) элемент текущего элемента, соответствующий заданным атрибутам. Возвращаются только непосредственные соседи (братья или сестры) в пределах того же родительского элемента.



  - `attributes` (`dict`): Словарь, содержащий атрибуты и их значения, которые должны быть найдены у искомого соседнего элемента. Например, `{'class': 'myClass', 'name': 'myName'}` ищет элемент, у которого атрибут `class` равен `myClass` и `name` равен `myName`.

  - `contains` (`bool`, необязательный): Флаг, указывающий, использовать ли функцию `contains` XPath для атрибутов. Если `True`, метод будет искать элементы, значение атрибута которых содержит указанное значение (а не полное совпадение). По умолчанию равно `True`.



  - Возвращает экземпляр `WebElementExtended`, представляющий найденный соседний элемент. Если такой элемент не найден, возвращается `None`.



  ```python

  sibling_element = app.get_sibling({'class': 'myClass'})


  sibling_element = app.get_sibling({'name': 'myName'}, contains=True)
  ```



  Этот метод возвращает все соседние (родственные) элементы текущего элемента. Возвращаются только непосредственные соседи (братья или сестры) в пределах того же родительского элемента.



  Метод не требует аргументов.



  - Возвращает список экземпляров `WebElementExtended`, каждый из которых представляет одного из родственных элементов текущего элемента. Если таких элементов не найдено, возвращается пустой список.



  ```python

  sibling_elements = app.get_siblings()
  ```



  Этот метод предназначен для поиска "кузена" текущего элемента в дереве DOM. Кузен в данном контексте определяется как элемент, находящийся на одинаковом уровне вложенности от общего предка.



  - `ancestor` - Предок, относительно которого определяется "кузенство". Может быть представлен в виде кортежа (списка атрибутов и их значений), экземпляра WebElement или WebElementExtended, словаря (атрибутов и их значений) или строки (XPath выражения).

  - `cousin` - Словарь атрибутов, определяющий искомого кузена. Ключи словаря - это названия атрибутов, значения - соответствующие значения этих атрибутов.

  - `contains` - Булевый флаг, который определяет, следует ли использовать функцию `contains` при формировании XPath выражения для поиска кузена. Если `True`, то будет искаться частичное совпадение атрибутов. Если `False`, то будет искаться полное совпадение. По умолчанию `True`.



  - Возвращает экземпляр `WebElementExtended`, представляющий кузена текущего элемента. Если кузен не найден, возвращается `None`.



  ```python

  cousin_element = app.get_cousin(ancestor={'class': 'parent-class'}, cousin={'class': 'desired-class'})
  ```



  Этот метод предназначен для поиска "кузенов" текущего элемента в дереве DOM. Кузен в данном контексте определяется как элемент, находящийся на одинаковом уровне вложенности от общего предка.



  - `ancestor` - Предок, относительно которого определяется "кузенство". Может быть представлен в виде кортежа (списка атрибутов и их значений), экземпляра WebElement или WebElementExtended, словаря (атрибутов и их значений) или строки (XPath выражения).

  - `cousin` - Словарь атрибутов, определяющий искомого кузена. Ключи словаря - это названия атрибутов, значения - соответствующие значения этих атрибутов.

  - `contains` - Булевый флаг, который определяет, следует ли использовать функцию `contains` при формировании XPath выражения для поиска кузенов. Если `True`, то будет искаться частичное совпадение атрибутов. Если `False`, то будет искаться полное совпадение. По умолчанию `True`.



  - Возвращает список экземпляров `WebElementExtended`, представляющих кузенов текущего элемента. Если кузены не найдены, возвращается пустой список.



  ```python

  cousin_elements = app.get_cousins(ancestor={'class': 'parent-class'}, cousin={'class': 'desired-class'})
  ```



  Этот метод проверяет, содержит ли текущий элемент другой элемент, определенный локатором `locator`.



  - `locator` - Локатор дочернего элемента. Может быть представлен в виде кортежа (списка атрибутов и их значений), экземпляра WebElement или WebElementExtended, словаря (атрибутов и их значений) или строки (XPath выражения).

  - `contains` - Булевый флаг, который определяет, следует ли использовать функцию `contains` при формировании XPath выражения для поиска элемента. Если `True`, то будет искаться частичное совпадение атрибутов. Если `False`, то будет искаться полное совпадение. По умолчанию `True`.



  - Возвращает `True`, если текущий элемент содержит искомый дочерний элемент, и `False` в противном случае.



  ```python

  if app.is_contains(locator={'class': 'child-class'}):
      print("Child element is present")
  else:
      print("Child element is not present")
  ```



  Вызывает `NotImplementedError` так как метод не реализован.
  Этот метод в будущем реализует функцию увеличения (zoom) на элементе страницы.



  - `hold` - Булевый параметр, который определяет, следует ли удерживать увеличение после его выполнения. Если `True`, увеличение будет удерживаться. Если `False`, увеличение не будет удерживаться после выполнения действия.



  - Вызывает `NotImplementedError` так как метод не реализован.



  ```python
  Метод не реализован
  ```



  Вызывает `NotImplementedError` так как метод не реализован.
  Этот метод в будущем реализует функцию увеличения (zoom) на элементе страницы.



  - `hold` - Булевый параметр, который определяет, следует ли удерживать увеличение после его выполнения. Если `True`, увеличение будет удерживаться. Если `False`, увеличение не будет удерживаться после выполнения действия.



  - Вызывает `NotImplementedError` так как метод не реализован.



  ```python
  Метод не реализован
  ```



  Этот метод вычисляет координаты центра текущего элемента страницы.



  - Возвращает кортеж в формате `(x, y)`, где `x` и `y` - это координаты центра элемента. Если во время выполнения произошла ошибка, метод вернёт `None`.



  ```python

  center_coordinates = element.get_center()


  if center_coordinates is not None:
      print("The center of the element is located at: ", center_coordinates)
  else:
      print("An error occurred while getting the center of the element.")
  ```



  Этот метод используется для получения координат текущего элемента веб-страницы.



  - Возвращает кортеж в формате `(left, top, right, bottom)`, где:
    - `left` - расстояние от левого края окна браузера до левого края элемента,
    - `top` - расстояние от верхнего края окна браузера до верхнего края элемента,
    - `right` - расстояние от левого края окна браузера до правого края элемента,
    - `bottom` - расстояние от верхнего края окна браузера до нижнего края элемента.

    Если во время выполнения произошла ошибка, метод вернёт `None`.



  ```python

  element_coordinates = element.get_coordinates()


  if element_coordinates is not None:
      print("The coordinates of the element are: ", element_coordinates)
  else:
      print("An error occurred while getting the coordinates of the element.")
  ```






  Класс `AppiumServer` предназначен для управления сервером Appium. Он позволяет запускать и останавливать сервер Appium с заданными параметрами, проверять его доступность и логировать процесс.



  - `logger`: Объект для записи логов, основанный на настройках, указанных в `config.APPIUM_LOG_NAME`.

  - `port`: Порт, на котором будет запущен сервер Appium. По умолчанию равен `4723`.

  - `log_level`: Уровень детализации логирования. По умолчанию равен `'error'`.






  Инициализирует новый экземпляр класса `AppiumServer`.

  **Параметры:**

  - `port: int` - Порт, на котором будет запущен сервер Appium. По умолчанию равен `4723`.

  - `log_level: str` - Уровень детализации логирования. По умолчанию равен `'error'`.



  Этот метод запускает сервер Appium.



  Метод не принимает параметров.



  - `bool`: Возвращает `True`, если сервер Appium был успешно запущен. В противном случае возвращает `False`.



  ```python

  is_started = app.start()
  ```



  Метод запускает команду `appium server` с рядом параметров в отдельном подпроцессе, используя `subprocess.Popen`. Если процесс запуска успешен, метод возвращает `True`. В случае исключения типа `subprocess.CalledProcessError` или `OSError`, метод записывает ошибку в лог и возвращает `False`.



  Этот метод проверяет статус сервера Appium.



  Метод не принимает параметров.



  - `bool`: Возвращает `True`, если сервер Appium доступен и готов к использованию. В противном случае возвращает `False`.



  ```python

  is_ready = app.is_alive()
  ```



  Метод отправляет GET-запрос на "http://127.0.0.1:4723/wd/hub/sessions" для проверки статуса сервера Appium. Если сервер отвечает с кодом статуса 200, метод возвращает `True`. Если сервер отвечает с другим кодом статуса, метод записывает предупреждение в лог и возвращает `False`. В случае исключения `requests.exceptions.RequestException`, метод записывает ошибку в лог и возвращает `False`.



  Этот метод останавливает сервер Appium.



  Метод не принимает параметров.



  - `bool`: Возвращает `True`, если сервер Appium был успешно остановлен. В противном случае возвращает `False`.



  ```python

  is_stopped = app.stop()
  ```



  Метод запускает команду 'taskkill /F /IM node.exe' в подпроцессе, используя `subprocess.check_output`. Если процесс остановки успешен, метод возвращает `True`. В случае исключения типа `subprocess.CalledProcessError`, метод возвращает `False`.



  Этот метод ожидает, пока сервер Appium не станет доступным.



  - `timeout` (`int`, необязательный): Максимальное время ожидания в секундах, в течение которого метод будет проверять статус сервера. Значение по умолчанию: `60`.
  - `poll` (`int`, необязательный): Интервал времени в секундах между проверками статуса сервера. Значение по умолчанию: `2`.



  - `bool`: Возвращает `True`, если сервер Appium стал доступным в течение заданного времени ожидания. В противном случае возвращает `False`.



  ```python

  is_ready = app.wait_until_alive(timeout=60, poll=2)
  ```



  Метод использует вспомогательный метод `is_alive()` для проверки статуса сервера. Он будет продолжать проверку статуса сервера каждые `poll` секунд в течение `timeout` секунд или до тех пор, пока сервер не станет доступным. Если сервер становится доступным в течение времени ожидания, метод возвращает `True`. Если сервер так и не становится доступным после истечения времени ожидания, метод возвращает `False`.




  Этот класс предоставляет функционал навигации для приложения, управляемого через сервер Appium.



  - `app` (`AppiumExtended`): Экземпляр класса `AppiumExtended`, который предоставляет API для взаимодействия с сервером Appium.
  - `graph_manager` (`AppiumGraph`): Объект для управления графом приложения.
  - `logger` (`logging.Logger`): Логгер для записи логов.
  - `image` (`AppiumImage`): Объект для работы с изображениями в контексте Appium.





  Инициализирует новый экземпляр класса `AppiumNavigator`.

  **Параметры:**

  - `app` (`AppiumExtended`): Экземпляр класса `AppiumExtended`, который предоставляет API для взаимодействия с сервером Appium.



  Этот метод добавляет вершину в граф навигации приложения.



  - `page` (`str`): Название страницы (экрана или окна), которую нужно добавить в граф.
  - `edges` (`List[str]`): Список страниц (экранов или окон), к которым можно перейти с текущей страницы. Страницы представлены их названиями.



  Метод не возвращает значения.



  ```python

  navigator.add_page(page='HomePage', edges=['SettingsPage', 'ProfilePage'])
  ```



  Метод использует `graph_manager` для добавления новой вершины в граф навигации приложения. Вершина представляет собой страницу (экран / окно) в приложении. Метод принимает название страницы и список других страниц, к которым можно перейти с текущей страницы.



  Этот метод выполняет навигацию от текущей страницы к указанной целевой странице в приложении.



  - `current_page` (`Type[YourPageClass]`): Класс текущей страницы, на которой находится пользователь.
  - `destination_page` (`Type[YourPageClass]`): Класс целевой страницы, на которую пользователь хочет перейти.
  - `timeout` (`int`, необязательный): Максимальное время ожидания перехода, по умолчанию 55 секунд.



  Метод не возвращает значения.



  - `ValueError`: Если не удается найти путь от текущей страницы к целевой странице.



  ```python

  navigator.navigate(current_page=HomePage, destination_page=SettingsPage)
  ```



  Метод использует поиск пути и последовательное выполнение шагов навигации, чтобы перейти от текущей страницы к целевой. Если указанная целевая страница совпадает с текущей, никаких действий не выполняется.

  Вначале метод находит путь от текущей страницы к целевой с использованием `find_path()`. Если путь не найден, генерируется исключение `ValueError`. После того как путь найден, метод `perform_navigation()` выполняет навигацию, следуя найденному пути.

  Примечание: `YourPageClass` в параметрах `current_page` и `destination_page` следует заменить на конкретные классы страниц в вашем приложении.



  Этот метод использует поиск в ширину (BFS) для нахождения пути от стартовой страницы до целевой.



  - `start_page` (`Any`): Начальная страница поиска пути.
  - `target_page` (`Any`): Целевая страница, которую нужно достичь.



  - `Optional[List[Any]]`: Список страниц, образующих путь от стартовой до целевой страницы. Если путь не найден, возвращает `None`.



  ```python

  path = navigator.find_path(start_page=HomePage, target_page=SettingsPage)
  ```



  Метод обходит граф переходов между страницами, сохраняя текущий путь и посещенные страницы. Если стартовая страница совпадает с целевой, никаких действий не выполняется.

  Вначале метод создает множество для отслеживания посещенных страниц и очередь для выполнения поиска в ширину. Затем, пока очередь не пуста, метод извлекает текущую страницу и путь от стартовой страницы до нее. Получает переходы (соседние страницы) для текущей страницы и проверяет каждую соседнюю страницу. Если соседняя страница является целевой, возвращает полный путь. Если соседняя страница не была посещена, добавляет ее в очередь для дальнейшего поиска. Если путь не найден, возвращает `None`.

  Примечание: `start_page` и `target_page` должны быть конкретными классами страниц в вашем приложении.



  Этот метод выполняет навигацию по заданному пути.



  - `path` (`List[Any]`): Список страниц, образующих путь для навигации. Каждый элемент списка представляет страницу, а порядок элементов в списке определяет последовательность переходов от одной страницы к другой.
  - `timeout` (`int`, необязательный): Максимальное время ожидания перехода, по умолчанию 55 секунд.



  - `None`



  ```python

  path = [HomePage, MenuPage, SettingsPage]

  navigator.perform_navigation(path)
  ```



  Метод принимает список страниц, который представляет собой путь для навигации. Он выполняет переходы между соседними страницами, чтобы достичь целевой страницы. Проходит по пути и выполняет переходы между соседними страницами. Если метод перехода между текущей и следующей страницами не найден, выводит сообщение об ошибке. После выполнения каждого перехода ожидает появления изображения целевой страницы.

  Примечания:
  - Элементы списка `path` должны быть конкретными классами страниц в вашем приложении.
  - Рекомендуется вместо него использовать метод navigate()


  `#app_map.py`
  ```python
  from pages.page_1 import page_1
  from pages.page_2 import page_2
  from pages.page_3 import page_3
  class ExampleAppMap(AppiumExtended):

  	def __init__(self, logger: logging.Logger):
  		super().__init__(logger=logger)

  		
  	    self.page_1 = Page1(self)
  	    self.page_2 = Page2(self)
  	    self.page_3 = Page3(self)

  		self.driver = None
  		self.navigator: AppiumNavigator = None
  		self.image: AppiumImage = None
  		self.keyboard: KeyboardMain = None
  		self.current_path = os.path.dirname(os.path.abspath(inspect.getframeinfo(inspect.currentframe()).filename))
  		self.page_images_path = os.path.join(self.current_path, ConstMapPath.FOLDER_TRANSACTION_IMAGES)
  		self.pages_ndarray_images = None

  	def connect(self,
  		capabilities: dict,
  		server_ip: str = '0.0.0.0',
  		server_port: int = 4723,
  		server_log_level: str = 'error',
  		remote: bool = False,
  		keep_alive_server: bool = True) -> None:
  		super().connect(capabilities=capabilities,
  						server_ip=server_ip,
  						server_port=server_port,
  						server_log_level=server_log_level,
  						remote=remote,
  						keep_alive_server=keep_alive_server)

  		
  		self.navigator = AppiumNavigator(app=self, logger=self.logger)
  		self.keyboard = KeyboardMain(app=self, logger=self.logger)
  		self.image = self.helper

  		
  		self.page_1.edges = {
  		    self.page_2: self.go_1_2,
  		}
  		self.page_2.edges = {
  		    self.page_1: self.go_2_1,
  		    self.page_3: self.go_2_3
  		}
  		self.page_3.edges = {
  			self.page_2 = self.go_3_2
  		}
  		
  		self.navigator.add_page(page=self.page_1,
  		                        edges=self.page_1.edges)
  		self.navigator.add_page(page=self.page_2,
  		                        edges=self.page_2.edges)
  		self.navigator.add_page(page=self.page_3,
  		                        edges=self.page_3.edges)
  		self.pages_ndarray_images = {
  		    self.page_1: self._get_ndarray_images(self.page_1.page_images),
  		    self.page_2: self._get_ndarray_images(self.page_2.page_images),
  		    self.page_3: self._get_ndarray_images(self.page_3.page_images),
  			}

  	def go_1_2(self):
  		...

  	def go_2_1(self):
  		...

  	def go_2_3(self):
  		...

  	def go_3_2(self):
  		...
  ```

  Структура файлов page:
  -pages
    -page_1
      -action_images
        action_image_1.png
        action_image_2.png
      -images
        current_page_fragment_image_1.png
        current_page_fragment_image_2.png
      page_1.py

  `#page_1.py`
  ```python
  class Page1(PageBase):
      edges: list

      def __init__(self, app):
          super().__init__(app)
          self.app = app
          self.current_path = os.path.dirname(os.path.abspath(inspect.getframeinfo(inspect.currentframe()).filename))
          self.page_images_path = os.path.join(self.current_path, 'images')
          self.page_action_images_path = os.path.join(self.current_path, 'action_images')
          self.page_images = self._get_page_images(self.page_images_path)

      def is_current_page(self) -> bool:
          return self._is_current_page(self.page_images)

  	def some_logic_on_page(self):
  		...
  ```

  `#page_base.py`

    ```python
  class PageBase(object):
      def __init__(self, app):
          self.app: AppiumExtended = app
          self.page_images_path: str
          self.page_images: list[str]
          self.logger = logging.getLogger(config.LOGGER_NAME)

      def _is_current_page(self, page_images, max_attempts=3) -> bool:
          attempts = 0

          while attempts < max_attempts:
              if len(page_images) == 0:
                  return False

              all_images_found = True  # Предполагаем, что все изображения найдены

              for image in page_images:
                  if not self.app.image._is_image_on_the_screen(image=image):
                      all_images_found = False
                      break  # Прерываем цикл, если хотя бы одно изображение не найдено

              if all_images_found:
                  return True

              attempts += 1
              time.sleep(1)  # Подождать 1 секунду перед следующей попыткой

          return False

      @staticmethod
      def _get_page_images(page_images_path):
          page_images = []
          if os.path.exists(page_images_path):
              page_images = os.listdir(page_images_path)
          for index, image_name in enumerate(page_images):
              page_images[index] = os.path.join(page_images_path, image_name)
          return page_images
  ```



  Класс




  Статический метод, получает название пакета APK-файла с помощью команды aapt. Используется для извлечения информации о пакете из файла APK.



  - `path_to_apk`: Путь до APK-файла, из которого требуется извлечь название пакета. Должен быть строкой, содержащей путь к файлу.



  Возвращает строку, содержащую название пакета, извлеченное из APK-файла. Если название пакета не может быть извлечено, возвращается `None`.



  ```python
  package_name = get_package_name(path_to_apk="/path/to/apk/file.apk")
  print(package_name)
  ```



  Этот метод выполняет системную команду с использованием утилиты `aapt` (Android Asset Packaging Tool). В процессе работы создаются логи, которые сохраняются с использованием модуля `logging`.



  Метод может генерировать исключения, если указанный файл APK не найден, не может быть прочитан или не содержит ожидаемой информации о пакете. Все такие исключения должны быть обработаны в вызывающем коде. Дополнительно, если утилита `aapt` не установлена или не доступна для вызова в системе, метод может не работать корректно.



  Статический метод, получает название запускаемой активности из APK-файла с помощью команды `aapt`. Используется для извлечения информации о запускаемой активности из файла APK.



  - `path_to_apk`: Путь до APK-файла, из которого требуется извлечь название запускаемой активности. Должен быть строкой, содержащей путь к файлу.



  Возвращает строку, содержащую название запускаемой активности, извлеченное из APK-файла. Если название активности не может быть извлечено, возвращается `None`.



  ```python
  launchable_activity = YourClassName.get_launchable_activity(path_to_apk="/path/to/apk/file.apk")
  print(launchable_activity)
  ```



  Этот метод выполняет системную команду с использованием утилиты `aapt` (Android Asset Packaging Tool). В процессе работы создаются логи, которые сохраняются с использованием модуля `logging`.



  Метод может генерировать исключения, если указанный файл APK не найден, не может быть прочитан или не содержит ожидаемой информации о запускаемой активности. Все такие исключения должны быть обработаны в вызывающем коде. Дополнительно, если утилита `aapt` не установлена или не доступна для вызова в системе, метод может не работать корректно.

  Пожалуйста, замените `YourClassName` на имя вашего класса.




  Класс отвечает за работу с устройством, командами adb подаваемыми через Appium server.



  Этот метод класса `Terminal` позволяет выполнить команду adb shell через драйвер Appium. Используется для взаимодействия с устройством на уровне adb.



  - `command`: Команда adb shell, которую требуется выполнить. Должна быть строкой, представляющей собой команду adb shell.

  - `args`: Аргументы команды adb shell. Должны быть представлены в виде строки. По умолчанию, значение этого параметра — пустая строка.



  Возвращает значение, возвращаемое драйвером Appium при выполнении скрипта. Тип возвращаемого значения может зависеть от конкретной команды adb shell, но, как правило, это строка, содержащая вывод выполненной команды.



  ```python
  output = Terminal(driver).adb_shell(command="pm list packages", args="-3")
  print(output)
  ```



  Этот метод использует возможности драйвера Appium для выполнения adb shell команд. В зависимости от команды и аргументов, которые передаются в этот метод, он может быть использован для выполнения широкого спектра задач, связанных с управлением устройством на уровне adb.



  Метод может генерировать исключения, если указанная команда adb shell не может быть выполнена или возвращает ошибку. Все такие исключения должны быть обработаны в вызывающем коде.



  Этот метод класса `Terminal` позволяет копировать файл или директорию с локальной машины на подключенное устройство через Appium сервер.



  - `source`: Путь к копируемому файлу или директории на локальной машине. Должен быть представлен в виде строки.

  - `destination`: Путь назначения на устройстве, куда будет скопирован файл или директория. Должен быть представлен в виде строки.



  Возвращает `True`, если файл или директория были успешно скопированы. В противном случае возвращается `False`.



  ```python
  terminal = Terminal(driver)
  copy_result = terminal.push(source="/local/path/to/file.txt", destination="/device/path/to/file.txt")
  if copy_result:
      print("File was successfully copied.")
  else:
      print("File copying failed.")
  ```



  Этот метод использует возможности драйвера Appium для копирования файлов или директорий на подключенное устройство. В случае возникновения ошибок в процессе копирования (например, если исходный файл не существует или назначение недоступно), метод возвращает `False` и записывает информацию об ошибке в лог.



  Метод может генерировать исключение `IOError`, если возникают проблемы с чтением исходного файла или записью в целевую директорию на устройстве. Это исключение обрабатывается внутри метода, и информация о нем записывается в лог.



  Этот метод класса `Terminal` позволяет извлекать файл с подключенного устройства и сохранять его на локальной машине через Appium сервер.



  - `source`: Путь к файлу на устройстве, который требуется извлечь. Должен быть представлен в виде строки.

  - `destination`: Путь, по которому файл должен быть сохранен на локальной машине. Должен быть представлен в виде строки.



  Возвращает `True`, если файл успешно извлечен и сохранен на локальной машине. В противном случае возвращается `False`.



  ```python
  terminal = Terminal(driver)
  pull_result = terminal.pull(source="/device/path/to/file.txt", destination="/local/path/to/file.txt")
  if pull_result:
      print("File was successfully pulled.")
  else:
      print("File pulling failed.")
  ```



  Этот метод использует возможности драйвера Appium для извлечения файлов с подключенного устройства. Сначала он извлекает файл с устройства в виде строки в формате base64, затем декодирует эту строку и записывает полученные данные в файл по указанному локальному пути. Если в процессе возникают ошибки (например, если исходный файл не существует или назначение недоступно), метод возвращает `False` и записывает информацию об ошибке в лог.



  Метод может генерировать исключение `IOError`, если возникают проблемы с записью файла на локальной машине. Это исключение обрабатывается внутри метода, и информация о нем записывается в лог.



  Этот метод класса `Terminal` предназначен для запуска определенной активности в приложении на подключенном устройстве с использованием adb shell команды.



  - `package`: Название пакета приложения, в котором находится активность. Должен быть представлен в виде строки.

  - `activity`: Название активности, которую нужно запустить. Должно быть представлено в виде строки.



  Возвращает `True`, если активность была успешно запущена. В противном случае возвращается `False`.



  ```python
  terminal = Terminal(driver)
  activity_started = terminal.start_activity(package="com.example", activity=".MainActivity")
  if activity_started:
      print("Activity was successfully started.")
  else:
      print("Activity starting failed.")
  ```



  Метод использует adb shell команду `am start` для запуска активности. В случае успешного выполнения команды метод возвращает `True`. Если команда не может быть выполнена (например, если указанное приложение или активность не существуют), метод возвращает `False` и записывает информацию об ошибке в лог.



  Метод может генерировать исключение `KeyError`, если в процессе выполнения adb shell команды возникают проблемы. Это исключение обрабатывается внутри метода, и информация о нем записывается в лог.



  Метод класса `Terminal` предназначен для получения имени пакета текущего запущенного приложения на подключенном устройстве.



  Возвращает строку, содержащую имя пакета текущего запущенного приложения. В случае ошибки возвращает `None`.



  ```python
  terminal = Terminal(driver)
  current_app_package = terminal.get_current_app_package()
  if current_app_package:
      print(f"The current running app package is {current_app_package}.")
  else:
      print("Failed to get the current running app package.")
  ```



  Метод использует команду adb shell `dumpsys window windows` для получения информации о текущем активном окне на устройстве. Эта информация анализируется, и из неё извлекается имя пакета запущенного приложения. Если информацию не удалось извлечь (например, если нет активного окна или приложения), метод возвращает `None`.



  Метод может генерировать исключение `KeyError`, если в процессе выполнения команды adb shell возникают проблемы. Это исключение обрабатывается внутри метода, и информация о нем записывается в лог.



  Метод класса `Terminal`, который принудительно закрывает приложение на подключенном устройстве с помощью указанного имени пакета.



  - `package`: Строка, содержащая имя пакета приложения, которое необходимо закрыть.



  Возвращает `True`, если приложение было успешно закрыто, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.close_app("com.example.myapp"):
      print("The app was successfully closed.")
  else:
      print("Failed to close the app.")
  ```



  Метод использует команду adb shell `am force-stop`, чтобы принудительно остановить приложение с указанным именем пакета.



  Метод может генерировать исключение `KeyError`, если в процессе выполнения команды adb shell возникают проблемы. Это исключение обрабатывается внутри метода, и информация о нем записывается в лог.



  Метод класса `Terminal`, который перезапускает указанное приложение, сначала принудительно закрывая его, а затем запуская указанную активность.



  - `package`: Строка, содержащая имя пакета приложения, которое необходимо перезапустить.

  - `activity`: Строка, содержащая имя активности приложения, которую необходимо запустить.



  Возвращает `True`, если перезапуск приложения выполнен успешно, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.reboot_app("com.example.myapp", "com.example.myapp.MainActivity"):
      print("The app was successfully rebooted.")
  else:
      print("Failed to reboot the app.")
  ```



  Этот метод сначала закрывает приложение с использованием метода `close_app()`, а затем пытается его перезапустить с использованием метода `start_activity()`. Если какой-либо из этих методов возвращает `False`, метод `reboot_app()` также вернет `False`.



  Метод может генерировать исключение, если в процессе его выполнения возникают проблемы. В частности, если методы `close_app()` или `start_activity()` возвращают `False`, метод `reboot_app()` также вернет `False`.



  Метод класса `Terminal`, который удаляет указанное приложение с помощью ADB (Android Debug Bridge).



  - `package`: Строка, содержащая имя пакета приложения, которое необходимо удалить.



  Возвращает `True`, если приложение успешно удалено, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.uninstall_app("com.example.myapp"):
      print("The app was successfully uninstalled.")
  else:
      print("Failed to uninstall the app.")
  ```



  Этот метод использует метод `remove_app()` из `driver` для удаления приложения. Если удаление успешно, метод `remove_app()` не возвращает значение, в противном случае он может вызвать исключение.



  Метод может генерировать исключение, если в процессе его выполнения возникают проблемы. Если метод `remove_app()` вызывает исключение, это исключение будет логироваться, а метод `uninstall_app()` вернет `False`.



  Метод класса `Terminal`, который устанавливает указанное приложение с помощью Appium.



  - `app_path`: Строка, содержащая путь до APK-файла приложения, которое необходимо установить.



  Возвращает `True`, если приложение успешно установлено, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.install_app("/path/to/myapp.apk"):
      print("The app was successfully installed.")
  else:
      print("Failed to install the app.")
  ```



  Этот метод использует метод `install_app()` из `driver` для установки приложения. Если установка успешна, метод `install_app()` не возвращает значение, в противном случае он может вызвать исключение.



  Метод может генерировать исключение, если в процессе его выполнения возникают проблемы. Если метод `install_app()` вызывает исключение, это исключение будет логироваться, а метод `install_app()` вернет `False`.



  Метод класса `Terminal`, предназначенный для проверки установки указанного пакета приложения с помощью Appium.



  - `package` (тип: `str`): Имя пакета приложения, для которого нужно проверить установку.



  Возвращает значение `True`, если указанный пакет приложения установлен на устройстве, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.is_app_installed("com.example.myapp"):
      print("The app is installed.")
  else:
      print("The app is not installed.")
  ```



  Метод `is_app_installed()` использует команду `pm list packages` для получения списка установленных пакетов приложений. Затем он фильтрует список и проверяет, содержится ли указанный пакет среди установленных. Если пакет найден в списке, метод вернет `True`, в противном случае вернет `False`.



  Метод может вызывать исключение типа `KeyError`, если в процессе выполнения возникли проблемы с доступом к списку пакетов. В случае возникновения исключения, оно будет залогировано, и метод `is_app_installed()` вернет значение `False`.

  **Примечание:** Для корректной работы метода `is_app_installed()`, убедитесь, что устройство подключено к Appium и правильно настроено для выполнения команд через ADB.



  Метод класса `Terminal`, который эмулирует нажатие кнопки "Домой" на устройстве, используя Android Debug Bridge (ADB).



  Метод не принимает никаких параметров.



  Возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.press_home():
      print("Home button was successfully pressed.")
  else:
      print("Failed to press the home button.")
  ```



  Этот метод отправляет команду `input_keycode` с кодом "KEYCODE_HOME" к драйверу Appium. Если команда выполнена успешно, метод `input_keycode` не возвращает значение, в противном случае он может вызвать исключение.



  Метод может вызвать исключение, если возникают проблемы при выполнении его. Если метод `input_keycode` вызывает исключение, это исключение будет залогировано, а метод `press_home()` вернет `False`.



  Метод класса `Terminal`, который эмулирует нажатие кнопки "Назад" на устройстве, используя Android Debug Bridge (ADB).



  Метод не принимает никаких параметров.



  Возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.press_back():
      print("Back button was successfully pressed.")
  else:
      print("Failed to press the back button.")
  ```



  Этот метод отправляет команду `input_keycode` с кодом "KEYCODE_BACK" к драйверу Appium. Если команда выполнена успешно, метод `input_keycode` не возвращает значение, в противном случае он может вызвать исключение.



  Метод может вызвать исключение, если возникают проблемы при выполнении его. Если метод `input_keycode` вызывает исключение, это исключение будет залогировано, а метод `press_back()` вернет `False`.



  Метод класса `Terminal`, который эмулирует нажатие кнопки "Меню" на устройстве, используя Android Debug Bridge (ADB).



  Метод не принимает никаких параметров.



  Возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.press_menu():
      print("Menu button was successfully pressed.")
  else:
      print("Failed to press the menu button.")
  ```



  Этот метод отправляет команду `input_keycode` с кодом "KEYCODE_MENU" к драйверу Appium. Если команда выполнена успешно, метод `input_keycode` не возвращает значение, в противном случае он может вызвать исключение.



  Метод может вызвать исключение, если возникают проблемы при выполнении его. Если метод `input_keycode` вызывает исключение, это исключение будет залогировано, а метод `press_menu()` вернет `False`.



  Этот метод класса `Terminal` имитирует нажатие клавиши на числовой клавиатуре устройства с использованием Android Debug Bridge (ADB).



  Метод принимает следующие параметры:

  - `num (int)`: числовое значение нажимаемой клавиши.



  Возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.input_keycode_num_(5):
      print("Клавиша с числом 5 была успешно нажата.")
  else:
      print("Не удалось нажать клавишу с числом 5.")
  ```



  Этот метод отправляет команду `adb_shell` с командой `input` и аргументом `keyevent KEYCODE_NUMPAD_{num}` в драйвер Appium. Если команда успешно выполнена, метод `adb_shell` не возвращает значение, в противном случае, он может вызвать исключение.



  Метод может вызвать исключение, если при его выполнении возникли проблемы. Если метод `adb_shell` вызывает исключение, это исключение будет залогировано, и метод `input_keycode_num_()` вернет `False`.



  Метод класса `Terminal`, который имитирует ввод указанного кода клавиши на устройстве с помощью Android Debug Bridge (ADB).



  Метод принимает следующий параметр:

  - `keycode (str)`: код клавиши для ввода. Это может быть любой код клавиши, поддерживаемый ADB, включая, но не ограничиваясь, такими как "KEYCODE_HOME", "KEYCODE_BACK", "KEYCODE_MENU" и т. д.



  Метод возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.input_keycode("KEYCODE_HOME"):
      print("Клавиша Home была успешно нажата.")
  else:
      print("Не удалось нажать клавишу Home.")
  ```



  Метод отправляет команду `adb_shell` с командой `input` и аргументом `keyevent {keycode}` в драйвер Appium. Если команда успешно выполнена, метод `adb_shell` не возвращает значение, в противном случае, он может вызвать исключение.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы. Если метод `adb_shell` вызывает исключение, это исключение будет залогировано, и метод `input_keycode()` вернет `False`.



  Метод класса `Terminal`, который эмулирует ввод строки символов с помощью виртуальной клавиатуры на устройстве.



  Метод принимает следующие параметры:

  - `key (str)`: Строка символов, которые требуется ввести.
  - `keyboard (dict)`: Словарь, отображающий символы на координаты нажатия на экране. Ключами словаря являются символы, а значениями - кортежи, содержащие координаты x и y на экране для каждого символа.



  Метод возвращает `True`, если ввод символов был выполнен успешно, и `False` в противном случае.



  ```python
  keyboard_mapping = {
      "a": (100, 200),
      "b": (120, 220),
      ...
  }
  terminal = Terminal(driver)
  if terminal.input_by_virtual_keyboard("abc", keyboard_mapping):
      print("Ввод символов 'abc' выполнен успешно.")
  else:
      print("Ошибка при вводе символов 'abc'.")
  ```



  В данном методе используется функция `tap()`, которая выполняет нажатие на указанные координаты на экране. Для каждого символа во входной строке метод вызывает функцию `tap()` с координатами, соответствующими этому символу.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы, например, если указанный символ отсутствует в словаре `keyboard`. Если метод `tap()` вызывает исключение, это исключение будет залогировано, и метод `input_by_virtual_keyboard()` вернет `False`.



  Метод класса `Terminal`, который эмулирует ввод указанного текста на устройстве с использованием ADB (Android Debug Bridge).



  Метод принимает следующий параметр:

  - `text (str)`: Строка текста, которую нужно ввести на устройстве.



  Метод возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.input_text("Hello, world!"):
      print("Текст 'Hello, world!' успешно введен.")
  else:
      print("Ошибка при вводе текста 'Hello, world!'.")
  ```



  В данном методе используется функция `adb_shell()`, которая отправляет ADB команду в shell Android устройства. С помощью ADB команды "input text" мы можем ввести текст на устройстве.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы. Если возникает исключение, оно будет залогировано, и метод `input_text()` вернет `False`.



  Это метод класса `Terminal`, который эмулирует нажатие на указанные координаты на устройстве с использованием ADB (Android Debug Bridge).



  Метод принимает следующие параметры:

  - `x (int)`: Координата по оси X точки, по которой нужно нажать.
  - `y (int)`: Координата по оси Y точки, по которой нужно нажать.



  Метод возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.tap(200, 300):
      print("Нажатие на координаты (200, 300) успешно выполнено.")
  else:
      print("Ошибка при нажатии на координаты (200, 300).")
  ```



  В данном методе используется функция `adb_shell()`, которая отправляет ADB команду в shell Android устройства. С помощью ADB команды "input tap" мы можем выполнить нажатие на определенные координаты экрана.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы. Если возникает исключение, оно будет залогировано, и метод `tap()` вернет `False`.



  Это метод класса `Terminal`, который эмулирует жест свайпа (или перетаскивания) с одной точки на экране до другой на устройстве с использованием ADB (Android Debug Bridge).



  Метод принимает следующие параметры:

  - `start_x (Union[str, int])`: Координата по оси X начальной точки свайпа.
  - `start_y (Union[str, int])`: Координата по оси Y начальной точки свайпа.
  - `end_x (Union[str, int])`: Координата по оси X конечной точки свайпа.
  - `end_y (Union[str, int])`: Координата по оси Y конечной точки свайпа.
  - `duration (int)`: Длительность свайпа в миллисекундах. По умолчанию равна 300 мс.



  Метод возвращает `True`, если команда была успешно выполнена, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.swipe(200, 300, 400, 500, 1000):
      print("Свайп с координат (200, 300) до координат (400, 500) выполнен успешно.")
  else:
      print("Ошибка при выполнении свайпа.")
  ```



  В данном методе используется функция `adb_shell()`, которая отправляет ADB команду в shell Android устройства. С помощью ADB команды "input swipe" мы можем выполнить свайп по экрану от одних координат до других.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы. Если возникает исключение, оно будет залогировано, и метод `swipe()` вернет `False`.



  Это метод класса `Terminal`, который проверяет, активно ли VPN-соединение на устройстве, используя ADB (Android Debug Bridge).



  Метод принимает следующий параметр:

  - `ip_address (str)`: IP-адрес для проверки VPN-соединения. Если он не указан, то используется значение по умолчанию.



  Метод возвращает `True`, если VPN-соединение активно, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.check_vpn('192.168.0.1'):
      print("VPN-соединение активно.")
  else:
      print("VPN-соединение не активно.")
  ```



  В данном методе используется функция `adb_shell()`, которая отправляет ADB команду в shell Android устройства. С помощью команды "netstat" мы можем проверить состояние сетевых соединений устройства.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы. Если возникает исключение, оно будет залогировано, и метод `check_vpn()` вернет `False`.



  Это метод класса `Terminal`, который останавливает выполнение logcat на устройстве, используя ADB (Android Debug Bridge).



  Метод не принимает никаких параметров.



  Метод возвращает `True`, если выполнение logcat остановлено успешно, и `False` в противном случае.



  ```python
  terminal = Terminal(driver)
  if terminal.stop_logcat():
      print("logcat остановлен успешно.")
  else:
      print("Не удалось остановить logcat.")
  ```



  Метод `stop_logcat()` сначала получает список всех выполняющихся процессов на устройстве с помощью команды `ps`. Затем он проходит через этот список и отправляет сигнал `SIGINT` каждому процессу `logcat`, который он находит, чтобы остановить его.



  Метод может вызвать исключение `KeyError`, если при его выполнении возникли проблемы. Если возникает исключение, оно будет залогировано, и метод `stop_logcat()` вернет `False`.



  Это метод класса `Terminal`, который ищет и возвращает идентификатор процесса (PID) по его имени с помощью команды `adb shell ps`.



  * `name (str)`: Имя процесса, PID которого необходимо найти.



  Метод возвращает `int` или `None`. Если процесс с указанным именем найден, метод возвращает его PID (как целое число). Если процесс не найден, метод возвращает `None`.



  ```python
  terminal = Terminal(driver)
  pid = terminal.know_pid("com.example.app")
  if pid is not None:
      print(f"PID процесса 'com.example.app': {pid}")
  else:
      print("Процесс 'com.example.app' не найден.")
  ```



  Метод `know_pid()` получает список всех выполняющихся процессов на устройстве с помощью команды `adb shell ps`, затем проходит по этому списку и ищет процесс с указанным именем. Если такой процесс найден, метод возвращает его PID. Если процесс не найден, метод возвращает `None`.



  Метод не обрабатывает исключения и, таким образом, может вызвать любое исключение, которое может вызвать `adb_shell(command)`.




  Это метод класса `Terminal`, который проверяет, существует ли процесс с указанным именем, используя команду `adb shell ps`.



  * `name (str)`: Имя процесса, которое требуется проверить на существование.



  Метод возвращает `bool`. Если процесс с указанным именем существует, метод возвращает `True`. В противном случае, если процесс не найден, метод возвращает `False`.



  ```python
  terminal = Terminal(driver)
  if terminal.is_process_exist("com.example.app"):
      print("Процесс 'com.example.app' существует.")
  else:
      print("Процесс 'com.example.app' не существует.")
  ```



  Метод `is_process_exist(name)` получает список всех выполняющихся процессов на устройстве с помощью команды `adb shell ps`, затем проверяет, есть ли процесс с указанным именем в этом списке. Если процесс с заданным именем найден, метод возвращает `True`, иначе возвращает `False`.



  Метод не обрабатывает исключения и, таким образом, может вызвать любое исключение, которое может возникнуть при выполнении `adb_shell(command)`.

  **Примечание:** В описании метода `is_process_exist(name)` вместо `is_process_exist() > True` и `is_process_exist() > False`, используются логгеры для вывода отладочной информации. В реальной реализации эти строки не будут отображаться. Они присутствуют в данном контексте только для демонстрации логгирования.



  Это метод класса `Terminal`, который запускает процесс в фоновом режиме на устройстве Android.



  * `command (str)`: Команда для выполнения на устройстве.
  * `args (str)`: Дополнительные аргументы для команды. По умолчанию `""`.
  * `process (str)`: Название процесса, который будет запущен. По умолчанию `""`. Если значение `process` равно `""`, то не будет проверяться его запуск в системе.



  Метод возвращает `bool`. Если процесс был успешно запущен, метод возвращает `True`. В противном случае, если процесс не удалось запустить или указанный процесс не был найден, метод возвращает `False`.



  ```python
  terminal = Terminal(driver)
  command_to_run = "my_background_command arg1 arg2"
  if terminal.run_background_process(command_to_run, args="--option"):
      print("Процесс был успешно запущен.")
  else:
      print("Произошла ошибка при запуске процесса или процесс не найден.")
  ```



  Метод `run_background_process(command, args="", process="")` выполняет переданную команду `command` на устройстве Android с дополнительными аргументами `args`. Команда запускается в фоновом режиме с использованием `nohup` и перенаправлением вывода в `/dev/null` для игнорирования вывода в консоль.

  Если параметр `process` не равен пустой строке, метод после запуска процесса проверяет его существование через метод `is_process_exist(name=process)`. Если процесс не найден, метод вернет `False`. В противном случае, если процесс успешно запущен или параметр `process` равен пустой строке, метод вернет `True`.

  Метод может вызывать исключение `KeyError`, и в таком случае он будет логировать ошибку и возвращать `False`.




  Это метод класса `Terminal`, который посылает сигнал SIGINT процессу с указанным идентификатором процесса (PID), используя команду `adb shell kill`.



  * `pid (int)`: Идентификатор процесса (PID), который нужно остановить.



  Метод возвращает `bool`. Если команда выполнена успешно и процесс остановлен, возвращается `True`. В противном случае - `False`.



  ```python
  terminal = Terminal(driver)
  pid = terminal.know_pid("com.example.app")
  if pid is not None:
      if terminal.kill_by_pid(pid):
          print(f"Процесс с PID {pid} успешно остановлен.")
      else:
          print(f"Не удалось остановить процесс с PID {pid}.")
  else:
      print("Процесс 'com.example.app' не найден.")
  ```



  Метод `kill_by_pid()` отправляет команду `kill -s SIGINT {pid}` на устройство через `adb shell` для остановки процесса с указанным идентификатором процесса.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `adb_shell(command, args)`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Terminal` предназначен для остановки всех процессов, соответствующих заданному имени или шаблону имени, с помощью команды `adb shell pkill`.



  * `name (str)`: Имя или шаблон имени процесса, который необходимо остановить.



  Метод возвращает `bool`. Если команда выполнена успешно и все процессы остановлены, возвращается `True`. В противном случае - `False`.



  ```python
  terminal = Terminal(driver)
  if terminal.kill_all("com.example.app"):
      print("Все процессы 'com.example.app' успешно остановлены.")
  else:
      print("Не удалось остановить все процессы 'com.example.app'.")
  ```



  Метод `kill_all()` отправляет команду `pkill -f {name}` на устройство через `adb shell` для остановки всех процессов, соответствующих заданному имени или шаблону имени.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `adb_shell(command, args)`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Terminal` предназначен для удаления файлов из внутреннего хранилища устройства с помощью команды `adb shell rm`.



  * `path (str)`: Путь к папке во внутреннем хранилище, из которой необходимо удалить файлы.



  Метод возвращает `bool`. Если команда выполнена успешно и файлы удалены, возвращается `True`. В противном случае - `False`.



  ```python
  terminal = Terminal(driver)
  if terminal.delete_files_from_internal_storage("/sdcard/Download/"):
      print("Файлы успешно удалены из '/sdcard/Download/'.")
  else:
      print("Не удалось удалить файлы из '/sdcard/Download/'.")
  ```



  Метод `delete_files_from_internal_storage()` отправляет команду `rm -rf {path}*` на устройство через `adb shell` для удаления всех файлов в указанном каталоге.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `adb_shell(command, args)`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Terminal` предназначен для удаления конкретного файла из внутреннего хранилища устройства с помощью команды `adb shell rm`.



  * `path (str)`: Путь к папке во внутреннем хранилище, из которой необходимо удалить файл.
  * `filename (str)`: Имя файла, который необходимо удалить.



  Метод возвращает `bool`. Если команда выполнена успешно и файл удален, возвращается `True`. В противном случае - `False`.



  ```python
  terminal = Terminal(driver)
  if terminal.delete_file_from_internal_storage("/sdcard/Download/", "myfile.txt"):
      print("Файл 'myfile.txt' успешно удален из '/sdcard/Download/'.")
  else:
      print("Не удалось удалить файл 'myfile.txt' из '/sdcard/Download/'.")
  ```



  Метод `delete_file_from_internal_storage()` отправляет команду `rm -rf {path}/{filename}` на устройство через `adb shell` для удаления указанного файла в указанном каталоге.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `adb_shell(command, args)`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Terminal` предназначен для начала записи видео с экрана устройства.



  * `**options (Any)`: Опциональные аргументы для настройки записи видео. Обратитесь к документации Appium для получения полного списка доступных параметров.



  Метод возвращает `bool`. Если запись видео успешно начата, возвращается `True`. В противном случае - `False`.



  ```python
  terminal = Terminal(driver)
  if terminal.record_video():
      print("Запись видео успешно начата.")
  else:
      print("Не удалось начать запись видео.")
  ```



  Метод `record_video()` использует метод `start_recording_screen()` из библиотеки Appium для начала записи видео.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `start_recording_screen()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Terminal` предназначен для остановки записи видео с экрана устройства и возвращения записанного видео в формате base64.



  * `**options (Any)`: Опциональные аргументы для настройки остановки записи видео. Эти могут включать параметры, такие как 'withFile' и другие. Обратитесь к документации Appium для получения полного списка доступных параметров.



  Метод возвращает `Union[bytes, None]`. Если запись видео успешно остановлена, возвращается видео в виде декодированных из base64 байтов. В противном случае возвращается `None`.



  ```python
  terminal = Terminal(driver)
  video_bytes = terminal.stop_video()
  if video_bytes is not None:
      with open('output.mp4', 'wb') as f:
          f.write(video_bytes)
      print("Видео успешно остановлено и сохранено.")
  else:
      print("Не удалось остановить запись видео.")
  ```



  Метод `stop_video()` использует метод `stop_recording_screen()` из библиотеки Appium для остановки записи видео. Этот метод возвращает видео в виде строки, закодированной в base64. Метод `stop_video()` затем декодирует эту строку в байты и возвращает их.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `stop_recording_screen()`. Если исключение возникает, оно логируется и метод возвращает `None`.



  Этот метод класса `Terminal` предназначен для перезагрузки устройства с использованием ADB.



  Метод не принимает никаких параметров.



  Метод возвращает `bool`. Если перезагрузка устройства успешно запущена, возвращается `True`. В противном случае возвращается `False`.



  ```python
  terminal = Terminal(driver)
  if terminal.reboot():
      print("Устройство успешно перезагружено.")
  else:
      print("Не удалось запустить перезагрузку устройства.")
  ```



  Метод `reboot()` использует команду `reboot` ADB для перезагрузки устройства.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `adb_shell()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Terminal` предназначен для получения разрешения экрана устройства с использованием ADB.



  Метод не принимает никаких параметров.



  Метод возвращает кортеж из двух целых чисел (`tuple[int, int]`) или `None`. Кортеж содержит ширину и высоту экрана в пикселях. Если происходит ошибка, возвращается `None`.



  ```python
  terminal = Terminal(driver)
  resolution = terminal.get_screen_resolution()
  if resolution:
      print(f"Разрешение экрана устройства: {resolution[0]}x{resolution[1]}")
  else:
      print("Не удалось получить разрешение экрана.")
  ```



  Метод `get_screen_resolution()` использует команду `wm size` ADB для получения разрешения экрана устройства.



  Метод обрабатывает исключение `KeyError`, которое может быть вызвано методом `adb_shell()`. Если исключение возникает, оно логируется и метод возвращает `None`.



  Предназначен для взаимодействия с Android Debug Bridge (ADB). Этот класс будет использовать для выполнения различных команд на устройстве Android.



  Этот метод класса `Adb` предназначен для установки приложения на устройство с использованием ADB.



  Метод принимает следующие параметры:

  1. `apk_path (str)`: Путь к APK-файлу приложения на компьютере.



  Метод возвращает `True` (`bool`), если приложение успешно установлено, и `False` в противном случае.



  ```python
  adb = Adb()
  if adb.install_app("path_to_apk"):
      print("Приложение успешно установлено.")
  else:
      print("Не удалось установить приложение.")
  ```



  Метод `install_app()` использует команду `adb install` для установки APK-файла на устройство.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.check_output()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для проверки, установлено ли указанное приложение на подключенном устройстве Android с использованием ADB.



  Метод принимает следующий параметр:

  - `package` (`str`): Имя пакета приложения, которое нужно проверить.



  Метод возвращает логическое значение `bool`:
  - `True` - если приложение установлено на устройстве.
  - `False` - если приложение не установлено на устройстве или произошла ошибка при проверке.



  ```python
  adb = Adb()
  is_installed = adb.is_app_installed("com.example.app")
  if is_installed:
      print("Приложение установлено на устройстве.")
  else:
      print("Приложение не установлено на устройстве.")
  ```



  Метод `is_app_installed()` использует команду `adb shell pm list packages` для получения списка всех установленных приложений на устройстве. Затем он проверяет, присутствует ли имя пакета в этом списке.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.check_output()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для удаления приложения на подключенном устройстве Android.



  Метод принимает следующий параметр:

  - `package` (`str`): Имя пакета приложения, которое вы хотите удалить.



  Метод возвращает логическое значение `bool`:
  - `True` - если приложение было успешно удалено с устройства.
  - `False` - если произошла ошибка при удалении приложения.



  ```python
  adb = Adb()
  success = adb.uninstall_app("com.example.app")
  if success:
      print("Приложение успешно удалено с устройства.")
  else:
      print("Не удалось удалить приложение с устройства.")
  ```



  Метод `uninstall_app()` использует команду `adb uninstall` для удаления указанного приложения.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду удаления приложения. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для получения модели подключенного устройства Android с использованием ADB.



  Метод не принимает никаких параметров.



  Метод возвращает модель устройства в виде строки (`str`) или `None`, если происходит ошибка при получении модели устройства.



  ```python
  adb = Adb()
  model = adb.get_device_model()
  if model:
      print(f"Модель устройства: {model}")
  else:
      print("Не удалось получить модель устройства.")
  ```



  Метод `get_device_model()` использует команду `adb shell getprop ro.product.model` для получения модели устройства.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.check_output()`. Если исключение возникает, оно логируется и метод возвращает `None`.



  Этот метод класса `Adb` предназначен для копирования файла или директории с вашего компьютера на подключенное устройство Android с использованием ADB.



  Метод принимает следующие параметры:

  - `source` (`str`): Путь на вашем компьютере к файлу или директории, который вы хотите скопировать.
  - `destination` (`str`): Путь назначения на устройстве, куда вы хотите скопировать файл или директорию.



  Метод возвращает логическое значение `bool`:
  - `True` - если файл или директория были успешно скопированы на устройство.
  - `False` - если произошла ошибка при копировании файла или директории.



  ```python
  adb = Adb()
  success = adb.push("/path/to/local/file.txt", "/path/to/device/file.txt")
  if success:
      print("Файл успешно скопирован на устройство.")
  else:
      print("Не удалось скопировать файл на устройство.")
  ```



  Метод `push()` использует команду `adb push` для копирования файла или директории на устройство.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.run()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для копирования файла или директории с подключенного устройства Android на ваш компьютер с использованием ADB.



  Метод принимает следующие параметры:

  - `source` (`str`): Путь на устройстве к файлу или директории, которые вы хотите скопировать.
  - `destination` (`str`): Путь назначения на вашем компьютере, куда вы хотите скопировать файл или директорию.



  Метод возвращает логическое значение `bool`:
  - `True` - если файл или директория были успешно скопированы с устройства.
  - `False` - если произошла ошибка при копировании файла или директории.



  ```python
  adb = Adb()
  success = adb.pull("/path/to/device/file.txt", "/path/to/local/file.txt")
  if success:
      print("Файл успешно скопирован с устройства.")
  else:
      print("Не удалось скопировать файл с устройства.")
  ```



  Метод `pull()` использует команду `adb pull` для копирования файла или директории с устройства.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.run()`. Если исключение возникает, оно логируется и метод возвращает `False`.




  Этот метод класса `Adb` предназначен для запуска конкретной активности на подключенном устройстве Android с использованием ADB.



  Метод принимает следующие параметры:

  - `package` (`str`): Имя пакета активности, которую вы хотите запустить.
  - `activity` (`str`): Имя активности, которую вы хотите запустить.



  Метод возвращает логическое значение `bool`:
  - `True` - если активность была успешно запущена на устройстве.
  - `False` - если произошла ошибка при запуске активности.



  ```python
  adb = Adb()
  success = adb.start_activity("com.example.app", "com.example.app.MainActivity")
  if success:
      print("Активность успешно запущена на устройстве.")
  else:
      print("Не удалось запустить активность на устройстве.")
  ```



  Метод `start_activity()` использует команду `adb shell am start` для запуска активности на устройстве. Параметр `-n` используется для указания имени активности в формате `[package]/[activity]`.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.check_output()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для принудительного завершения указанного пакета на подключенном устройстве Android с использованием ADB.



  Метод принимает следующие параметры:

  - `package` (`str`): Имя пакета приложения, которое вы хотите закрыть.



  Метод возвращает логическое значение `bool`:
  - `True` - если приложение было успешно закрыто на устройстве.
  - `False` - если произошла ошибка при закрытии приложения.



  ```python
  adb = Adb()
  success = adb.close_app("com.example.app")
  if success:
      print("Приложение успешно закрыто на устройстве.")
  else:
      print("Не удалось закрыть приложение на устройстве.")
  ```



  Метод `close_app()` использует команду `adb shell am force-stop` для принудительного завершения указанного пакета на устройстве.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может быть вызвано методом `subprocess.run()`. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для перезапуска приложения на подключенном устройстве Android. Он делает это, закрывая приложение, а затем запуская указанную активность.



  Метод принимает следующие параметры:

  - `package` (`str`): Имя пакета приложения, которое вы хотите перезапустить.
  - `activity` (`str`): Имя активности внутри пакета приложения, которую вы хотите запустить после закрытия приложения.



  Метод возвращает логическое значение `bool`:
  - `True` - если приложение было успешно перезапущено на устройстве.
  - `False` - если произошла ошибка при перезапуске приложения.



  ```python
  adb = Adb()
  success = adb.reboot_app("com.example.app", "com.example.app.MainActivity")
  if success:
      print("Приложение успешно перезапущено на устройстве.")
  else:
      print("Не удалось перезапустить приложение на устройстве.")
  ```



  Метод `reboot_app()` использует методы `close_app()` и `start_activity()` класса `Adb` для выполнения своей функции.



  Метод не обрабатывает исключения напрямую, но вызываемые им методы `close_app()` и `start_activity()` обрабатывают исключения `subprocess.CalledProcessError`. Если эти методы возвращают `False`, что указывает на появление исключения, то `reboot_app()` также возвращает `False`.



  Этот метод класса `Adb` предназначен для отправки события нажатия кнопки Home на подключенном устройстве Android.



  Метод не принимает никаких параметров.



  Метод возвращает логическое значение `bool`:
  - `True` - если событие нажатия кнопки Home было успешно отправлено на устройство.
  - `False` - если произошла ошибка при отправке события.



  ```python
  adb = Adb()
  success = adb.press_home()
  if success:
      print("Событие нажатия кнопки Home успешно отправлено.")
  else:
      print("Не удалось отправить событие нажатия кнопки Home.")
  ```



  Метод `press_home()` использует команду `adb shell input keyevent KEYCODE_HOME` для отправки события нажатия кнопки Home.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду отправки события. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для отправки события нажатия кнопки Back на подключенном устройстве Android.



  Метод не принимает никаких параметров.



  Метод возвращает логическое значение `bool`:
  - `True` - если событие нажатия кнопки Back было успешно отправлено на устройство.
  - `False` - если произошла ошибка при отправке события.



  ```python
  adb = Adb()
  success = adb.press_back()
  if success:
      print("Событие нажатия кнопки Back успешно отправлено.")
  else:
      print("Не удалось отправить событие нажатия кнопки Back.")
  ```



  Метод `press_back()` использует команду `adb shell input keyevent KEYCODE_BACK` для отправки события нажатия кнопки Back.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду отправки события. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для отправки события нажатия кнопки Menu на подключенном устройстве Android.



  Метод не принимает никаких параметров.



  Метод возвращает логическое значение `bool`:
  - `True` - если событие нажатия кнопки Menu было успешно отправлено на устройство.
  - `False` - если произошла ошибка при отправке события.



  ```python
  adb = Adb()
  success = adb.press_menu()
  if success:
      print("Событие нажатия кнопки Menu успешно отправлено.")
  else:
      print("Не удалось отправить событие нажатия кнопки Menu.")
  ```



  Метод `press_menu()` использует команду `adb shell input keyevent KEYCODE_MENU` для отправки события нажатия кнопки Menu.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду отправки события. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для отправки события нажатия числовой клавиши на подключенном устройстве Android.



  - `num` (int): Числовое значение клавиши для нажатия. Допустимые значения: от 0 до 9 и специальные символы (ADD, COMMA, DIVIDE, DOT, ENTER, EQUALS).



  Метод возвращает логическое значение `bool`:
  - `True` - если событие нажатия числовой клавиши было успешно отправлено на устройство.
  - `False` - если произошла ошибка при отправке события.



  ```python
  adb = Adb()
  success = adb.input_keycode_num_(5)
  if success:
      print("Событие нажатия числовой клавиши успешно отправлено.")
  else:
      print("Не удалось отправить событие нажатия числовой клавиши.")
  ```



  Метод `input_keycode_num_()` использует команду `adb shell input keyevent KEYCODE_NUMPAD_{num}` для отправки события нажатия числовой клавиши.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду отправки события. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для ввода определенного кода клавиши на подключенном устройстве Android.



  - `keycode` (str): Код клавиши для ввода. Примеры допустимых значений: "KEYCODE_HOME", "KEYCODE_BACK", "KEYCODE_VOLUME_UP" и т.д.



  Метод возвращает логическое значение `bool`:
  - `True` - если команда ввода клавиши была успешно выполнена.
  - `False` - если произошла ошибка при выполнении команды.



  ```python
  adb = Adb()
  success = adb.input_keycode("KEYCODE_HOME")
  if success:
      print("Команда ввода клавиши успешно выполнена.")
  else:
      print("Не удалось выполнить команду ввода клавиши.")
  ```



  Метод `input_keycode()` использует команду `adb shell input keyevent {keycode}` для ввода кода клавиши на устройстве.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ввода клавиши. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для ввода строки символов с помощью виртуальной клавиатуры на подключенном устройстве Android.



  - `text` (str): Строка символов для ввода.
  - `keyboard` (dict): Словарь с маппингом символов на координаты нажатий на виртуальной клавиатуре. Каждому символу в словаре соответствует кортеж из двух чисел, представляющих координаты нажатия (x, y).



  Метод возвращает логическое значение `bool`:
  - `True` - если ввод выполнен успешно.
  - `False` - если произошла ошибка при вводе символов.



  ```python
  keyboard_mapping = {
      'a': (100, 200),
      'b': (150, 200),
      
  }
  adb = Adb()
  success = adb.input_by_virtual_keyboard("ab", keyboard_mapping)
  if success:
      print("Ввод символов выполнен успешно.")
  else:
      print("Не удалось выполнить ввод символов.")
  ```



  Метод `input_by_virtual_keyboard()` использует функцию `tap()` класса `Adb` для ввода каждого символа, проходя по всем символам в заданной строке `text`.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке ввода символа. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для ввода текста на подключенном устройстве Android.



  - `text` (str): Текст для ввода на устройстве.



  Метод возвращает логическое значение `bool`:
  - `True` - если команда была успешно выполнена.
  - `False` - если произошла ошибка при выполнении команды.



  ```python
  adb = Adb()
  success = adb.input_text("Hello, World!")
  if success:
      print("Ввод текста выполнен успешно.")
  else:
      print("Не удалось выполнить ввод текста.")
  ```



  Метод `input_text()` использует команду `adb shell input text` для ввода текста на устройстве Android. Пожалуйста, убедитесь, что текст, который вы хотите ввести, не содержит специальных символов, которые могут нарушить работу команды ADB.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для совершения нажатия на экран устройства в заданных координатах.



  - `x` (str, int): Координата по оси X, где требуется произвести нажатие. Может быть как числом, так и строкой.
  - `y` (str, int): Координата по оси Y, где требуется произвести нажатие. Может быть как числом, так и строкой.



  Метод возвращает логическое значение `bool`:
  - `True` - если команда была успешно выполнена.
  - `False` - если произошла ошибка при выполнении команды.



  ```python
  adb = Adb()
  success = adb.tap(100, 200)
  if success:
      print("Нажатие выполнено успешно.")
  else:
      print("Не удалось выполнить нажатие.")
  ```



  Метод `tap()` использует команду `adb shell input tap` для совершения нажатия на экране устройства в указанных координатах.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для выполнения свайпа (перетаскивания) на экране устройства.



  - `start_x` (str, int): Координата X начальной точки свайпа. Может быть как числом, так и строкой.
  - `start_y` (str, int): Координата Y начальной точки свайпа. Может быть как числом, так и строкой.
  - `end_x` (str, int): Координата X конечной точки свайпа. Может быть как числом, так и строкой.
  - `end_y` (str, int): Координата Y конечной точки свайпа. Может быть как числом, так и строкой.
  - `duration` (int, optional): Длительность свайпа в миллисекундах. По умолчанию равна 300.



  Метод возвращает логическое значение `bool`:
  - `True` - если команда была успешно выполнена.
  - `False` - если произошла ошибка при выполнении команды.



  ```python
  adb = Adb()
  success = adb.swipe(100, 200, 300, 400)
  if success:
      print("Свайп выполнен успешно.")
  else:
      print("Не удалось выполнить свайп.")
  ```



  Метод `swipe()` использует команду `adb shell input swipe` для выполнения свайпа на экране устройства от начальной точки к конечной.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для получения названия пакета текущего запущенного приложения на устройстве.



  Метод не требует параметров.



  Метод возвращает строку, представляющую название пакета текущего запущенного приложения, или `None`, если произошла ошибка.



  ```python
  adb = Adb()
  package = adb.get_current_app_package()
  if package:
      print(f"Текущее приложение: {package}")
  else:
      print("Не удалось определить текущее приложение.")
  ```



  Метод `get_current_app_package()` использует команду `adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp' | grep -e 'mFo'` для получения информации о текущем запущенном приложении. Затем он анализирует результат этой команды, чтобы извлечь название пакета приложения.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `None`.



  Этот метод класса `Adb` предназначен для проверки, установлено ли VPN-соединение на устройстве.



  - `ip_address` (str, по умолчанию `''`): IP-адрес для проверки VPN-соединения. Если параметр не указан, используется значение из конфигурации.



  Метод возвращает булевое значение: `True`, если VPN-соединение активно, и `False` в противном случае.



  ```python
  adb = Adb()
  vpn_status = adb.check_vpn('192.168.1.1')
  if vpn_status:
      print("VPN-соединение активно.")
  else:
      print("VPN-соединение не активно.")
  ```



  Метод `check_vpn()` использует команду `adb shell netstat | grep -w -e [ip_address]` для проверки активности VPN-соединения. Если в выводе команды присутствует слово "ESTABLISHED", метод возвращает `True`, что означает, что VPN-соединение активно.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для остановки выполнения `logcat` на устройстве.



  Метод не принимает параметров.



  Метод возвращает булевое значение: `True`, если выполнение `logcat` остановлено успешно, и `False` в противном случае.



  ```python
  adb = Adb()
  logcat_status = adb.stop_logcat()
  if logcat_status:
      print("logcat успешно остановлен.")
  else:
      print("Не удалось остановить logcat.")
  ```



  Метод `stop_logcat()` сначала использует команду `adb shell ps | grep logcat` для получения списка процессов `logcat`. Затем, для каждого найденного процесса, он отправляет сигнал `SIGINT`, используя команду `adb shell kill -s SIGINT [pid]`.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `False`.



  Этот метод класса `Adb` предназначен для перезапуска adb-сервера на устройстве.



  Метод не принимает параметров.



  Метод возвращает булевое значение: `True`, если adb-сервер успешно перезапущен, и `False` в противном случае.



  ```python
  adb = Adb()
  adb_status = adb.reload_adb()
  if adb_status:
      print("adb-сервер успешно перезапущен.")
  else:
      print("Не удалось перезапустить adb-сервер.")
  ```



  Метод `reload_adb()` сначала использует команду `adb kill-server` для остановки adb-сервера. Затем, после паузы в три секунды, используется команда `adb start-server` для перезапуска adb-сервера.



  Метод обрабатывает исключение `subprocess.CalledProcessError`, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, оно логируется и метод возвращает `False`.




  Этот метод находит Process ID (PID) процесса по его имени, используя `adb shell ps`.



  Метод принимает следующие параметры:

  - `name`: Имя процесса, PID которого нужно найти.



  Метод возвращает PID процесса, если он найден, или `None`, если процесс не найден.



  ```python
  adb = Adb()
  process_pid = adb.know_pid("my_process")
  if process_pid:
      print("PID процесса 'my_process' найден.")
  else:
      print("Процесс 'my_process' не найден.")
  ```



  Метод `know_pid()` выполняет команду `adb shell ps` и затем проходит через вывод, пытаясь найти строку, которая содержит имя указанного процесса. Если такая строка найдена, метод извлекает PID из этой строки и возвращает его.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`. Также, если процесс с указанным именем не найден, метод возвращает `None`.



  Этот метод находит Process ID (PID) процесса по его имени, используя `adb shell ps`.



  Метод принимает следующие параметры:

  - `name` (str): Имя процесса, PID которого нужно найти.



  Метод возвращает PID процесса, если он найден, или `None`, если процесс не найден.



  ```python
  adb = Adb()
  process_pid = adb.know_pid("my_process")
  if process_pid:
      print("PID процесса 'my_process' найден.")
  else:
      print("Процесс 'my_process' не найден.")
  ```



  Метод `know_pid()` выполняет команду `adb shell ps` и затем проходит через вывод, пытаясь найти строку, которая содержит имя указанного процесса. Если такая строка найдена, метод извлекает PID из этой строки и возвращает его.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`. Также, если процесс с указанным именем не найден, метод возвращает `None`.



  Проверяет, запущен ли процесс, используя `adb shell ps`.



  - `name` (str): Имя процесса.



  Метод возвращает `True`, если процесс с указанным именем существует, и `False` в ином случае.



  ```python
  adb = Adb()
  if adb.is_process_exist("my_process"):
      print("Процесс 'my_process' существует.")
  else:
      print("Процесс 'my_process' не существует.")
  ```

  Данный метод `is_process_exist()` используется внутри метода `know_pid()` для определения наличия процесса с заданным именем.




  Запускает процесс в фоновом режиме на устройстве Android с использованием ADB.



  - `command` (str): Команда для выполнения на устройстве.
  - `process` (str): Название процесса, который будет запущен. По умолчанию пустая строка (`""`). Если `process == ""`, то не будет проверяться его запуск в системе.



  Метод возвращает `True`, если процесс был успешно запущен, и `False` в противном случае.



  ```python
  adb = Adb()
  command = "my_script.sh"
  process_name = "my_process"
  if adb.run_background_process(command, process_name):
      print(f"Процесс '{process_name}' был успешно запущен.")
  else:
      print(f"Не удалось запустить процесс '{process_name}'.")
  ```



  Метод `run_background_process()` запускает процесс в фоновом режиме на устройстве Android с использованием команды `adb shell` и `nohup` для выполнения команды без привязки к текущей сессии терминала. Вывод команды перенаправляется в `/dev/null`, чтобы не создавать логов в текущей сессии.

  Если указан аргумент `process`, метод проверяет наличие процесса с указанным именем, используя метод `is_process_exist(name)`, чтобы убедиться, что процесс был успешно запущен.

  В случае возникновения исключения при выполнении команды, метод возвращает `False`, а также логирует информацию об ошибке.




  Этот метод отправляет сигнал SIGINT для остановки процесса по указанному идентификатору PID с помощью ADB.



  Метод принимает следующий параметр:

  - `pid`: Идентификатор PID процесса для остановки.



  Метод возвращает `True`, если процесс успешно остановлен, и `False` в противном случае.



  ```python
  adb = Adb()
  process_status = adb.kill_by_pid("1234")
  if process_status:
      print("Процесс с PID '1234' успешно остановлен.")
  else:
      print("Не удалось остановить процесс с PID '1234'.")
  ```



  Метод `kill_by_pid()` выполняет команду `adb shell kill -s SIGINT <pid>`, чтобы отправить сигнал SIGINT указанному процессу. Этот сигнал останавливает процесс.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод останавливает все процессы с указанным именем на устройстве с помощью ADB.



  Метод принимает следующий параметр:

  - `name`: Имя процесса для остановки.



  Метод возвращает `True`, если все процессы успешно остановлены, и `False` в противном случае.



  ```python
  adb = Adb()
  process_status = adb.kill_by_name("my_process")
  if process_status:
      print("Все процессы с именем 'my_process' успешно остановлены.")
  else:
      print("Не удалось остановить процессы с именем 'my_process'.")
  ```



  Метод `kill_by_name()` выполняет команду `adb shell pkill -l SIGINT <name>`, чтобы остановить все процессы с указанным именем.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод останавливает все процессы, соответствующие указанному имени или шаблону имени, на устройстве с помощью ADB.



  Метод принимает следующий параметр:

  - `name`: Имя процесса или шаблон имени для остановки.



  Метод возвращает `True`, если все процессы успешно остановлены, и `False` в противном случае.



  ```python
  adb = Adb()
  process_status = adb.kill_all("my_process")
  if process_status:
      print("Все процессы, соответствующие имени 'my_process', успешно остановлены.")
  else:
      print("Не удалось остановить процессы, соответствующие имени 'my_process'.")
  ```



  Метод `kill_all()` выполняет команду `adb shell pkill -f <name>`, чтобы остановить все процессы, соответствующие указанному имени или шаблону имени.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод удаляет файлы из внутреннего хранилища устройства с помощью ADB.



  Метод принимает следующий параметр:

  - `path`: Путь к файлам для удаления.



  Метод возвращает `True`, если файлы успешно удалены, и `False` в противном случае.



  ```python
  adb = Adb()
  delete_status = adb.delete_files_from_internal_storage("/sdcard/MyFiles/")
  if delete_status:
      print("Файлы успешно удалены из '/sdcard/MyFiles/'.")
  else:
      print("Не удалось удалить файлы из '/sdcard/MyFiles/'.")
  ```



  Метод `delete_files_from_internal_storage()` выполняет команду `adb shell rm -rf <path>*` для удаления всех файлов в указанной директории.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод копирует видеофайлы с устройства на компьютер с помощью ADB.



  Метод принимает следующие параметры:

  - `wherefrom` (необязательный): Путь к исходной директории на устройстве, откуда нужно скопировать видеофайлы. Если не указан, по умолчанию используется путь '/sdcard/Movies/'.
  - `destination`: Путь для сохранения скопированных видеофайлов на компьютере.
  - `delete` (необязательный): Флаг, указывающий, следует ли удалять видеофайлы после копирования с устройства. По умолчанию значение `True`.



  Метод возвращает `True`, если видеофайлы успешно скопированы, и `False` в противном случае.



  ```python
  adb = Adb()
  copy_status = adb.pull_video("/sdcard/MyVideos/", "/home/user/Videos/")
  if copy_status:
      print("Видеофайлы успешно скопированы в '/home/user/Videos/'.")
  else:
      print("Не удалось скопировать видеофайлы в '/home/user/Videos/'.")
  ```



  Метод `pull_video()` сначала выполняет команду `adb pull <wherefrom> <destination>` для копирования видеофайлов из указанной директории на устройстве в указанную директорию на компьютере. Если флаг `delete` установлен в `True`, после копирования видеофайлы удаляются из исходной директории на устройстве командой `adb shell rm -rf <wherefrom>*`.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команды ADB. Если исключение возникает при выполнении любой из команд, информация об ошибке логируется и метод возвращает `False`.



  Этот метод останавливает запись видео на устройстве с помощью ADB.



  Метод не принимает никаких параметров.



  Метод возвращает `True`, если запись видео успешно остановлена, и `False` в противном случае.



  ```python
  adb = Adb()
  stop_status = adb.stop_video()
  if stop_status:
      print("Запись видео успешно остановлена.")
  else:
      print("Не удалось остановить запись видео.")
  ```



  Метод `stop_video()` выполняет команду `adb shell pkill -l SIGINT screenrecord` для остановки записи видео.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод начинает запись видео на устройстве с помощью ADB.



  - `filename` (`str`): Имя файла, в который будет сохранено видео на устройстве.



  Метод возвращает `True`, если запись видео успешно начата, и `False` в противном случае.



  ```python
  adb = Adb()
  record_status = adb.record_video("test_video.mp4")
  if record_status:
      print("Запись видео успешно начата.")
  else:
      print("Не удалось начать запись видео.")
  ```



  Метод `record_video()` выполняет команду `adb shell screenrecord /sdcard/Movies/{filename}`, чтобы начать запись видео.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод перезагружает устройство с помощью ADB.



  Метод не принимает никаких параметров.



  Метод возвращает `True`, если перезагрузка устройства успешно запущена, и `False` в противном случае.



  ```python
  adb = Adb()
  reboot_status = adb.reboot()
  if reboot_status:
      print("Перезагрузка устройства успешно запущена.")
  else:
      print("Не удалось запустить перезагрузку устройства.")
  ```



  Метод `reboot()` выполняет команду `adb shell reboot`, чтобы перезагрузить устройство.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `False`.



  Этот метод возвращает разрешение экрана устройства с использованием ADB.



  Метод не принимает никаких параметров.



  Метод возвращает кортеж с двумя целыми числами, представляющими ширину и высоту экрана в пикселях. Если при выполнении возникает ошибка, метод возвращает `None`.



  ```python
  adb = Adb()
  screen_resolution = adb.get_screen_resolution()
  if screen_resolution:
      width, height = screen_resolution
      print(f"Разрешение экрана устройства: {width}x{height}.")
  else:
      print("Не удалось получить разрешение экрана устройства.")
  ```



  Метод `get_screen_resolution()` выполняет команду `adb shell wm size`, чтобы получить физическое разрешение экрана устройства.



  Метод обрабатывает исключение, которое может возникнуть при попытке выполнить команду ADB. Если исключение возникает, информация об ошибке логируется и метод возвращает `None`.


