# packages

pkgId: 04bd6cc6df06235cc28e75e1a4607d984d707ce8db41d9d97621f8eee7ed0144
name: python-anticaptchaofficial
arch: src
version: 1.0.61
epoch: 0
release: 1
summary: Official anti-captcha.com library
url: https://github.com/anti-captcha/anticaptcha-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anticaptchaofficial-1.0.61-1.src.rpm
checksum_type: sha256
description:
  Official https://anti-captcha.com/ library for solving images with text, Recaptcha v2/v3 Enterprise or non-Enterprise, Funcaptcha Arcoselabs, GeeTest and hCaptcha Enterprise or non-Enterprise.
  Anti-Captcha is the most popular and reliable captcha solving service, working since 2007.
  Prices for solving captchas start from $0.0005 per item.
  ```bash
  pip3 install anticaptchaofficial
  ```
  &nbsp;
  Check API key balance before creating tasks:
  ```python
  balance = solver.get_balance()
  if balance <= 0:
      print("too low balance!")
      return
  ```
  &nbsp;
  <br>
  Check subscription credits balance if you have one:
  ```python
  credits = solver.get_credits_balance()
  if credits <= 0:
      print("too low credits balance!")
      return
  ```
  &nbsp;
  Example how to create [Recaptcha V2](https://anti-captcha.com/apidoc/task-types/RecaptchaV2TaskProxyless) task and receive g-response:
  ```python
  from anticaptchaofficial.recaptchav2proxyless import *
  solver = recaptchaV2Proxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_API_KEY")
  solver.set_website_url("https://website.com")
  solver.set_website_key("SITE_KEY")






  solver.set_soft_id(0)
  g_response = solver.solve_and_return_solution()
  if g_response != 0:
      print "g-response: "+g_response
  else:
      print "task finished with error "+solver.error_code
  ```
  Report previosly solved Recaptcha V2/V3/Enterprise as incorrect:
  ```python
  solver.report_incorrect_recaptcha()
  ```
  Report it as correct to improve your quality:
  ```python
  solver.report_correct_recaptcha()
  ```
  ___
  &nbsp;
  Solve [image captcha](https://anti-captcha.com/apidoc/task-types/ImageToTextTask):
  ```python
  from anticaptchaofficial.imagecaptcha import *
  solver = imagecaptcha()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")


  solver.set_soft_id(0)
  captcha_text = solver.solve_and_return_solution("captcha.jpeg")
  if captcha_text != 0:
      print("captcha text "+captcha_text)
  else:
      print("task finished with error "+solver.error_code)
  ```
  Report previosly solved image captcha as incorrect:
  ```python
  solver.report_incorrect_image_captcha()
  ```
  ___
  &nbsp;
  Solve [HCaptcha](https://anti-captcha.com/apidoc/task-types/HCaptchaTask):
  ```python
  from anticaptchaofficial.hcaptchaproxyless import *
  solver = hCaptchaProxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")
  solver.set_website_url("https://website.com")
  solver.set_website_key("SITE_KEY")
  solver.set_user_agent("YOUR FULL USER AGENT HERE")




  solver.set_soft_id(0)
  g_response = solver.solve_and_return_solution()
  if g_response != 0:
      print("g-response: "+g_response)
      
      print("user-agent: "+solver.get_user_agent())
      print("respkey, if any: ", solver.get_respkey())
  else:
      print("task finished with error "+solver.error_code)
  ```
  Report previosly solved Hcaptcha as incorrect:
  ```python
  solver.report_incorrect_hcaptcha()
  ```
  ___
  &nbsp;
  Solve [Funcaptcha](https://anti-captcha.com/apidoc/task-types/FunCaptchaTaskProxyless) (Arkoselabs):
  ```python
  from anticaptchaofficial.funcaptchaproxyless import *
  solver = funcaptchaProxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")
  solver.set_website_url("https://website.com")
  solver.set_website_key("XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX")
  token = solver.solve_and_return_solution()
  if token != 0:
      print("result token: "+token)
  else:
      print("task finished with error "+solver.error_code)
  ```
  ___
  &nbsp;
  Solve [GeeTest](https://anti-captcha.com/apidoc/task-types/GeeTestTask) captcha:
  ```python
  from anticaptchaofficial.geetestproxyless import *
  solver = geetestProxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_API_KEY")
  solver.set_website_url("https://address.com")
  solver.set_gt_key("CONSTANT_GT_KEY")
  solver.set_challenge_key("VARIABLE_CHALLENGE_KEY")
  token = solver.solve_and_return_solution()
  if token != 0:
      print("result tokens: ")
      print(token)
  else:
      print("task finished with error "+solver.error_code)
  ```
  ___
  &nbsp;
  Solve [GeeTest v4](https://anti-captcha.com/apidoc/task-types/GeeTestTask) captcha:
  ```python
  from anticaptchaofficial.geetestproxyless import *
  solver = geetestProxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_API_KEY")
  solver.set_website_url("https://address.com")
  solver.set_version(4)
  solver.set_init_parameters({"riskType": "slide"})
  token = solver.solve_and_return_solution()
  if token != 0:
      print("result tokens: ")
      print(token)
  else:
      print("task finished with error "+solver.error_code)
  ```
  ___
  &nbsp;
  Solve [HCaptcha Enterprise](https://anti-captcha.com/apidoc/task-types/HCaptchaTask):
  ```python
  from anticaptchaofficial.hcaptchaproxyless import *
  solver = hCaptchaProxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")
  solver.set_website_url("https://website.com")
  solver.set_website_key("SITE_KEY")
  solver.set_user_agent("YOUR FULL USER AGENT HERE")





  solver.set_enterprise_payload({
      "rqdata": "rq data value from target website",
      "sentry": True
  })
  g_response = solver.solve_and_return_solution()
  if g_response != 0:
      print("g-response: "+g_response)
      
      print("user-agent: "+solver.get_user_agent())
      print("respkey, if any: ", solver.get_respkey())
  else:
      print("task finished with error "+solver.error_code)
  ```
  ___
  &nbsp;
  Example how to create [Turnstile](https://anti-captcha.com/apidoc/task-types/TurnstileTaskProxyless) task and receive a token:
  ```python
  from anticaptchaofficial.turnstileproxyless import *
  solver = turnstileProxyless()
  solver.set_verbose(1)
  solver.set_key("YOUR_API_KEY")
  solver.set_website_url("https://website.com")
  solver.set_website_key("SITE_KEY")

  solver.set_action("login")

  solver.set_action("some_custom_token")


  solver.set_soft_id(0)
  token = solver.solve_and_return_solution()
  if token != 0:
      print "token: "+token
  else:
      print "task finished with error "+solver.error_code
  ```
  ___
  &nbsp;
  Solve [AntiGate](https://anti-captcha.com/apidoc/task-types/AntiGateTask) task:
  ```python
  from anticaptchaofficial.antigatetask import *
  solver = antigateTask()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")
  solver.set_website_url("http://antigate.com/logintest.php")
  solver.set_template_name("Sign-in and wait for control text")
  solver.set_variables({
      "login_input_css": "#login",
      "login_input_value": "test login",
      "password_input_css": "#password",
      "password_input_value": "test password",
      "control_text": "You have been logged successfully"
  })
  result  = solver.solve_and_return_solution()
  if result != 0:
      cookies, localStorage, fingerprint, url, domain = result["cookies"], result["localStorage"], result["fingerprint"], result["url"], result["domain"]
      print("cookies: ", cookies)
      print("localStorage: ", localStorage)
      print("fingerprint: ", fingerprint)
      print("url: "+url)
      print("domain: "+domain)
  else:
      print("task finished with error "+solver.error_code)
  ```
  ___
  &nbsp;
  Solve [AntiBotCookieTask](https://anti-captcha.com/apidoc/task-types/AntiBotCookieTask) task to bypass Cloudflare, Datadome and others:
  ```python
  from anticaptchaofficial.antibotcookietask import *
  solver = antibotcookieTask()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")
  solver.set_website_url("https://www.somewebsite.com/")
  solver.set_proxy_address("1.2.3.4")
  solver.set_proxy_port(3128)
  solver.set_proxy_login("login")
  solver.set_proxy_password("password")
  result = solver.solve_and_return_solution()
  if result == 0:
      print("could not solve task")
      exit()
  print(result)
  cookies, localStorage, fingerprint = result["cookies"], result["localStorage"], result["fingerprint"]
  if len(cookies) == 0:
      print("empty cookies, try again")
      exit()
  cookie_string = '; '.join([f'{key}={value}' for key, value in cookies.items()])
  user_agent = fingerprint['self.navigator.userAgent']
  print(f"use these cookies for requests: {cookie_string}")
  print(f"use this user-agent for requests: {user_agent}")
  s = requests.Session()
  proxies = {
    "http": "http://login:password@1.2.3.4:3128",
    "https": "http://login:password@1.2.3.4:3128"
  }
  s.proxies = proxies
  content = s.get("https://www.somewebsite.com/", headers={
      "Cookie": cookie_string,
      "User-Agent": user_agent
  }).text
  print(content)
  ```
  ___
  &nbsp;
  Get [object coordinates](https://anti-captcha.com/apidoc/task-types/ImageCoordinatesTask) in an image:
  ```python
  from anticaptchaofficial.imagetocoordinates import *
  solver = imagetocoordinates()
  solver.set_verbose(1)
  solver.set_key("YOUR_KEY")
  solver.set_mode("points")
  solver.set_comment("Select in specified order")


  solver.set_soft_id(0)
  coordinates = solver.solve_and_return_solution("coordinates.png")
  if coordinates != 0:
      print("coordinates: ", captcha_text)
  else:
      print("task finished with error "+solver.error_code)
  ```
  Report previosly solved captcha as incorrect:
  ```python
  solver.report_incorrect_image_captcha()
  ```
  ___


pkgId: 2ebbb896e6599ae4b87ac2ec9dd6d625ffc19257301e319e32dfd394e9a1f378
name: python-anticor-features
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Anti-correlation based feature selection for single cell datasets
url: https://scottyler892@bitbucket.org/scottyler892/anticor_features
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anticor-features-0.2.1-1.src.rpm
checksum_type: sha256
description:
  Anti-correlated genes as a method of feature selection
  * Unsupervised feature selection for single cell omics (or anything else!) that passes the null-dataset test



  `python3 -m pip install anticor_features`

  You can also install using the setup.py script in the distribution like so:
  `python3 setup.py install`

  This should take less than one minute or even seconds if dependecies were already installed.



  ```
  from anticor_features.anticor_features import get_anti_cor_genes





  anti_cor_table = get_anti_cor_genes(in_mat,
                                      all_features,
                                      species="hsapiens")

  ```
  A list of the gProfiler accepted species codes is listed here: https://biit.cs.ut.ee/gprofiler/page/organism-list

  The above call yields a pandas data frame that will give you the collected summary statistics, and let you filter based on the features annotated as "selected" in that column
  ```
  >>> print(anti_cor_table.head())
       gene  pre_remove_feature  pre_remove_pathway  ...       FDR  num_sig_pos_cor  selected
  0    Xkr4               False               False  ...       NaN              NaN       NaN
  1     Rp1               False               False  ...       NaN              NaN       NaN
  2   Sox17               False               False  ...  0.001883           3406.0      True
  3  Mrpl15               False                True  ...       NaN              NaN       NaN
  4  Lypla1               False                True  ...       NaN              NaN       NaN
  ```
  The NaNs are produced where the gene was not assayed for anti-correlations either from pre-filtering
  (the default is to remove genes in pathways related to mitochondria, ribosomes, and hemoglobin).

  If you want to customize which GO terms are removed, or specify specific genes to exclude, you can do that with the pre_remove_features and pre_remove_pathways arguments
  ```
  anti_cor_table = get_anti_cor_genes(in_mat,
                                      all_features,
                                      species="hsapiens",
                                      pre_remove_features = ["ACTB","MT-COX1"])

  ```


  * If you're using scanpy, then you can use the same basic syntax as above. The only thing worth noting is that our downsampling function assumes that the genes are in rows, and cells are in columns, which is flipped from AnnData's formatting, that's why we use the have the transpose() functions below:

  If you follow along [Scanpy's tutorial](https://scanpy-tutorials.readthedocs.io/en/latest/pbmc3k.html), then the only thing different would be swapping out:

  ```
  [16]: sc.pp.highly_variable_genes(adata, min_mean=0.0125, max_mean=3, min_disp=0.5)
  [17]: sc.pl.highly_variable_genes(adata)
  [18]: adata.raw = adata
  [19]: adata = adata[:, adata.var.highly_variable]
  ```
  for
  ```
  from anticor_features.anticor_features import get_anti_cor_genes

  anti_cor_table = get_anti_cor_genes(adata.X.T,
                                      adata.var.index.tolist(),
                                      species="hsapiens")

  selected_table = anti_cor_table[anti_cor_table["selected"]==True]
  print(selected_table)


  import pandas as pd
  adata.var = pd.concat([adata.var,anti_cor_table], axis=1)


  adata.raw = adata
  adata = adata[:, selected_table.index]


  ```
  It should take ~ 1-2 minute(s) for the feature selection depending on your internet connection, the speed of the gprofiler server (if looking up pathways like ribosomes, mitochondria, etc to remove), but will also scale a bit with the complexity of the dataset. For example, the tabula muris dataset used in the manuscript took ~ 60 minutes, in part because nearly every gene was expressed at appreciable values in a subset of the cells.

  * *An important note if you're working in a cluster environment*
  ** Anti-correlated genes are selected out of memory - to do this, the pipeline needs a hard-disk area to work in. On a stand-alone computer it'll automatically find the system temp drive, but this might not be the behavior you want on a cluster, or if you're analyzing several datasets simultaneously because they would overwrite each other.
  ** In those cases, you should supply the additional argument `scratch_dir=</local/path/to/dataset/directory>`. This ensures that each dataset will be analyzed properly and there won't be conflicts in terms of where files get written.


  You can also use this tool at the command line, if you have either a .tsv or an hdf5 file, with the matrix under the key "infile"

  ```
  python3 -m anticor_features.anticor_features -i exprs.tsv -species mmusculus
  ```
  or something similar. This outputs the pandas table to a tsv in the same folder as the input file

  See the help section for more detailed usage of the command line interface:
  ```
  python3 -m anticor_features.anticor_features -h
  ```


  This package is available via the AGPLv3 license.



  * Repo owner/admin: scottyler89+bitbucket@gmail.com


pkgId: cf893f1102788174921fe9f8b8a30960bcf05398672dcb7e3356352b00009490
name: python-antidote
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Dependency injection.
url: https://github.com/Finistere/antidote
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antidote-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Antidote works with a :code:`Catalog` which is a sort of collection of dependencies. Multiple ones can co-exist, but :code:`world` is used by default. The most common form of a dependency is an instance of a given class
      from antidote import injectable
      @injectable
      class Service:
          pass
      world[Service]  # retrieve the instance
      world.get(Service, default='something')  # similar to a dict
  By default, :code:`@injectable` defines a singleton but alternative lifetimes (how long the :code:`world` keeps value alive in its cache) exists such as :code:`transient` where nothing is cached at all. Dependencies can also be injected into a function/method with :code:`@inject`. With both, Mypy, Pyright and PyCharm will infer the correct types.
      from antidote import inject
      @inject  #                      ⯆ Infers the dependency from the type hint
      def f(service: Service = inject.me()) -> Service:
          return service
      f()  # service injected
      f(Service())  # useful for testing: no injection, argument is used
      from antidote import InjectMe
      
      @inject
      def f2(service = inject[Service]):
      @inject(kwargs={'service': Service})
      def f3(service):
      @inject
      def f4(service: InjectMe[Service]):
  Classes can also be fully wired, all methods injected, easily with :code:`@wire`. It is also possible to
  inject the first argument, commonly named :code:`self`, of a method with an instance of a class:
      @injectable
      class Dummy:
          @inject.method
          def method(self) -> 'Dummy':
              return self
      
      assert Dummy.method() is world[Dummy]
      
      dummy = Dummy()
      assert dummy.method() is dummy


pkgId: b2e18991511e4094e3e7df14376a31741584d8d701be8e4114dc5c516d396d77
name: python-antigranular-enterprise
arch: src
version: 1.3.0
epoch: 0
release: 1
url: https://pypi.org/project/antigranular-enterprise/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antigranular-enterprise-1.3.0-1.src.rpm
checksum_type: sha256
summary:
  Antigranular Enterprise is a robust, scalable version of the Antigranular platform. It combines the power of differential privacy, providing a secure environment for handling and unlocking the full potential of unseen data. With enhanced features and dedicated support, Antigranular Enterprise is the ideal solution for businesses seeking to leverage the power of data privacy and security.

description:
  The `antigranular_enterprise` package is a specialized client designed for secure and private interactions with the Antigranular Enterprise platform. It supports data analysis and model training in both Jupyter notebook and standard Python interactive shell environments, emphasizing privacy and data protection. This documentation provides guidance on installing, configuring, and utilizing the client package to fully integrate the capabilities of Antigranular Enterprise into your data science workflows.



  To integrate Antigranular Enterprise with your environment, install the package using pip:

  ```bash
  pip install antigranular_enterprise
  ```

  This command installs the `antigranular_enterprise` package and its necessary dependencies, setting up your environment for secure, privacy-preserving data science operations.





  Configure the package to communicate with your Antigranular Enterprise instance. Essential parameters include:

  - **AGENT Jupyter Server URL**: URL for the proxy server routing requests to the Antigranular platform.
  - **AGENT Jupyter Server Port**: Port on which the proxy listens.
  - **AGENT Console URL**: URL for accessing the Antigranular management console.
  - **TLS Enabled**: Set to `true` if TLS is enabled for the proxy to ensure secure communication.



  Configure your environment to interact with the Antigranular Enterprise platform in a way that best suits your setup and preferences.



  This is the simplest and recommended method for configuration:

  1. **Navigate to the UI Configuration Page**: Open your browser and visit `https://<ui_url>/config/client`.
  2. **Copy the Configuration Code**: The page will display a pre-formatted configuration snippet.
  3. **Execute the Configuration Code**: Run the copied code in your environment to automatically load the configuration.

     ```python
     import antigranular_enterprise as ag
     ag.load_config("https://<ui_url>/config/client", profile='default')
     ```



  Alternatively, you can manually set up the configuration:

  1. **Import the Package**: Begin by importing `antigranular_enterprise`.

     ```python
     import antigranular_enterprise as ag
     ```

  2. **Write the Configuration**:

     Save your configuration settings using the `write_config` method:

     ```python
     ag.write_config(profile='default', yaml_config="""
     agent_jupyter_url: <Jupyter URL>
     agent_jupyter_port: <Jupyter Port>
     agent_console_url: <Console URL>
     tls_enabled: true
     """)
     ```

     Replace placeholders with the appropriate values for your environment.







  Log in to the Antigranular Enterprise services from Jupyter notebooks:

  ```python
  client = ag.login("<api_key>")
  ```

  After entering your API key, a UI notification or link will prompt you for approval. Once approved, your session starts, allowing secure interactions with the Antigranular platform.



  In Jupyter notebooks, use the `%ag` magic command to execute code securely on the server:

  ```python
  %ag
  ag_print("hello", "world")
  ```





  This script demonstrates a simple login to the Antigranular server, executes a basic print command, and displays the server's response directly.

  **script.py**:

  ```python

  import antigranular_enterprise as ag


  session = ag.login("Your_API_Key")
  response = session.execute("ag_print('Hello', 'World!')")
  print(response)


  session.execute("var = 'test'; export(var, 'varlocal')", globals())
  print(varlocal)  # Outputs: test


  terminate_session_response = session.terminate_session()
  print(terminate_session_response)  # Outputs: {'status': 'ok'}

  ```
  Output:
  ```plaintext
  > python script.py
  Connected to Antigranular server session id: <masked>
  Hello World!
  Setting up exported variable in local environment: varlocal
  test
  {'status': 'ok'}
  ```



  All package methods are supported within these sessions, including:

  - **`interrupt_kernel()`**: Interrupts the currently running kernel.
  - **`terminate_session()`**: Terminates the session and cleans up resources.
  - **`privacy_odometer()`**: Returns the amount of epsilon and delta used.
  - **`private_import()`**: Imports a user-provided model or dataset into the AG server securely.



  The `antigranular_enterprise` package offers a suite of features for secure data analysis and model training, with robust support for privacy regulations. It is designed to integrate seamlessly into Jupyter notebooks and Python interactive shells, enhancing the data science workflow with privacy-preserving capabilities.

  For further information or support, please consult the Antigranular Enterprise platform's detailed documentation or contact our support team directly.


pkgId: 03e15576309d5d40930561f69756dd0582f98b1cf92f2410fd93275ea44eb9fa
name: python-antimeridian
arch: src
version: 0.3.11
epoch: 0
release: 1
summary: Fix GeoJSON geometries that cross the 180th meridian
url: https://pypi.org/project/antimeridian/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antimeridian-0.3.11-1.src.rpm
checksum_type: sha256
description:
  [![CI Status](https://img.shields.io/github/actions/workflow/status/gadomski/antimeridian/ci.yaml?style=for-the-badge&label=CI)](https://github.com/gadomski/antimeridian/actions/workflows/ci.yaml)
  [![Read the Docs](https://img.shields.io/readthedocs/antimeridian?style=for-the-badge)](https://antimeridian.readthedocs.io/en/stable/)
  [![PyPI](https://img.shields.io/pypi/v/antimeridian?style=for-the-badge)](https://pypi.org/project/antimeridian/)

  [![GitHub](https://img.shields.io/github/license/gadomski/antimeridian?style=for-the-badge)](https://github.com/gadomski/antimeridian/blob/main/LICENSE)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg?style=for-the-badge)](https://github.com/gadomski/antimeridian/blob/main/CODE_OF_CONDUCT)

  <img src="https://github.com/gadomski/antimeridian/blob/main/docs/img/complex-split.png?raw=true" style="width: 600px;" alt="Demonstration image" />

  Fix shapes that cross the antimeridian.
  See [the documentation](https://antimeridian.readthedocs.io) for information about the underlying algorithm.
  Depends on [shapely](https://shapely.readthedocs.io) and [numpy](https://numpy.org/).

  Can fix:

  - Shapely [`Polygon`](https://shapely.readthedocs.io/en/stable/reference/shapely.Polygon.html#shapely.Polygon), [`MultiPolygon`](https://shapely.readthedocs.io/en/stable/reference/shapely.MultiPolygon.html#shapely.MultiPolygon), [`LineString`](https://shapely.readthedocs.io/en/stable/reference/shapely.LineString.html#shapely.LineString), and [`MultiLineString`](https://shapely.readthedocs.io/en/stable/reference/shapely.MultiLineString.html#shapely.MultiLineString) objects
  - GeoJSON [Polygons](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6), [MultiPolygons](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.7), [Features](https://datatracker.ietf.org/doc/html/rfc7946#section-3.2) and [FeatureCollections](https://datatracker.ietf.org/doc/html/rfc7946#section-3.3), as dictionaries
  - Anything that has a [`__geo_interface__`](https://gist.github.com/sgillies/2217756)



  ```shell
  python -m pip install antimeridian
  ```

  Then:

  ```python
  import antimeridian

  fixed = antimeridian.fix_geojson(geojson)
  ```

  We also have some utilities to create [bounding boxes](https://antimeridian.readthedocs.io/en/latest/api.html#antimeridian.bbox) and [centroids](https://antimeridian.readthedocs.io/en/latest/api.html#antimeridian.centroid) from antimeridian-crossing polygons and multipolygons.
  See [the documentation](https://antimeridian.readthedocs.io/) for a complete API reference.



  Use the `cli` optional dependency to install the `antimeridian` CLI:

  ```shell
  python -m pip install 'antimeridian[cli]'
  antimeridian fix input.json > output.json
  ```



  Get [uv](https://docs.astral.sh/uv/getting-started/installation/).
  Then:

  ```shell
  git clone https://github.com/gadomski/antimeridian
  cd antimeridian
  uv sync
  ```

  We use [pytest](https://docs.pytest.org) for tests:

  ```shell
  uv run pytest
  ```

  We use [Sphinx](https://www.sphinx-doc.org) for docs:

  ```shell
  make -C docs html
  ```



  See [CONTRIBUTING.md](./CONTRIBUTING.md).



  [Apache-2.0](https://github.com/gadomski/antimeridian/blob/main/LICENSE)


pkgId: caaca52eb93285179be11b6e2ae6b7963eae3d86c46e7df2452c977b39ea78de
name: python-antimeridian
arch: src
version: 0.3.9
epoch: 0
release: 1
summary: Fix GeoJSON geometries that cross the 180th meridian
url: https://pypi.org/project/antimeridian/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antimeridian-0.3.9-1.src.rpm
checksum_type: sha256
description:
  [![CI Status](https://img.shields.io/github/actions/workflow/status/gadomski/antimeridian/ci.yaml?style=for-the-badge&label=CI)](https://github.com/gadomski/antimeridian/actions/workflows/ci.yaml)
  [![Read the Docs](https://img.shields.io/readthedocs/antimeridian?style=for-the-badge)](https://antimeridian.readthedocs.io/en/stable/)
  [![PyPI](https://img.shields.io/pypi/v/antimeridian?style=for-the-badge)](https://pypi.org/project/antimeridian/)

  [![GitHub](https://img.shields.io/github/license/gadomski/antimeridian?style=for-the-badge)](https://github.com/gadomski/antimeridian/blob/main/LICENSE)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg?style=for-the-badge)](https://github.com/gadomski/antimeridian/blob/main/CODE_OF_CONDUCT)

  <img src="https://github.com/gadomski/antimeridian/blob/main/docs/img/complex-split.png?raw=true" style="width: 600px;" alt="Demonstration image" />

  Fix shapes that cross the antimeridian.
  See [the documentation](https://antimeridian.readthedocs.io) for information about the underlying algorithm.
  Depends on [shapely](https://shapely.readthedocs.io) and [numpy](https://numpy.org/).

  Can fix:

  - Shapely [`Polygon`](https://shapely.readthedocs.io/en/stable/reference/shapely.Polygon.html#shapely.Polygon), [`MultiPolygon`](https://shapely.readthedocs.io/en/stable/reference/shapely.MultiPolygon.html#shapely.MultiPolygon), [`LineString`](https://shapely.readthedocs.io/en/stable/reference/shapely.LineString.html#shapely.LineString), and [`MultiLineString`](https://shapely.readthedocs.io/en/stable/reference/shapely.MultiLineString.html#shapely.MultiLineString) objects
  - GeoJSON [Polygons](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6), [MultiPolygons](https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.7), [Features](https://datatracker.ietf.org/doc/html/rfc7946#section-3.2) and [FeatureCollections](https://datatracker.ietf.org/doc/html/rfc7946#section-3.3), as dictionaries
  - Anything that has a [`__geo_interface__`](https://gist.github.com/sgillies/2217756)



  ```shell
  python -m pip install antimeridian
  ```

  Then:

  ```python
  import antimeridian

  fixed = antimeridian.fix_geojson(geojson)
  ```

  We also have some utilities to create [bounding boxes](https://antimeridian.readthedocs.io/en/latest/api.html#antimeridian.bbox) and [centroids](https://antimeridian.readthedocs.io/en/latest/api.html#antimeridian.centroid) from antimeridian-crossing polygons and multipolygons.
  See [the documentation](https://antimeridian.readthedocs.io/) for a complete API reference.



  Use the `cli` optional dependency to install the `antimeridian` CLI:

  ```shell
  python -m pip install 'antimeridian[cli]'
  antimeridian fix input.json > output.json
  ```



  Get [uv](https://docs.astral.sh/uv/getting-started/installation/).
  Then:

  ```shell
  git clone https://github.com/gadomski/antimeridian
  cd antimeridian
  uv sync
  ```

  We use [pytest](https://docs.pytest.org) for tests:

  ```shell
  uv run pytest
  ```

  We use [Sphinx](https://www.sphinx-doc.org) for docs:

  ```shell
  make -C docs html
  ```



  Github [issues](https://github.com/gadomski/antimeridian/issues) and [pull requests](https://github.com/gadomski/antimeridian/pulls), please and thank you!



  [Apache-2.0](https://github.com/gadomski/antimeridian/blob/main/LICENSE)


pkgId: 16797ed93ef86a20105a389668d09a19ded6be7f908ffd3d60dffc9fdcb6265a
name: python-antiorm
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: A Pythonic Helper for DBAPI-2.0 SQL Access
url: http://furius.ca/antiorm
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antiorm-1.2.1-1.src.rpm
checksum_type: sha256
description:
  Anti-ORM is not an ORM, and it certainly does not want to be.  Anti-ORM is a
  simple Python module that provides a pythonic syntax for making it more
  convenient to build SQL queries over the DBAPI-2.0 interface.

  In practice, if you're the kind of person that likes it to the bare metal, it's
  almost as good as the ORMs.  At least there is no magic, and it just works.


pkgId: b386a25402229f357d494403af7545e4e2fbcf2988d1bd3c49460e7d7acee55f
name: python-antipathy
arch: src
version: 0.85.4
epoch: 0
release: 1
summary: oo view of file paths and names, subclassed from bytes/str/unicode
url: https://github.com/ethanfurman/antipathy
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antipathy-0.85.4-1.src.rpm
checksum_type: sha256
description:
  Tired of calling a function for every path manipulation you need to do?
  Is::
      >>> path, filename = os.path.split(some_name)
      >>> basename, ext = os.path.splitext(filename)
      >>> basename = basename + '_01'
      >>> new_name = os.path.join(path, basename+ext)
  wearing on your nerves?
  In short, are you filled with antipathy [1] for os.path?
  Then get antipathy and work with Path::
      >>> from antipathy import Path
      >>> some_name = Path('/home/ethan/source/my_file.txt')
      >>> backups = Path('/home/ethan/backup/')
      >>> print some_name.path
      '/home/ethan/source/'
      >>> print some_name.ext
      '.txt'
      >>> print some_name.exists()
      True  # (well, if it happens to exist at this moment ;)
      >>> backup = backups / some_name.filename + '_01' + some_name.ext
      >>> print backup
      '/home/ethan/backup/my_file_01.txt'
      >>> some_name.copy(backup)
  Because Path is a subclass of bytes/str/unicode, it can still be passed to other functions that expect a bytes/str/unicode object and work seamlessly [2].
  [1] https://www.google.com/#q=antipathy
  [2] in most cases -- there are a few places that do a `type` check instead of an `isinstance` check.


pkgId: 78973f3b96bca3f55179c866d36fa79caae7303bfe7cbf64ed1df03c3cdf0317
name: python-antipetros_discordbot
arch: src
version: 2.1.4
epoch: 0
release: 1
summary: A Discord Bot for the Antistasi (ArmA 3) Community Discord Server
url: https://github.com/Giddius/Antipetros_Discord_Bot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antipetros_discordbot-2.1.4-1.src.rpm
checksum_type: sha256
description:
    - [Installation](#installation)
      - [PyPi](#pypi)
    - [Usage](#usage)
    - [Description](#description)
    - [Features](#features)
    - [Dependencies](#dependencies)
      - [Python dependencies](#python-dependencies)
      - [External dependencies](#external-dependencies)
    - [License](#license)
    - [Development](#development)
      - [Future Plans](#future-plans)
    - [See also](#see-also)


pkgId: fd2503870bd6aa1554c43a55cbc8c6ef49cb855dd8dd59bbec89a617cedca17e
name: python-antipickle
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Like pickle. But different
url: https://pypi.org/project/antipickle/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antipickle-0.2.0-1.src.rpm
checksum_type: sha256
description:
  **when you want to use pickle, but you shouldn't**
  Why? Because pickle isn't the right way to persist or share data, and [we all know that](#when-to-not-use-pickle).
  When it comes to practice, it takes time and effort to substitute pickle. <br />
  'Hmm, I can use json here' &mdash; I thought on many occasions, and usually was wrong.
  Something small but annoying was in the way: <br />
  `datetime` that can't be stored or `np.array` that serializers don't know how to deal with.
  Or even `bytes`! And many smaller things.
  At this point I either had to give up and pickle it <br />
  OR allocate time on figuring out 'how do I make this right'.
  `antipickle` solves this for me.
  `antipickle` is a **restricted** format for **safe, persistent, and platform-independent** storage.
  Also, it is very convenient:
  ```python
  import antipickle
  antipickle.dump(data, 'data.antipickle')
  antipickle.dump(data, 's3://mybucket/data.antipickle')     # stores in s3
  antipickle.dump(data, 's3://mybucket/data.antipickle.gz')  # will additionally gzip
  loaded_date = antipickle.load('s3://mybucket/data.antipickle.gz') # or local file
  ```
  <!---
  **Table of Contents**
  - [Installation](#installation)
  - [License](#license)


pkgId: a2e99650f069b96f5b18da9ee5f3af513c7bca05e5fa82a2721927fe2bd89266
name: python-antispaminc
arch: src
version: 4.0
epoch: 0
release: 1
summary: A Python Wrapper For Antispam Inc.
url: http://antispaminc.tk
rpm_license: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antispaminc-4.0-1.src.rpm
checksum_type: sha256
description:
  An Python Wrapper For AntispamInc Api.


  * Channel : @AntispamInc
  * Group : @AntispamIncSupport
  * Bot : @AntispamIncBot
  * Website : antispaminc.tk



  ```python
  from antispaminc.connect import Connect
  mytoken = 'your_token_from_@antispamincbot'
  sed = Connect(mytoken)
  sed2 = sed.is_banned('12974624')
  print(sed2.reason)
  ```


  ```sh
  pip install antispaminc
  ```
  or
  ```shell script
  pip3 install antispaminc


pkgId: 8172aa9ad0140be71d94c25d684c5673a1fd4fd476ab085def0cde034c3bab17
name: python-antitesting
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: No more testing
url: https://pypi.org/project/antitesting/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antitesting-0.0.10-1.src.rpm
checksum_type: sha256
description:
  ![logo](https://raw.githubusercontent.com/pomponchik/antitesting/main/docs/assets/logo_2.png)

  [![Downloads](https://static.pepy.tech/badge/antitesting/month)](https://pepy.tech/project/antitesting)
  [![Downloads](https://static.pepy.tech/badge/antitesting)](https://pepy.tech/project/antitesting)
  [![codecov](https://codecov.io/gh/pomponchik/antitesting/graph/badge.svg?token=jHPEZfRrjC)](https://codecov.io/gh/pomponchik/antitesting)
  [![Test-Package](https://github.com/pomponchik/antitesting/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/antitesting/actions/workflows/tests_and_coverage.yml)
  [![Hits-of-Code](https://hitsofcode.com/github/pomponchik/antitesting?branch=main)](https://hitsofcode.com/github/pomponchik/antitesting/view?branch=main)
  [![Python versions](https://img.shields.io/pypi/pyversions/antitesting.svg)](https://pypi.python.org/pypi/antitesting)
  [![PyPI version](https://badge.fury.io/py/antitesting.svg)](https://badge.fury.io/py/antitesting)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)


  There are standard ways to temporarily disable individual tests. As an example, using of the [`pytest.mark.skip`](https://docs.pytest.org/en/latest/how-to/skipping.html#skipping-test-functions) decorator. This plugin adds a new way to do this by extending the standard features of Pytest. Now you can put the names of the disabled tests in a separate file, and then correct and supplement them without going into the source code of the tests.

  Install the plugin:

  ```bash
  pip install antitesting
  ```

  Create one or more files containing the names of the tests that you want to disable. In our example, this will be a file `disabled_tests.txt` containing the text like this:

  ```
  test_1
  test_2 : 12.12.2012
  test_3 : 12.12.2025
  test_4 : 13.12.2025 # fix after test_3
  ```

  Finally, add these lines to the file `conftest.py`:

  ```python
  import antitesting

  antitesting("disabled_tests.txt")
  ```

  The `disabled_tests.txt` file that we created contains the names of the tests that we want to disable. This is equivalent to putting a  [`skip`](https://docs.pytest.org/en/latest/how-to/skipping.html#skipping-test-functions) decorator on each of them, but it does not require getting into the source code of the tests and saves you time. You could also see the dates in the file in the format `DD.MM.YYYY`. If there is a date in this format in the line with the test name, the test will be ignored only until that date, and after that it will become available. If necessary, you can accompany the lines with comments separated by sharps ("#").


pkgId: bbb40c92699a1e33ba27af2a8701f98379e8f3bdae4e80fe6922a60b657a9ddb
name: python-antiword
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Spew anything out as text to stdout
url: https://github.com/2e0byo/antiword
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antiword-0.1.0-1.src.rpm
checksum_type: sha256
description:
  This package is nothing more than a convenience wrapper around `libreoffice
  --convert-to txt` which dumps to stdout, cleaning up the generated temporary
  file as it goes.


  I probably should have written it in bash, but there we go.


pkgId: b1eaaa374705320d1cce0183db82702eabcd1ac2858ba5879d1aa59d81c4a121
name: python-antlib
arch: src
version: 1.1b1
epoch: 0
release: 1
summary: A python wrapper for the ant library
url: http://thisisant.com
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antlib-1.1b1-1.src.rpm
checksum_type: sha256
description:
  Python wrapper for the ANT library to communicate serially with ANT devices. For more information about ANT, see http://thisisant.com/


  Copyright 2019 Garmin Canada, Inc.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.


  Antlib now supports both 32bit/64bit windows. There is a restriction on using 64bit package which does not support
  communications with USB Interface Board (UIF) boards.


pkgId: 3ca6473cd457e670e1008c638ee13a9326086df09a13f3746da7508666c33a99
name: python-antlr-ast
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: AST shaping for antlr parsers
url: https://github.com/datacamp/antlr-ast
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antlr-ast-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/datacamp/antlr-ast.svg?branch=master)](https://travis-ci.org/datacamp/antlr-ast)
  [![codecov](https://codecov.io/gh/datacamp/antlr-ast/branch/master/graph/badge.svg)](https://codecov.io/gh/datacamp/antlr-ast)

  This package allows you to use ANTLR grammars and use the parser output to generate an abstract syntax tree (AST).



  ```bash
  pip install antlr-ast
  ```

  **Note:** this package is not python2 compatible.



  ```bash


  py.test
  ```



  Using `antlr-ast` involves four steps:

  1. Using ANTLR to define a grammar and to generate the necessary Python files to parse this grammar
  2. Using `parse` to get the ANTLR runtime output based on the generated grammar files
  3. Using `process_tree` on the output of the previous step
      1. A `BaseAstVisitor` (customisable by providing a subclass) transforms the ANTLR output to a serializable tree of `BaseNode`s,
         dynamically created based on the rules in the ANTLR grammar
      2. A `BaseNodeTransformer` subclass can be used to transform each kind of node
      3. The simplify option can be used to shorten paths in the tree by skipping nodes that only have a single descendant
  4. Using the resulting tree

  The next sections go into more detail about these steps.

  To visualize the process of creating and transforrming these parse trees, you can use [this ast-viewer](https://github.com/datacamp/ast-viewer).



  **Note: For this part of this tutorial you need to know how to parse code**
  See the ANTLR [getting started guide](https://github.com/antlr/antlr4/blob/4.7.2/doc/getting-started.md) if you have never installed ANTLR.
  The [ANTLR Mega Tutorial](https://tomassetti.me/antlr-mega-tutorial/#python-setup) has useful Python examples.

  [This page explains how to write ANTLR parser rules](https://github.com/antlr/antlr4/blob/master/doc/parser-rules.md).
  The rule definition below is an example with descriptive names for important ANTLR parser grammar elements:

  ```g4
  rule_name: rule_element? rule_element_label='literal'    #RuleAlternativeLabel
           | TOKEN+                                        #RuleAlternativeLabel
           ;
  ```

  Rule element and alternative labels are optional.
  `+`, `*`, `?`, `|` and `()` have the same meaning as in RegEx.

  Below, we'll use a simple grammar to explain how `antlr-ast` works.
  This grammar can be found in `/tests/Expr.g4`.

  ```g4
  grammar Expr;

  // parser

  expr:   left=expr op=('+'|'-') right=expr       #BinaryExpr
      |   NOT expr                                #NotExpr
      |   INT                                     #Integer
      |   '(' expr ')'                            #SubExpr
      ;

  // lexer

  INT :   [0-9]+ ;         // match integers
  NOT :   'not' ;

  WS  :   [ \t]+ -> skip ; // toss out whitespace
  ```

  ANTLR can use the grammar above to generate a parser in a number of languages.
  To generate a Python parser, you can use the following command.

  ```bash
  antlr4 -Dlanguage=Python3 -visitor /tests/Expr.g4
  ```

  This will generate a number of files in the `/tests/` directory, including a Lexer (`ExprLexer.py`),
  a parser (`ExprParser.py`), and a visitor (`ExprVisitor.py`).

  You can use and import these directly in Python. For example, from the root of this repo:

  ```bash
  from tests import ExprVisitor
  ```

  To easily use the generated files, they are put in the `antlr_py` package.
  The `__init__.py` file exports the generated files under an alias that doesn't include the name of the grammar.



  A `BaseNode` subclass has fields for all rule elements and labels for all rule element labels in its corresponding grammar rule.
  Both fields and labels are available as properties on `BaseNode` instances.
  Labels take precedence over fields if the names would collide.

  The name of a `BaseNode` is the name of the corresponding ANTLR grammar rule, but starting with an uppercase character.
  If rule alternative labels are specified for an ANTLR rule, these are used instead of the rule name.



  Typically, there is no 1-to-1 mapping between ANTLR rules and the concepts of a language: the rule hierarchy is more nested.
  Transformations can be used to make the initial tree of BaseNodes based on ANTLR rules more similar to an AST.



  The `BaseNodeTransformer` will walk over the tree from the root node to the leaf nodes.
  When visiting a node, it is possible to transform it.
  The tree is updated with transformed node before continuing the walk over the tree.

  To define a node transform, add a static method to the `BaseNodeTransformer` subclass passed to `process_tree`.

  - The name of the method you should define follows this pattern: `visit_<BaseNode>`,
    where `<BaseNode>` should be replaced by the name of the `BaseNode` subclass to transform.
  - The method should return the transformed node.

  This is a simple example:

  ```python
  class Transformer(BaseNodeTransformer):
      @staticmethod
      def visit_My_antlr_rule(node):
          return node.name_of_part
  ```



  A custom node can represent a part of the parsed language, a type of node present in an AST.

  To make it easy to return a custom node, you can define `AliasNode` subclasses.
  Normally, fields of `AliasNode`s are like symlinks to navigate the tree of `BaseNode`s.

  Instances of custom nodes are created from a `BaseNode`.
  Fields and labels of the source `BaseNode` are also available on the `AliasNode`.
  If an `AliasNode` field name collides with these, it takes precedence when accessing that property.

  This is what a custom node looks like:

  ```python
  class NotExpr(AliasNode):
      _fields_spec = ["expr", "op=NOT"]
  ```

  This code defines a custom node, `NotExpr` with an `expr` and an `op` field.



  The `_fields_spec` class property is a list that defines the fields the custom node should have.

  This is how a field spec in this list is used when creating an custom node from a `BaseNode` (the source node):

  - If a field spec does not exist on the source node, it is set to `None`
  - If multiple field specs define the same field, the first one that isn't `None` is used
  - If a field spec is just a name, it is copied from the source node
  - If a field spec is an assignment, the left side is the name of the field on the `AliasNode`
    and the right side is the path that should be taken starting in the source node to get the node
    that should be the value for the field on the custom node.
    Parts of this path are separated using `.`



  To use this custom node, add a method to the transformer:

  ```python
  class Transformer(BaseNodeTransformer):
      

      
      
      @staticmethod
      def visit_NotExpr(node):
          return NotExpr.from_spec(node)
  ```

  Instead of defining methods on the transformer class to use custom nodes, it's possible to do this automatically:

  ```python
  Transformer.bind_alias_nodes(alias_nodes)
  ```

  To make this work, the `AliasNode` classes in the list should have a `_rules` class property
  with a list of the `BaseNode` names it should transform.

  This is the result:

  ```python
  class NotExpr(AliasNode):
      _fields_spec = ["expr", "op=NOT"]
      _rules = ["NotExpr"]

  class Transformer(BaseNodeTransformer):
      pass

  alias_nodes = [NotExpr]
  Transformer.bind_alias_nodes(alias_nodes)
  ```

  An item in `_rules` can also be a tuple.
  In that case, the first item in the tuple is a `BaseNode` name
  and the second item is the name of a class method of the custom node.

  It's not useful in the example above, but it is equivalent to this:

  ```python
  class NotExpr(AliasNode):
      _fields_spec = ["expr", "op=NOT"]
      _rules = [("NotExpr", "from_not")]

      @classmethod
      def from_not(cls, node):
          return cls.from_spec(node)

  class Transformer(BaseNodeTransformer):
      pass

  alias_nodes = [NotExpr]
  Transformer.bind_alias_nodes(alias_nodes)
  ```



  It's easy to use a tree that has a mix of `AliasNode`s and dynamic `BaseNode`s:
  the whole tree is just a nested Python object.

  When searching nodes in a tree, the priority of nodes can be taken into account.
  By default, `BaseNode`s have priority 3 and `AliasNode`s have priority 2.

  When writing code to work with trees, it can be affected by changes in the grammar, the transforms and the custom nodes.
  The grammar is the most likely to change.

  To make grammar updates have no impact on your code, don't rely on `BaseNode`s.
  You can still check whether the `AliasNode` parent node of a `BaseNode` has the correct fields set
  and search for nested `AliasNode`s in a subtree.

  If you do rely on `BaseNode`s, code could break by the addition of `AliasNode`s that replace some of these
  if a field name collides with a field name on a used `BaseNode`.


pkgId: a99e405eaf727d58be5711c5b98104236bb599106a9a31d4e7dd82402dea5142
name: python-antlr-tsql
arch: src
version: 0.12.6
epoch: 0
release: 1
summary: A transact sql parser, written in Antlr4
url: https://github.com/datacamp/antlr-tsql
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antlr-tsql-0.12.6-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/datacamp/antlr-tsql.svg?branch=master)](https://travis-ci.org/datacamp/antlr-tsql)
  [![PyPI version](https://badge.fury.io/py/antlr-tsql.svg)](https://badge.fury.io/py/antlr-tsql)



  ANTLR requires Java, so we suggest you use Docker when building grammars. The `Makefile` contains directives to clean, build, test and deploy the ANTLR grammar. It does not run Docker itself, so run `make` inside Docker.



  ```bash

  docker build -t antlr_tsql .



  docker run -it -v ${PWD}:/usr/src/app antlr_tsql make build
  ```



  Now that the Python parsing files are available, you can install them with `pip`:

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

  And parse SQL code in Python:

  ```python
  from antlr_tsql import ast
  ast.parse("SELECT a from b")
  ```



  If you're actively developing on the ANLTR grammar or the tree shaping, it's a good idea to set up the [AST viewer](https://github.com/datacamp/ast-viewer) locally so you can immediately see the impact of your changes in a visual way.

  - Clone the ast-viewer repo and build the Docker image according to the instructions.
  - Spin up a docker container that volume mounts the Python package, symlink-installs the package and runs the server on port 3000:

  ```bash
  docker run -it \
    -u root \
    -v ~/workspace/antlr-tsql:/app/app/antlr-tsql \
    -p 3000:3000 \
    ast-viewer \
    /bin/bash -c "echo 'Install development requirements in development:' \
      && pip install --no-deps -e app/antlr-tsql \
      && python3 run.py"
  ```

  When simultaneously developing other packages, volume mount and install those too:

  ```bash
  docker run -it \
    -u root \
    -v ~/workspace/antlr-ast:/app/app/antlr-ast \
    -v ~/workspace/antlr-plsql:/app/app/antlr-plsql \
    -v ~/workspace/antlr-tsql:/app/app/antlr-tsql \
    -p 3000:3000 \
    ast-viewer \
    /bin/bash -c "echo 'Install development requirements in development:' \
      && pip install --no-deps -e app/antlr-ast \
      && pip install --no-deps -e app/antlr-plsql \
      && pip install --no-deps -e app/antlr-tsql \
      && python3 run.py"
  ```

  - If you update the tree shaping logic in this repo, the app will auto-update.
  - If you change the grammar, you will have to first rebuild the grammar (with the `antlr_tsql` docker image) and restart the `ast-viewer` container.



  ```bash


  docker build -t antlr_tsql .
  docker run -t antlr_tsql make build test
  ```

  Or run the test locally, first build the grammar then run:

  ```python
  pytest
  ```



  - Builds the Docker image.
  - Runs the Docker image to build the grammar and run the unit tests.
  - Deploys the resulting python files to PyPi when a new release is made, so they can be installed easily.


pkgId: a4acef491d2f8814bbe6f0238e3c3c7ac038b856db2d7ba68feb62cf8f9b2813
name: python-antlr4-vba
arch: src
version: 0.0.62
epoch: 0
release: 1
summary: VBA targeted antlr4 parsing classes.
url: https://github.com/Beakerboy/antlr4-vba/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antlr4-vba-0.0.62-1.src.rpm
checksum_type: sha256
description:
  antlr4-vba is a package of the Lexer and Parser created by antlr with the command `antlr4 -Dlanguage=Python3 -listener -visitor vba.g4`. The project also includes the empty listener and visitor classes, which are largely useless on their own, but good as reference.
  Similarly, there are grammar, lexer, and parser files which implement the conditional compilation process of VBA.


  The project can be installed with `python -m pip install antlr4-vba`


  The project also includes typed stubs for mypy. These stubs are autogenerated by stubgen, so they may be incomplete. Please let me know if they do not meet your needs and I can manage them manually.


pkgId: 21671a097392183bce5cae344f64c596c6cb7e0132f7a942aceeefb98f606474
name: python-antm
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Aligned Neural Topic Model for Exploring Evolving Topics
url: https://github.com/hamedR96/ANTM
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antm-0.1.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - PyPi](https://img.shields.io/pypi/v/antm)](https://pypi.org/project/antm/)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://hamedrahimi.fr)
  [![arXiv](https://img.shields.io/badge/arXiv-2302.01501-<COLOR>.svg)](https://arxiv.org/abs/2302.01501)


  ANTM: An Aligned Neural Topic Model for Exploring Evolving Topics

  ![alt text](https://github.com/hamedR96/ANTM/blob/main/diagram_Twitter.png?raw=true)

   Dynamic topic models are effective methods that primarily focus on studying the evolution of topics present in a collection of documents. These models are widely used for understanding trends, exploring public opinion in social networks, or tracking research progress and discoveries in scientific archives. Since topics are defined as clusters of semantically similar documents, it is necessary to observe the changes in the content or themes of these clusters in order to understand how topics evolve as new knowledge is discovered over time. Here, we introduce a dynamic neural topic model called ANTM, which uses document embeddings (data2vec) to compute clusters of semantically similar documents at different periods, and aligns document clusters to represent their evolution. This alignment procedure preserves the temporal similarity of document clusters over time and captures the semantic change of words characterized by their context within different periods. Experiments on four different datasets show that ANTM outperforms probabilistic dynamic topic models (e.g. DTM, DETM) and significantly improves topic coherence and diversity over other existing dynamic neural topic models (e.g. BERTopic).




  Installation can be done using:

  ```bash
  pip install antm
  ```


  As implemented in the notebook, we can quickly start extracting evolving topics from DBLP dataset containing computer science articles.


  ```python
  from antm import ANTM
  import pandas as pd


  df=pd.read_parquet("./data/dblpFullSchema_2000_2020_extract_big_data_2K.parquet")
  df=df[["abstract","year"]].rename(columns={"abstract":"content","year":"time"})
  df=df.dropna().sort_values("time").reset_index(drop=True).reset_index()


  window_size = 6
  overlap = 2


  model=ANTM(df,overlap,window_size,umap_n_neighbors=10, partioned_clusttering_size=5,mode="data2vec",num_words=10,path="./saved_data")


  topics_per_period=model.fit(save=True)

  ```


  ```python
  from antm import ANTM
  import pandas as pd


  df=pd.read_parquet("./data/dblpFullSchema_2000_2020_extract_big_data_2K.parquet")
  df=df[["abstract","year"]].rename(columns={"abstract":"content","year":"time"})
  df=df.dropna().sort_values("time").reset_index(drop=True).reset_index()


  window_size = 6
  overlap = 2

  model=ANTM(df,overlap,window_size,mode="data2vec",num_words=10,path="./saved_data")
  topics_per_period=model.load()
  ```

  ```python

  model.save_evolution_topics_plots(display=False)


  model.random_evolution_topic()


  model.plot_clusters_over_time()


  model.plot_evolving_topics()
  ```

  ```python

  model.get_periodwise_pairwise_jaccard_diversity()


  model.get_periodwise_puw_diversity()


  model.get_periodwise_topic_coherence(model="c_v")

  ```

  [Arxiv articles](https://www.kaggle.com/datasets/Cornell-University/arxiv)

  [DBLP articles](https://nuage.lip6.fr/s/FLKwdzcsbqYMkat)

  [Elon Musk's Tweets](https://nuage.lip6.fr/s/XKkcWLAiDiykZ4D)

  [New York Times News](https://nuage.lip6.fr/s/XKkcWLAiDiykZ4D)


  You can use the notebooks provided in "./experiments" in order to run ANTM on other sequential datasets.



  To cite [ANTM](https://arxiv.org/abs/2302.01501), please use the following bibtex reference:
  ```bibtext
  @misc{rahimi2023antm,
        title={ANTM: An Aligned Neural Topic Model for Exploring Evolving Topics},
        author={Hamed Rahimi and Hubert Naacke and Camelia Constantin and Bernd Amann},
        year={2023},
        eprint={2302.01501},
        archivePrefix={arXiv},
        primaryClass={cs.IR}
  }
  ```


pkgId: 418607c1251f5819cbb637ca00a8e6f8ba51e801fc8d038baa1d2b08eff480ec
name: python-ants
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: A human spider framework base on django
url: https://github.com/mymusise/ants
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ants-0.0.7-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://travis-ci.org/mymusise/Ants.svg?branch=master)
  Ants is a clawer framework for perfectionism base on Django， which help people build a clawer faster and easier to make manage.


pkgId: 035e74d237d653f6c3cb46bf3ad46b9473db3b669b46935d13d90df7e3ccabf3
name: python-antsibull
arch: src
version: 0.67.0
epoch: 0
release: 1
summary: The antsibull project has been renamed to antsibull-build
url: https://pypi.org/project/antsibull/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-0.67.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) Ansible Project
  GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
  SPDX-License-Identifier: GPL-3.0-or-later
  -->



  The `antsibull` project has been renamed to `antsibull-build`.
  This is an empty stub package for backwards compatibility.
  The new PyPI project is located at <https://pypi.org/project/antsibull-build>.


pkgId: 23e2123530a745119acef1e6b97916775303390f96f40c9f452576aa70a0c867
name: python-antsibull-build
arch: src
version: 0.69.0
epoch: 0
release: 1
summary: Tools for building the Ansible Distribution
url: https://pypi.org/project/antsibull-build/
rpm_license: GPL-3.0-or-later AND Python-2.0.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-build-0.69.0-1.src.rpm
checksum_type: sha256
description:
  antsibull-build depends on the sister antsibull-core, antsibull-changelog,
  antsibull-docs-parser, antsibull-docutils, and antsibull-fileutils projects.
  By default, `nox` will install development versions of these projects from
  Github.
  If you're hacking on antsibull-core, antsibull-changelog, antsibull-docs-parser,
  antsibull-docutils and/or antsibull-fileutils alongside antsibull-build,
  nox will automatically install the projects from `../antsibull-core`,
  `../antsibull-changelog`, `../antsibull-docs-parser`, `../antsibull-docutils`,
  and `../antsibull-fileutils` when running tests if those paths exist.
  You can change this behavior through the `OTHER_ANTSIBULL_MODE` env var:
  - `OTHER_ANTSIBULL_MODE=auto` — the default behavior described above
  - `OTHER_ANTSIBULL_MODE=local` — install the projects from `../antsibull-core`,
    `../antsibull-changelog`, `../antsibull-docs-parser`, `../antsibull-docutils`,
    and `../antsibull-fileutils`.
    Fail if those paths don't exist.
  - `OTHER_ANTSIBULL_MODE=git` — install the projects from the Github main branch


pkgId: fa0e3e643bb3bca944570c1f7fe349b21bc16cfb1415ed34870765bb2d7899f2
name: python-antsibull-changelog
arch: src
version: 0.30.0
epoch: 0
release: 1
summary: Changelog tool for Ansible-core and Ansible collections
url: https://pypi.org/project/antsibull-changelog/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-changelog-0.30.0-1.src.rpm
checksum_type: sha256
description:
  antsibull-changelog depends on the sister antsibull-docutils and antsibull-fileutils projects.
  By default, `nox` will install a development version of these projects from Github.
  If you're hacking on antsibull-docutils and/or antsibull-fileutils alongside antsibull-changelog,
  nox will automatically install these projects from  `../antsibull-docutils` and `../antsibull-fileutils`
  when running tests if those paths exist.
  You can change this behavior through the `OTHER_ANTSIBULL_MODE` env var:
  - `OTHER_ANTSIBULL_MODE=auto` — the default behavior described above
  - `OTHER_ANTSIBULL_MODE=local` — install the projects from `../antsibull-docutils`
    and `../antsibull-fileutils`.
    Fail if those paths don't exist.
  - `OTHER_ANTSIBULL_MODE=git` — install the projects from the Github main branch


pkgId: 45171b46d7963eb31a28d7a8b6fc30affd57795b183d63c1a1db6f514fe42585
name: python-antsibull-core
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Tools for building the Ansible Distribution
url: https://pypi.org/project/antsibull-core/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-core-3.3.0-1.src.rpm
checksum_type: sha256
description:
  antsibull-core depends on the sister antsibull-fileutils project.
  By default, `nox` will install a development version of this project from Github.
  If you're hacking on antsibull-fileutils alongside antsibull-core,
  nox will automatically install this project from `../antsibull-fileutils`
  when running tests if this path exists.
  You can change this behavior through the `OTHER_ANTSIBULL_MODE` env var:
  - `OTHER_ANTSIBULL_MODE=auto` — the default behavior described above
  - `OTHER_ANTSIBULL_MODE=local` — install the project from `../antsibull-fileutils`.
    Fail if this path doesn't exist.
  - `OTHER_ANTSIBULL_MODE=git` — install the project from the Github main branch


pkgId: 502103a60b10b1f2a9100ff30e4daa27015b574bf612c5f134afd37a07fe4f47
name: python-antsibull-docs
arch: src
version: 2.15.0
epoch: 0
release: 1
summary: Tools for building Ansible documentation
url: https://pypi.org/project/antsibull-docs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-docs-2.15.0-1.src.rpm
checksum_type: sha256
description:
  antsibull-docs depends on the sister antsibull-changelog, antsibull-core,
  antsibull-docs-parser, antsibull-docutils, and antsibull-fileutils projects.
  By default, `nox` will install a development version of these projects from Github.
  If you're hacking on antsibull-changelog, antsibull-core, antsibull-docs-parser,
  antsibull-docutils, and/or antsibull-fileutils alongside antsibull-docs,
  nox will automatically install the projects from  `../antsibull-changelog`,
  `../antsibull-core`, `../antsibull-docs-parser`, `../antsibull-docutils`,
  and `../antsibull-fileutils` when running tests if those paths exist.
  You can change this behavior through the `OTHER_ANTSIBULL_MODE` env var:
  - `OTHER_ANTSIBULL_MODE=auto` — the default behavior described above
  - `OTHER_ANTSIBULL_MODE=local` — install the projects from `../antsibull-changelog`,
    `../antsibull-core`, `../antsibull-docs-parser`, `../antsibull-docutils`, and
    `../antsibull-fileutils`.
    Fail if those paths don't exist.
  - `OTHER_ANTSIBULL_MODE=git` — install the projects from the Github main branch


pkgId: 4855a2db2f1df931e1626c03105f489a8aa2d5f9094b6f525a44a476a7776b07
name: python-antsibull-docs-parser
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Python library for processing Ansible documentation markup
url: https://pypi.org/project/antsibull-docs-parser/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-docs-parser-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) Ansible Project
  GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
  SPDX-License-Identifier: GPL-3.0-or-later
  SPDX-FileCopyrightText: 2023, Ansible Project
  -->


  [![Discuss on Matrix at #antsibull:ansible.com](https://img.shields.io/matrix/antsibull:ansible.com.svg?server_fqdn=ansible-accounts.ems.host&label=Discuss%20on%20Matrix%20at%20%23antsibull:ansible.com&logo=matrix)](https://matrix.to/#/#antsibull:ansible.com)
  [![Nox badge](https://github.com/ansible-community/antsibull-docs-parser/actions/workflows/nox.yml/badge.svg)](https://github.com/ansible-community/antsibull-docs-parser/actions/workflows/nox.yml)
  [![Codecov badge](https://img.shields.io/codecov/c/github/ansible-community/antsibull-docs-parser)](https://codecov.io/gh/ansible-community/antsibull-docs-parser)
  [![REUSE status](https://api.reuse.software/badge/github.com/ansible-community/antsibull-docs-parser)](https://api.reuse.software/info/github.com/ansible-community/antsibull-docs-parser)

  This is a Python library for processing Ansible documentation markup. It is named after [antsibull-docs](https://github.com/ansible-community/antsibull-docs/) where this code originates from. It was moved out to make it easier to reuse the markup code in other projects without having to depend on all of antsibull-docs's dependencies.



  Install and run `nox` to run all tests. `nox` will create virtual environments in `.nox` inside the checked out project and install the requirements needed to run the tests there.

  To run specific tests:
  1. `nox -e test` to only run unit tests;
  2. `nox -e lint` to run all linters and formatters at once;
  3. `nox -e formatters` to run `isort` and `black`;
  4. `nox -e codeqa` to run `flake8`, `pylint`, `reuse lint`, and `antsibull-changelog lint`;
  5. `nox -e typing` to run `mypy` and `pyre`;
  6. `nox -e create_vectors` to update the `test-vectors.yml` file. Please note that this file should be synchronized with the corresponding file in [the antsibull-docs-ts project](https://github.com/ansible-community/antsibull-docs-ts).



  1. Run `nox -e bump -- <version> <release_summary_message>`. This:
     * Bumps the package version in `src/antsibull_docs_parser/__init__.py`.
     * Creates `changelogs/fragments/<version>.yml` with a `release_summary` section.
     * Runs `antsibull-changelog release` and adds the changed files to git.
     * Commits with message `Release <version>.` and runs `git tag -a -m 'antsibull-docs-parser <version>' <version>`.
     * Runs `hatch build --clean`.
  2. Run `git push` to the appropriate remotes.
  3. Once CI passes on GitHub, run `nox -e publish`. This:
     * Runs `hatch publish`;
     * Bumps the version to `<version>.post0`;
     * Adds the changed file to git and run `git commit -m 'Post-release version bump.'`;
  4. Run `git push --follow-tags` to the appropriate remotes and create a GitHub release.


pkgId: 65aae74ab5d53744b190f1e2660b18708446dcf0ae7f9274cbaa2a1ba472d7f6
name: python-antsibull-docutils
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Antsibull docutils helpers
url: https://pypi.org/project/antsibull-docutils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-docutils-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) Ansible Project
  GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
  SPDX-License-Identifier: GPL-3.0-or-later
  -->


  [![Discuss on Matrix at #antsibull:ansible.com](https://img.shields.io/matrix/antsibull:ansible.com.svg?server_fqdn=ansible-accounts.ems.host&label=Discuss%20on%20Matrix%20at%20%23antsibull:ansible.com&logo=matrix)](https://matrix.to/#/#antsibull:ansible.com)
  [![Nox badge](https://github.com/ansible-community/antsibull-docutils/workflows/nox/badge.svg?event=push&branch=main)](https://github.com/ansible-community/antsibull-docutils/actions?query=workflow%3A%22nox%22+branch%3Amain)
  [![Codecov badge](https://img.shields.io/codecov/c/github/ansible-community/antsibull-docutils)](https://codecov.io/gh/ansible-community/antsibull-docutils)
  [![REUSE status](https://api.reuse.software/badge/github.com/ansible-community/antsibull-docutils)](https://api.reuse.software/info/github.com/ansible-community/antsibull-docutils)

  A Python library with some [docutils](https://www.docutils.org/) helpers used by Antsibull tools.

  antsibull-docutils is covered by the [Ansible Code of Conduct](https://docs.ansible.com/ansible/latest/community/code_of_conduct.html).



  Install and run `nox` to run all tests. That's it for simple contributions!
  `nox` will create virtual environments in `.nox` inside the checked out project
  and install the requirements needed to run the tests there.

  To run specific tests:

  1. `nox -e test` to only run unit tests;
  2. `nox -e coverage` to display combined coverage results after running `nox -e
     test integration`;
  3. `nox -e lint` to run all linters and formatters at once;
  4. `nox -e formatters` to run `isort` and `black`;
  5. `nox -e codeqa` to run `flake8`, `pylint`, `reuse lint`, and `antsibull-changelog lint`;
  6. `nox -e typing` to run `mypy`.



  1. Run `nox -e bump -- <version> <release_summary_message>`. This:
     * Bumps the package version in `src/antsibull_docutils/__init__.py`.
     * Creates `changelogs/fragments/<version>.yml` with a `release_summary` section.
     * Runs `antsibull-changelog release` and adds the changed files to git.
     * Commits with message `Release <version>.` and runs `git tag -a -m 'antsibull-docutils <version>' <version>`.
     * Runs `hatch build --clean`.
  2. Run `git push` to the appropriate remotes.
  3. Once CI passes on GitHub, run `nox -e publish`. This:
     * Runs `hatch publish`;
     * Bumps the version to `<version>.post0`;
     * Adds the changed file to git and run `git commit -m 'Post-release version bump.'`;
  4. Run `git push --follow-tags` to the appropriate remotes and create a GitHub release.



  Unless otherwise noted in the code, it is licensed under the terms of the GNU
  General Public License v3 or, at your option, later. See
  [LICENSES/GPL-3.0-or-later.txt](https://github.com/ansible-community/antsibull-docutils/tree/main/LICENSE)
  for a copy of the license.

  The repository follows the [REUSE Specification](https://reuse.software/spec/) for declaring copyright and
  licensing information. The only exception are changelog fragments in ``changelog/fragments/``.


pkgId: 411e3f687e2c9e808a58b651c5f88643b40fcd693f255a0d365ab4abccd89b5f
name: python-antsibull-fileutils
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Tools for building the Ansible Distribution
url: https://pypi.org/project/antsibull-fileutils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antsibull-fileutils-1.0.1-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) Ansible Project
  GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
  SPDX-License-Identifier: GPL-3.0-or-later
  -->


  [![Discuss on Matrix at #antsibull:ansible.com](https://img.shields.io/matrix/antsibull:ansible.com.svg?server_fqdn=ansible-accounts.ems.host&label=Discuss%20on%20Matrix%20at%20%23antsibull:ansible.com&logo=matrix)](https://matrix.to/#/#antsibull:ansible.com)
  [![Nox badge](https://github.com/ansible-community/antsibull-fileutils/actions/workflows/nox.yml/badge.svg)](https://github.com/ansible-community/antsibull-fileutils/actions/workflows/nox.yml)
  [![Codecov badge](https://img.shields.io/codecov/c/github/ansible-community/antsibull-fileutils)](https://codecov.io/gh/ansible-community/antsibull-fileutils)
  [![REUSE status](https://api.reuse.software/badge/github.com/ansible-community/antsibull-fileutils)](https://api.reuse.software/info/github.com/ansible-community/antsibull-fileutils)

  This library provides file utils needed by community Ansible tooling.

  You can find a list of changes in [the antsibull-fileutils changelog](./CHANGELOG.rst).

  Unless otherwise noted in the code, it is licensed under the terms of the GNU
  General Public License v3 or, at your option, later.

  antsibull-fileutils is covered by the [Ansible Code of Conduct](https://docs.ansible.com/ansible/latest/community/code_of_conduct.html).



  From version 1.0.0 on, antsibull-fileutils sticks to semantic versioning and aims at providing no backwards compatibility breaking changes during a major release cycle. We might make exceptions from this in case of security fixes for vulnerabilities that are severe enough.

  The current development version is 1.x.y. 1.x.y is developed on the `main` branch.



  Install and run `nox` to run all tests. That's it for simple contributions!
  `nox` will create virtual environments in `.nox` inside the checked out project
  and install the requirements needed to run the tests there.

  To run specific tests:

  1. `nox -e test` to only run unit tests;
  2. `nox -e coverage` to display combined coverage results after running `nox -e
     test`;
  3. `nox -e lint` to run all linters and formatters at once;
  4. `nox -e formatters` to run `isort` and `black`;
  3. `nox -e codeqa` to run `flake8`, `pylint`, `reuse lint`, and `antsibull-changelog lint`;
  6. `nox -e typing` to run `mypy` and `pyre`



  1. Run `nox -e bump -- <version> <release_summary_message>`. This:
     * Bumps the package version in `src/antsibull_fileutils/__init__.py`.
     * Creates `changelogs/fragments/<version>.yml` with a `release_summary` section.
     * Runs `antsibull-changelog release` and adds the changed files to git.
     * Commits with message `Release <version>.` and runs `git tag -a -m 'antsibull-fileutils <version>' <version>`.
     * Runs `hatch build`.
  2. Run `git push` to the appropriate remotes.
  3. Once CI passes on GitHub, run `nox -e publish`. This:
     * Runs `hatch publish`;
     * Bumps the version to `<version>.post0`;
     * Adds the changed file to git and run `git commit -m 'Post-release version bump.'`;
  4. Run `git push --follow-tags` to the appropriate remotes and create a GitHub release.



  Unless otherwise noted in the code, it is licensed under the terms of the GNU
  General Public License v3 or, at your option, later. See
  [LICENSES/GPL-3.0-or-later.txt](https://github.com/ansible-community/antsibull-fileutils/tree/main/LICENSE)
  for a copy of the license.

  The repository follows the [REUSE Specification](https://reuse.software/spec/) for declaring copyright and
  licensing information. The only exception are changelog fragments in ``changelog/fragments/``.


pkgId: 8729585535aaae357630aa3f035ba2e620b517bd51ed4cbd2334157c9a8c9e06
name: python-antspymm
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: multi-channel/time-series medical image processing with antspyx
url: https://pypi.org/project/antspymm/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antspymm-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/ANTsX/ANTsPyMM/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/ANTsX/ANTsPyMM/tree/main)

  ![mapping](https://i.imgur.com/qKqYjU9.jpeg)



  the outputs of these processes can be used for data inspection/cleaning/triage
  as well for interrogating hypotheses.

  this package also keeps track of the latest preferred algorithm variations for
  production environments.

  install the `dev` version by calling (within the source directory):

  ```
  python3 -m  build .
  ```

  or install the latest release via

  ```
  pip install antspymm
  ```



  ANTsPyMM will process several types of brain MRI into tabular form as well as normalized (standard template) space.  The processing includes:

  * T1wHier uses hierarchical processing from ANTsPyT1w organized around these measurements

      * CIT168 template 10.1101/211201

      * Desikan Killiany Tourville (DKT) 10.3389/fnins.2012.00171

      * basal forebrain (Avants et al HBM 2022 abstract)

      * other regions (eg MTL) 10.1101/2023.01.17.23284693

      * also produces jacobian data

  * rsfMRI: resting state functional MRI

      * uses [a recent homotopic parcellation](https://pubmed.ncbi.nlm.nih.gov/36918136/) to estimate network specific correlations

      * f/ALFF 10.1016/j.jneumeth.2008.04.012

      * [percent absolute fluctuation](https://www.frontiersin.org/journals/neuroscience/articles/10.3389/fnins.2022.888174/full)

  * NM2DMT: neuromelanin mid-brain images

      * CIT168 template 10.1101/211201

  * DTI: DWI diffusion weighted images organized via:

      * CIT168 template 10.1101/211201

      * JHU atlases 10.1016/j.neuroimage.2008.07.009  10.1016/j.neuroimage.2007.07.053

      * DKT for cortical to cortical tractography estimates based on DiPy

  * T2Flair: flair for white matter hyperintensity

      * https://pubmed.ncbi.nlm.nih.gov/30908194/

      * https://pubmed.ncbi.nlm.nih.gov/30125711/

      * https://pubmed.ncbi.nlm.nih.gov/35088930/

  * T1w: voxel-based cortical thickness (DiReCT) 10.1016/j.neuroimage.2008.12.016

  Results of these processes are plentiful; processing for a single subject
  will all modalities will take around 2 hours on an average laptop.

  * documentation of functions [here](http://htmlpreview.github.io/?https://github.com/stnava/ANTsPyMM/blob/main/docs/antspymm/mm.html).

  * data dictionary [here](http://htmlpreview.github.io/?https://github.com/stnava/ANTsPyMM/blob/main/docs/make_dict_table.html).

  * notes on QC [here](http://htmlpreview.github.io/?https://github.com/stnava/ANTsPyMM/blob/main/docs/blind_qc.html)


  achieved through four steps (recommended approach):

  1. organize data in NRG format

  2. perform blind QC

  3. compute outlierness per modality and select optimally matched modalities ( steps 3.1 and 3.2 )

  4. run the main antspymm function



  <details>
  <summary>Overview</summary>

  The Advanced Normalization Tools Ecosystem (ANTsX) is a collection of interrelated, open-source software libraries for biological and medical image processing [1](https://pubmed.ncbi.nlm.nih.gov/33907199/) and analysis built on the NIH’s Insight Toolkit (ITK).  ANTsX has demonstrated significant applicability for a variety of organ systems, species, and imaging modalities [2](https://pubmed.ncbi.nlm.nih.gov/25977810/) [3](https://pubmed.ncbi.nlm.nih.gov/38746199/) [4](https://pubmed.ncbi.nlm.nih.gov/35703369/).  ANTsX-based processing of multi-modality studies utilizes the Python-based ANTsPyMM library.  This includes structural (T1-w, DTI, FLAIR), functional (fMRI), and perfusion (ASL) modalities.

  </details>

  <details>
  <summary>T1-weighted MRI</summary>

  T1-weighted MRI processing has been previously described [1](https://pubmed.ncbi.nlm.nih.gov/33907199/) [2](https://pubmed.ncbi.nlm.nih.gov/38632390/).  It is coordinated by ANTsPyT1w, a sub-component of ANTsPyMM, and includes tools for image registration, segmentation, and super-resolution as customized for the human brain. Processing components include preprocessing (denoising + bias correction), brain extraction, sis-tissue parenchymal parcellation (CSF, gray matter, white matter, deep gray matter, brain stem, and cerebellum), and cortical parcellation for morphological quantitation.  Derived measurements are tabulated by the neuroanatomical coordinates defined above and include cortical and subcortical measurements and morphological measurements of the hippocampus, basal forebrain and cerebellum.

  </details>

  <details>
  <summary>Diffusion</summary>

  Diffusion processing.  ANTsPyMM couples the ANTsX toolkit with the Diffusion Imaging in Python (Dipy) library for the processing and analysis of diffusion MRI [1](https://pubmed.ncbi.nlm.nih.gov/24600385/).   The former is used for motion correction and normalization to corresponding T1-w images.  Output consists of QC images, the motion corrected diffusion series, RGB images, FA, mean diffusion and dense tractography as well as tractography-based connectivity matrices.  Tabular summary of these metrics are written to csv.

  </details>

  <details>
  <summary>Resting-state fMRI</summary>

  Several preprocessing steps are included in the ANTsPyMM processing of resting state fMRI (rsfMRI) data.  First, motion correction is used to align the time series to a series specific fMRI template.  Distortion correction to t1 is also performed along with brain extraction.  A homotopic coordinate system is transformed to the time series space and used to derive network correlation matrices.  CompCor is used to model physiological noise [1](https://pubmed.ncbi.nlm.nih.gov/17560126/).  Censoring is performed for problematic volumes.  By default, three different sets of processing parameters are employed.  These were chosen based on an empirical evaluation of reproducibility in a traveling participant cohort.  Several QC measurements are derived and all of these data are summarized in a tabular format.

  </details>

  <details>
  <summary>ASL</summary>

  ASL processing.  Cerebral blood flow (CBF) is a critical parameter in understanding brain function and its alterations in various neurological conditions. Arterial spin labeling (ASL) MRI is a non-invasive technique that can measure CBF without the need for contrast agents. ANTsPyMM estimates CBF from ASL MRI data through a combination of image processing and mathematical modeling techniques [1](https://pubmed.ncbi.nlm.nih.gov/24715426/).  First, motion artifacts and outliers are removed from the time series data.  Second, the preprocessed data is registered to the reference T1-w space using a rigid transformation optimized through the ANTs registration tools [2](https://pubmed.ncbi.nlm.nih.gov/24817849/).  Third, the six-tissue segmentation generated during the T1-w segmentation is used to partition the registered ASL data from which the CBF is estimated using a mathematical model that takes into account the ASL MRI signal, the labeling efficiency, and the longitudinal relaxation time of blood.  Finally, the M0 image, which represents the equilibrium magnetization of brain tissue, is estimated using a separate mathematical model.

  </details>

  <details>
  <summary>Magnetic resonance angiography</summary>

  MRA processing and analysis.   A precursor for quantitative measures of potential vascular irregularities is the segmentation derived from MR angiography.  To extract these image-based quantitative measures (described below), we developed and trained a deep learning network as part of the ANTsXNet functional library.  Training data was adapted from a publicly available resource [1](https://data.kitware.com/#item/58a372e48d777f0721a64dc9) consisting of 42 subjects with vascular network segmentations and brain masks provided.  A previously constructed high-resolution template was generated from the Human Connectome Project Young Adult cohort comprising T1-w, T2-w, and FA modalities using ANTs functionality [2](https://pubmed.ncbi.nlm.nih.gov/19818860/) [3](https://pubmed.ncbi.nlm.nih.gov/25433513/) and served as the prediction space for network training.  Prior spatial information was included by warping all vascular segmentations to the template space, averaged, spatially smoothed, and renormalized to the intensity range [0,1].  Aggressive data augmentation was used to generate additional data in real time during training consisting of random spatial linear and deformable transformations, random Gaussian additive noise, random histogram-based intensity warping [4](https://pubmed.ncbi.nlm.nih.gov/34227163/), and simulated bias field based on the popular N4 algorithm [5](https://pubmed.ncbi.nlm.nih.gov/20378467/). The functionality is available as open-source in both the R-based ANTsRNet (``brainMraVesselSegmentation(...)``) and Python-based ANTsPyNet (``brain_mra_vessel_segmentation(...)``).

  </details>

  <details>
  <summary>Periventricular spaces and white matter hyperintensities</summary>

  Traditional measures for indicating abnormal vascular morphology can then be calculated, such as tortuosity [1](https://pubmed.ncbi.nlm.nih.gov/12956271/).  For example, tight vascular coils (i.e., high tortuosity) are often associated with the presence of malignant tumors.  From the centerline of the vessel segmentation, various tortuosity measures have been proposed including 1) distance metric: the ratio of the length of the centerline to the distance between the two endpoints, 2) inflection count metric: the distance metric multiplied by the number of the inflection points (i.e., a point of minimum total curvature), 3) sum of angles metric: the integrated total curvature normalized by total path length.

  For quantitative assessment of enlarged perivascular spaces, we employ functionality made publicly available through the ANTsX toolkit.  Specifically, previous published research [2](https://pubmed.ncbi.nlm.nih.gov/34262443/) has been ported to the ANTsXNet library and will be used for segmenting enlarged perivascular spaces.  Using both T1 and FLAIR modalities, a trained deep learning U-net neural network was trained using 40 datasets in which all visible perivascular spaces were manually annotated by an expert.  An ensemble of trained weights is used to produce the final probability image.  Previous work in MRI super resolution [3](https://www.medrxiv.org/content/10.1101/2023.02.02.23285376v1) will be used to explore the possible output enhancement.  PVS segmentation results will be tabulated per lobe using separate ANTsXNet functionality [4](https://pubmed.ncbi.nlm.nih.gov/38632390/).

  Similar functionality exists for segmentation of white matter hyperintensities and will be included in the MRI processing for this project.  Several algorithms have been ported to ANTsXNet from previous research from multiple groups to complement existing capabilities [5](https://pubmed.ncbi.nlm.nih.gov/30125711/) [6](https://pubmed.ncbi.nlm.nih.gov/35088930/) [7](https://pubmed.ncbi.nlm.nih.gov/38050769/).  Regional tabulation will also depend on the lobar segmentation within the white matter as with the PVS segmentation results.

  </details>



  ```python
  import antspyt1w
  import antspymm
  antspyt1w.get_data(force_download=True)
  antspymm.get_data(force_download=True)
  ```

  NOTE: `get_data` has a `force_download` option to make sure the latest
  package data is installed.

  NOTE: some functions in `antspynet` will download deep network model weights on the fly.  if one is containerizing, then it would be worth running a test case through in the container to make sure all the relevant weights are pre-downloaded.

  NOTE: an example process for BIDS data on a cluster is [here](https://github.com/stnava/ANTPD_antspymm).  this repo is also a good place to try to learn how to use this tool.



  see the latest help but this snippet gives an idea of how one might use the package:

  ```python
  import os
  os.environ["TF_NUM_INTEROP_THREADS"] = "8"
  os.environ["TF_NUM_INTRAOP_THREADS"] = "8"
  os.environ["ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS"] = "8"

  import antspymm
  import antspyt1w
  import antspynet
  import ants

  ... i/o code here ...

  tabPro, normPro = antspymm.mm(
      t1,
      hier,
      nm_image_list = mynm,
      rsf_image = rsf,
      dw_image = dwi,
      bvals = bval_fname,
      bvecs = bvec_fname,
      flair_image = flair,
      do_tractography=False,
      do_kk=False,
      do_normalization=True,
      verbose=True )

  antspymm.write_mm( '/tmp/test_output', t1wide, tabPro, normPro )

  ```



  this package also provides tools to identify the *best* multi-modality image set at a given visit.

  the code below provides guidance on how to automatically qc, filter and match multiple modality images at each time point.  these tools are based on standard unsupervised approaches and are not perfect so we recommend using the associated plotting/visualization techniques to check the quality characterizations for each modality.

  ```python


  qcdf=pd.DataFrame()
  for fn in fns:
    qcdf=pd.concat( [qcdf,antspymm.blind_image_assessment(fn)], axis=0)
  qcdfa=antspymm.average_blind_qc_by_modality(qcdf,verbose=True) ## reduce the time series qc
  qcdfaol=antspymm.outlierness_by_modality(qcdfa) # estimate outlier scores
  print( qcdfaol.shape )
  print( qcdfaol.keys )
  matched_mm_data=antspymm.match_modalities( qcdfaol  )
  ```

  or just get modality-specific outlierness "by hand" then match `mm`:

  ```python
  import antspymm
  import pandas as pd
  mymods = antspymm.get_valid_modalities( )
  alldf = pd.DataFrame()
  for n in range(len(mymods)):
      m=mymods[n]
      jj=antspymm.collect_blind_qc_by_modality("qc/*"+m+"*csv")
      jjj=antspymm.average_blind_qc_by_modality(jj,verbose=False).dropna(axis=1) ## reduce the time series qc
      jjj=antspymm.outlierness_by_modality( jjj, verbose=False)
      alldf = pd.concat( [alldf, jjj ], axis=0 )
      jjj.to_csv( "mm_outlierness_"+m+".csv")
      print(m+" done")

  alldf.to_csv( "mm_outlierness.csv", index=False )

  matched_mm_data=antspymm.match_modalities( alldf, verbose=True )
  matched_mm_data.to_csv( "matched_mm_data.csv", index=False )
  matched_mm_data['negative_outlier_factor'] = 1.0 - matched_mm_data['ol_loop'].astype("float")
  matched_mm_data2 = antspymm.highest_quality_repeat( matched_mm_data, 'subjectID', 'date', qualityvar='negative_outlier_factor')
  matched_mm_data2.to_csv( "matched_mm_data2.csv", index=False )
  ```



  from : [ANT PD](https://openneuro.org/datasets/ds001907/versions/3.0.2)   see also [this repo](https://github.com/stnava/ANTPD_antspymm).

  ```
  imagesBIDS/
  └── ANTPD
      └── sub-RC4125
          └── ses-1
              ├── anat
              │   ├── sub-RC4125_ses-1_T1w.json
              │   └── sub-RC4125_ses-1_T1w.nii.gz
              ├── dwi
              │   ├── sub-RC4125_ses-1_dwi.bval
              │   ├── sub-RC4125_ses-1_dwi.bvec
              │   ├── sub-RC4125_ses-1_dwi.json
              │   └── sub-RC4125_ses-1_dwi.nii.gz
              └── func
                  ├── sub-RC4125_ses-1_task-ANT_run-1_bold.json
                  ├── sub-RC4125_ses-1_task-ANT_run-1_bold.nii.gz
                  └── sub-RC4125_ses-1_task-ANT_run-1_events.tsv
  ```

  ```python
  import antspymm
  import pandas as pd
  import glob as glob
  fns = glob.glob("imagesBIDS/ANTPD/sub-RC4125/ses-*/*/*gz")
  fns.sort()
  randid='000' # BIDS does not have unique image ids - so we assign one
  studycsv = antspymm.generate_mm_dataframe(
      'ANTPD',
      'sub-RC4125',
      'ses-1',
      randid,
      'T1w',
      '/Users/stnava/data/openneuro/imagesBIDS/',
      '/Users/stnava/data/openneuro/processed/',
      t1_filename=fns[0],
      dti_filenames=[fns[1]],
      rsf_filenames=[fns[2]])
  studycsv2 = studycsv.dropna(axis=1)
  mmrun = antspymm.mm_csv( studycsv2, mysep='_' )



  zz=antspymm.aggregate_antspymm_results_sdf( studycsv_all,
      subject_col='subjectID', date_col='date', image_col='imageID',  base_path=bd,
      splitsep='_', idsep='-', wild_card_modality_id=True, verbose=True)

  ```



  NRG format details [here](https://htmlpreview.github.io/?https://github.com/stnava/biomedicalDataOrganization/blob/master/src/nrg_data_organization_summary.html)

  ```
  imagesNRG/
  └── ANTPD
      └── sub-RC4125
          └── ses-1
              ├── DTI
              │   └── 000
              │       ├── ANTPD_sub-RC4125_ses-1_DTI_000.bval
              │       ├── ANTPD_sub-RC4125_ses-1_DTI_000.bvec
              │       ├── ANTPD_sub-RC4125_ses-1_DTI_000.json
              │       └── ANTPD_sub-RC4125_ses-1_DTI_000.nii.gz
              ├── T1w
              │   └── 000
              │       └── ANTPD_sub-RC4125_ses-1_T1w_000.nii.gz
              └── rsfMRI
                  └── 000
                      └── ANTPD_sub-RC4125_ses-1_rsfMRI_000.nii.gz
  ```



  ```python
  import antspymm
  import pandas as pd
  import glob as glob
  t1fn=glob.glob("imagesNRG/ANTPD/sub-RC4125/ses-*/*/*/*T1w*gz")[0]

  dtfn=glob.glob("imagesNRG/ANTPD/sub-RC4125/ses-*/*/*/*DTI*gz")
  rsfn=glob.glob("imagesNRG/ANTPD/sub-RC4125/ses-*/*/*/*rsfMRI*gz")
  studycsv = antspymm.generate_mm_dataframe(
      'ANTPD',
      'sub-RC4125',
      'ses-1',
      '000',
      'T1w',
      '/Users/stnava/data/openneuro/imagesNRG/',
      '/Users/stnava/data/openneuro/processed/',
      t1fn,
      rsf_filenames=rsfn,
      dti_filenames=dtfn
  )
  studycsv2 = studycsv.dropna(axis=1)
  mmrun = antspymm.mm_csv( studycsv2, mysep='_' )
  ```




  Large population studies may need more care to ensure everything is reproducibly organized and processed.  In this case, we recommend:



  first run the blind qc function that would look like `tests/blind_qc.py`.
  this gives a quick view of the relevant data to be processed. it provides
  both figures and summary data for each 3D and 4D (potential) input image.



  the outlierness function gives one an idea of how each image relates to
  the others in terms of similarity.  it may or may not succeed in detecting
  true outliers but does a reasonable job of providing some rank ordering
  of quality when there is repeated data.  see `tests/outlierness.py`.



  this occurs at the end of `tests/outlierness.py`.  the output of the
  function will select the best quality time point multiple modality
  collection and will define the antspymm cohort in a reproducible manner.



  for each subject/timepoint, one would run:

  ```python

  studyfn="matched_mm_data2.csv"
  df=pd.read_csv( studyfn )
  index = 20 # 20th subject/timepoint
  csvfns = df['filename']
  csvrow = df[ df['filename'] == csvfns[index] ]
  csvrow['projectID']='MyStudy'


  template = ants.image_read("~/.antspymm/PPMI_template0.nii.gz")
  bxt = ants.image_read("~/.antspymm/PPMI_template0_brainmask.nii.gz")
  template = template * bxt
  template = ants.crop_image( template, ants.iMath( bxt, "MD", 12 ) )
  studycsv2 = antspymm.study_dataframe_from_matched_dataframe(
          csvrow,
          rootdir + "nrgdata/data/",
          rootdir + "processed/", verbose=True)
  mmrun = antspymm.mm_csv( studycsv2,
                          dti_motion_correct='SyN',
                          dti_denoise=True,
                          normalization_template=template,
                          normalization_template_output='ppmi',
                          normalization_template_transform_type='antsRegistrationSyNQuickRepro[s]',
                          normalization_template_spacing=[1,1,1])
  ```



  if you have a large population study then the last step would look like this:

  ```python
  import antspymm
  import glob as glob
  import re
  import pandas as pd
  import os
  df = pd.read_csv( "matched_mm_data2.csv" )
  pdir='./processed/'
  df['projectID']='MYSTUDY'
  merged = antspymm.merge_wides_to_study_dataframe( df, pdir, verbose=False, report_missing=False, progress=100 )
  print(merged.shape)
  merged.to_csv("mystudy_results_antspymm.csv")
  ```




  * [dcm2niix](https://github.com/rordenlab/dcm2niix)

  * [dicom2nifti](https://dicom2nifti.readthedocs.io/en/latest/)

  ```python
  import dicom2nifti

  dicom2nifti.convert_directory(dicom_directory, output_folder, compression=True, reorient=True)
  ```

  * [simpleitk](https://pypi.org/project/SimpleITK/)

  ```python
  import SimpleITK as sitk
  import sys
  import os
  import glob as glob
  import ants
  dd='dicom'
  oo='dicom2nifti'
  folders=glob.glob('dicom/*')
  k=0
  for f in folders:
      print(f)
      reader = sitk.ImageSeriesReader()
      ff=glob.glob(f+"/*")
      dicom_names = reader.GetGDCMSeriesFileNames(ff[0])
      if len(ff) > 0:
          fnout='dicom2nifti/image_'+str(k).zfill(4)+'.nii.gz'
          if not exists(fnout):
              failed=False
              reader.SetFileNames(dicom_names)
              try:
                  image = reader.Execute()
              except:
                  failed=True
                  pass
              if not failed:
                  size = image.GetSpacing()
                  print( image.GetMetaDataKeys( ) )
                  print( size )
                  sitk.WriteImage(image, fnout )
                  img=ants.image_read( fnout )
                  img=ants.iMath(img,'TruncateIntensity',0.02,0.98)
                  ants.plot( img, nslices=21,ncol=7,axis=2, crop=True )
          else:
              print(f+ ": "+'empty')
      k=k+1
  ```



  ```
  pdoc -o ./docs antspymm --html
  ```



  if you get an odd certificate error when calling `force_download`, try:

  ```python
  import ssl
  ssl._create_default_https_context = ssl._create_unverified_context
  ```



  before doing this - make sure you have a recent run of `pip-compile pyproject.toml`

  ```
  rm -r -f build/ antspymm.egg-info/ dist/
  python3 -m  build .
  python3 -m pip install --upgrade twine
  python3 -m twine upload --repository antspymm dist/*
  ```


pkgId: bbd4aa6d346747bd1a04dade030717395af1229bd859817c5941b123b7131cd2
name: python-antspymm
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: multi-channel/time-series medical image processing with antspyx
url: https://pypi.org/project/antspymm/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antspymm-1.4.2-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/ANTsX/ANTsPyMM/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/ANTsX/ANTsPyMM/tree/main)

  ![mapping](https://i.imgur.com/qKqYjU9.jpeg)



  the outputs of these processes can be used for data inspection/cleaning/triage
  as well for interrogating hypotheses.

  this package also keeps track of the latest preferred algorithm variations for
  production environments.

  install the `dev` version by calling (within the source directory):

  ```
  python3 -m  build .
  ```

  or install the latest release via

  ```
  pip install antspymm
  ```



  ANTsPyMM will process several types of brain MRI into tabular form as well as normalized (standard template) space.  The processing includes:

  * T1wHier uses hierarchical processing from ANTsPyT1w organized around these measurements

      * CIT168 template 10.1101/211201

      * Desikan Killiany Tourville (DKT) 10.3389/fnins.2012.00171

      * basal forebrain (Avants et al HBM 2022 abstract)

      * other regions (eg MTL) 10.1101/2023.01.17.23284693

      * also produces jacobian data

  * rsfMRI: resting state functional MRI

      * uses [a recent homotopic parcellation](https://pubmed.ncbi.nlm.nih.gov/36918136/) to estimate network specific correlations

      * f/ALFF 10.1016/j.jneumeth.2008.04.012

      * [percent absolute fluctuation](https://www.frontiersin.org/journals/neuroscience/articles/10.3389/fnins.2022.888174/full)

  * NM2DMT: neuromelanin mid-brain images

      * CIT168 template 10.1101/211201

  * DTI: DWI diffusion weighted images organized via:

      * CIT168 template 10.1101/211201

      * JHU atlases 10.1016/j.neuroimage.2008.07.009  10.1016/j.neuroimage.2007.07.053

      * DKT for cortical to cortical tractography estimates based on DiPy

  * T2Flair: flair for white matter hyperintensity

      * https://pubmed.ncbi.nlm.nih.gov/30908194/

      * https://pubmed.ncbi.nlm.nih.gov/30125711/

      * https://pubmed.ncbi.nlm.nih.gov/35088930/

  * T1w: voxel-based cortical thickness (DiReCT) 10.1016/j.neuroimage.2008.12.016

  Results of these processes are plentiful; processing for a single subject
  will all modalities will take around 2 hours on an average laptop.

  * documentation of functions [here](http://htmlpreview.github.io/?https://github.com/stnava/ANTsPyMM/blob/main/docs/antspymm/mm.html).

  * data dictionary [here](http://htmlpreview.github.io/?https://github.com/stnava/ANTsPyMM/blob/main/docs/make_dict_table.html).

  * notes on QC [here](http://htmlpreview.github.io/?https://github.com/stnava/ANTsPyMM/blob/main/docs/blind_qc.html)


  achieved through four steps (recommended approach):

  1. organize data in NRG format

  2. perform blind QC

  3. compute outlierness per modality and select optimally matched modalities ( steps 3.1 and 3.2 )

  4. run the main antspymm function



  <details>
  <summary>Overview</summary>

  The Advanced Normalization Tools Ecosystem (ANTsX) is a collection of interrelated, open-source software libraries for biological and medical image processing [1](https://pubmed.ncbi.nlm.nih.gov/33907199/) and analysis built on the NIH’s Insight Toolkit (ITK).  ANTsX has demonstrated significant applicability for a variety of organ systems, species, and imaging modalities [2](https://pubmed.ncbi.nlm.nih.gov/25977810/) [3](https://pubmed.ncbi.nlm.nih.gov/38746199/) [4](https://pubmed.ncbi.nlm.nih.gov/35703369/).  ANTsX-based processing of multi-modality studies utilizes the Python-based ANTsPyMM library.  This includes structural (T1-w, DTI, FLAIR), functional (fMRI), and perfusion (ASL) modalities.

  </details>

  <details>
  <summary>T1-weighted MRI</summary>

  T1-weighted MRI processing has been previously described [1](https://pubmed.ncbi.nlm.nih.gov/33907199/) [2](https://pubmed.ncbi.nlm.nih.gov/38632390/).  It is coordinated by ANTsPyT1w, a sub-component of ANTsPyMM, and includes tools for image registration, segmentation, and super-resolution as customized for the human brain. Processing components include preprocessing (denoising + bias correction), brain extraction, sis-tissue parenchymal parcellation (CSF, gray matter, white matter, deep gray matter, brain stem, and cerebellum), and cortical parcellation for morphological quantitation.  Derived measurements are tabulated by the neuroanatomical coordinates defined above and include cortical and subcortical measurements and morphological measurements of the hippocampus, basal forebrain and cerebellum.

  </details>

  <details>
  <summary>Diffusion</summary>

  Diffusion processing.  ANTsPyMM couples the ANTsX toolkit with the Diffusion Imaging in Python (Dipy) library for the processing and analysis of diffusion MRI [1](https://pubmed.ncbi.nlm.nih.gov/24600385/).   The former is used for motion correction and normalization to corresponding T1-w images.  Output consists of QC images, the motion corrected diffusion series, RGB images, FA, mean diffusion and dense tractography as well as tractography-based connectivity matrices.  Tabular summary of these metrics are written to csv.

  </details>

  <details>
  <summary>Resting-state fMRI</summary>

  The rsfMRI processing computes a robust summary of resting-state fMRI time series data and corrects for motion artifacts, extracts temporal statistics, and computes functional connectivity across the brain. The analysis pipeline incorporates advanced techniques for noise reduction, temporal derivative calculation, signal standardization, and the calculation of functional connectivity between brain regions using Yeo homotopic labels. This provides researchers with cleaned, standardized, and biologically meaningful data for further analysis of brain network activity.

  Several preprocessing steps are included in the ANTsPyMM processing of resting state fMRI (rsfMRI) data.  First, motion correction is used to align the time series to a series specific fMRI template.  Distortion correction to t1 is also performed along with brain extraction.  The **temporal derivative** is calculated to quantify changes over time in the signal, followed by the **temporal standard deviation (tSTD)**, which computes the variability across time for each voxel. This is done to identify regions of interest with significant signal variation. The **CompCor matrix** [1](https://pubmed.ncbi.nlm.nih.gov/17560126/) is computed using temporal standard deviation thresholds, which helps remove noise by identifying high-variance regions. Additionally, **motion correction** is a central part of the pipeline, where metrics like framewise displacement (FD) and motion-induced signal changes (DVARS) are calculated to detect and correct for artifacts caused by subject movement. **Bandpass filtering** is applied to focus the analysis on brain signals within specific frequency ranges, and **censoring** is used to exclude high-motion time points from the analysis, ensuring cleaner data. The preprocessing concludes with the calculation of **summary statistics**, including measures of signal-to-noise ratio (SNR) and motion effects, which are compiled into a dictionary for further use.

  The next step in the pipeline involves computing functional connectivity through **correlation matrices** based on the **Yeo homotopic labels**, which group brain regions into homotopic (mirrored) areas across hemispheres. Time series data are averaged within each Yeo-labeled region, and pairwise **correlation matrices** are computed to assess the functional connectivity both within and between brain hemispheres. This allows for an in-depth analysis of large-scale brain networks, including symmetrical interactions between homotopic regions and connectivity within networks such as the default mode network, visual network, and others.

  This provides a comprehensive framework for preprocessing resting-state fMRI data and analyzing functional connectivity across the brain. By combining robust noise reduction, motion correction, and correlation matrix computation, the pipeline ensures that the resulting data are suitable for high-quality research into brain network dynamics and resting-state connectivity. Through the use of Yeo homotopic labels and functional correlation matrices, the code offers a valuable tool for investigating symmetrical brain activity and network interactions in fMRI studies. By default, three different sets of processing parameters are employed.  These were chosen based on an empirical evaluation of reproducibility in a traveling participant cohort.

  </details>

  <details>
  <summary>ASL</summary>

  ASL processing.  Cerebral blood flow (CBF) is a critical parameter in understanding brain function and its alterations in various neurological conditions. Arterial spin labeling (ASL) MRI is a non-invasive technique that can measure CBF without the need for contrast agents. ANTsPyMM estimates CBF from ASL MRI data through a combination of image processing and mathematical modeling techniques [1](https://pubmed.ncbi.nlm.nih.gov/24715426/).  First, motion artifacts and outliers are removed from the time series data.  Second, the preprocessed data is registered to the reference T1-w space using a rigid transformation optimized through the ANTs registration tools [2](https://pubmed.ncbi.nlm.nih.gov/24817849/).  Third, the six-tissue segmentation generated during the T1-w segmentation is used to partition the registered ASL data from which the CBF is estimated using a mathematical model that takes into account the ASL MRI signal, the labeling efficiency, and the longitudinal relaxation time of blood.  Finally, the M0 image, which represents the equilibrium magnetization of brain tissue, is estimated using a separate mathematical model.

  </details>

  <details>
  <summary>Magnetic resonance angiography</summary>

  MRA processing and analysis.   A precursor for quantitative measures of potential vascular irregularities is the segmentation derived from MR angiography.  To extract these image-based quantitative measures (described below), we developed and trained a deep learning network as part of the ANTsXNet functional library.  Training data was adapted from a publicly available resource [1](https://data.kitware.com/#item/58a372e48d777f0721a64dc9) consisting of 42 subjects with vascular network segmentations and brain masks provided.  A previously constructed high-resolution template was generated from the Human Connectome Project Young Adult cohort comprising T1-w, T2-w, and FA modalities using ANTs functionality [2](https://pubmed.ncbi.nlm.nih.gov/19818860/) [3](https://pubmed.ncbi.nlm.nih.gov/25433513/) and served as the prediction space for network training.  Prior spatial information was included by warping all vascular segmentations to the template space, averaged, spatially smoothed, and renormalized to the intensity range [0,1].  Aggressive data augmentation was used to generate additional data in real time during training consisting of random spatial linear and deformable transformations, random Gaussian additive noise, random histogram-based intensity warping [4](https://pubmed.ncbi.nlm.nih.gov/34227163/), and simulated bias field based on the popular N4 algorithm [5](https://pubmed.ncbi.nlm.nih.gov/20378467/). The functionality is available as open-source in both the R-based ANTsRNet (``brainMraVesselSegmentation(...)``) and Python-based ANTsPyNet (``brain_mra_vessel_segmentation(...)``).

  </details>

  <details>
  <summary>Periventricular spaces and white matter hyperintensities</summary>

  Traditional measures for indicating abnormal vascular morphology can then be calculated, such as tortuosity [1](https://pubmed.ncbi.nlm.nih.gov/12956271/).  For example, tight vascular coils (i.e., high tortuosity) are often associated with the presence of malignant tumors.  From the centerline of the vessel segmentation, various tortuosity measures have been proposed including 1) distance metric: the ratio of the length of the centerline to the distance between the two endpoints, 2) inflection count metric: the distance metric multiplied by the number of the inflection points (i.e., a point of minimum total curvature), 3) sum of angles metric: the integrated total curvature normalized by total path length.

  For quantitative assessment of enlarged perivascular spaces, we employ functionality made publicly available through the ANTsX toolkit.  Specifically, previous published research [2](https://pubmed.ncbi.nlm.nih.gov/34262443/) has been ported to the ANTsXNet library and will be used for segmenting enlarged perivascular spaces.  Using both T1 and FLAIR modalities, a trained deep learning U-net neural network was trained using 40 datasets in which all visible perivascular spaces were manually annotated by an expert.  An ensemble of trained weights is used to produce the final probability image.  Previous work in MRI super resolution [3](https://www.medrxiv.org/content/10.1101/2023.02.02.23285376v1) will be used to explore the possible output enhancement.  PVS segmentation results will be tabulated per lobe using separate ANTsXNet functionality [4](https://pubmed.ncbi.nlm.nih.gov/38632390/).

  Similar functionality exists for segmentation of white matter hyperintensities and will be included in the MRI processing for this project.  Several algorithms have been ported to ANTsXNet from previous research from multiple groups to complement existing capabilities [5](https://pubmed.ncbi.nlm.nih.gov/30125711/) [6](https://pubmed.ncbi.nlm.nih.gov/35088930/) [7](https://pubmed.ncbi.nlm.nih.gov/38050769/).  Regional tabulation will also depend on the lobar segmentation within the white matter as with the PVS segmentation results.

  </details>



  ```python
  import antspyt1w
  import antspymm
  antspyt1w.get_data(force_download=True)
  antspymm.get_data(force_download=True)
  ```

  NOTE: `get_data` has a `force_download` option to make sure the latest
  package data is installed.

  NOTE: some functions in `antspynet` will download deep network model weights on the fly.  if one is containerizing, then it would be worth running a test case through in the container to make sure all the relevant weights are pre-downloaded.

  NOTE: an example process for BIDS data on a cluster is [here](https://github.com/stnava/ANTPD_antspymm).  this repo is also a good place to try to learn how to use this tool.



  see the latest help but this snippet gives an idea of how one might use the package:

  ```python
  import os
  os.environ["TF_NUM_INTEROP_THREADS"] = "8"
  os.environ["TF_NUM_INTRAOP_THREADS"] = "8"
  os.environ["ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS"] = "8"

  import antspymm
  import antspyt1w
  import antspynet
  import ants

  ... i/o code here ...

  tabPro, normPro = antspymm.mm(
      t1,
      hier,
      nm_image_list = mynm,
      rsf_image = rsf,
      dw_image = dwi,
      bvals = bval_fname,
      bvecs = bvec_fname,
      flair_image = flair,
      do_tractography=False,
      do_kk=False,
      do_normalization=True,
      verbose=True )

  antspymm.write_mm( '/tmp/test_output', t1wide, tabPro, normPro )

  ```



  this package also provides tools to identify the *best* multi-modality image set at a given visit.

  the code below provides guidance on how to automatically qc, filter and match multiple modality images at each time point.  these tools are based on standard unsupervised approaches and are not perfect so we recommend using the associated plotting/visualization techniques to check the quality characterizations for each modality.

  ```python


  qcdf=pd.DataFrame()
  for fn in fns:
    qcdf=pd.concat( [qcdf,antspymm.blind_image_assessment(fn)], axis=0)
  qcdfa=antspymm.average_blind_qc_by_modality(qcdf,verbose=True) ## reduce the time series qc
  qcdfaol=antspymm.outlierness_by_modality(qcdfa) # estimate outlier scores
  print( qcdfaol.shape )
  print( qcdfaol.keys )
  matched_mm_data=antspymm.match_modalities( qcdfaol  )
  ```

  or just get modality-specific outlierness "by hand" then match `mm`:

  ```python
  import antspymm
  import pandas as pd
  mymods = antspymm.get_valid_modalities( )
  alldf = pd.DataFrame()
  for n in range(len(mymods)):
      m=mymods[n]
      jj=antspymm.collect_blind_qc_by_modality("qc/*"+m+"*csv")
      jjj=antspymm.average_blind_qc_by_modality(jj,verbose=False).dropna(axis=1) ## reduce the time series qc
      jjj=antspymm.outlierness_by_modality( jjj, verbose=False)
      alldf = pd.concat( [alldf, jjj ], axis=0 )
      jjj.to_csv( "mm_outlierness_"+m+".csv")
      print(m+" done")

  alldf.to_csv( "mm_outlierness.csv", index=False )

  matched_mm_data=antspymm.match_modalities( alldf, verbose=True )
  matched_mm_data.to_csv( "matched_mm_data.csv", index=False )
  matched_mm_data['negative_outlier_factor'] = 1.0 - matched_mm_data['ol_loop'].astype("float")
  matched_mm_data2 = antspymm.highest_quality_repeat( matched_mm_data, 'subjectID', 'date', qualityvar='negative_outlier_factor')
  matched_mm_data2.to_csv( "matched_mm_data2.csv", index=False )
  ```



  from : [ANT PD](https://openneuro.org/datasets/ds001907/versions/3.0.2)   see also [this repo](https://github.com/stnava/ANTPD_antspymm).

  ```
  imagesBIDS/
  └── ANTPD
      └── sub-RC4125
          └── ses-1
              ├── anat
              │   ├── sub-RC4125_ses-1_T1w.json
              │   └── sub-RC4125_ses-1_T1w.nii.gz
              ├── dwi
              │   ├── sub-RC4125_ses-1_dwi.bval
              │   ├── sub-RC4125_ses-1_dwi.bvec
              │   ├── sub-RC4125_ses-1_dwi.json
              │   └── sub-RC4125_ses-1_dwi.nii.gz
              └── func
                  ├── sub-RC4125_ses-1_task-ANT_run-1_bold.json
                  ├── sub-RC4125_ses-1_task-ANT_run-1_bold.nii.gz
                  └── sub-RC4125_ses-1_task-ANT_run-1_events.tsv
  ```

  ```python
  import antspymm
  import pandas as pd
  import glob as glob
  fns = glob.glob("imagesBIDS/ANTPD/sub-RC4125/ses-*/*/*gz")
  fns.sort()
  randid='000' # BIDS does not have unique image ids - so we assign one
  studycsv = antspymm.generate_mm_dataframe(
      'ANTPD',
      'sub-RC4125',
      'ses-1',
      randid,
      'T1w',
      '/Users/stnava/data/openneuro/imagesBIDS/',
      '/Users/stnava/data/openneuro/processed/',
      t1_filename=fns[0],
      dti_filenames=[fns[1]],
      rsf_filenames=[fns[2]])
  studycsv2 = studycsv.dropna(axis=1)
  mmrun = antspymm.mm_csv( studycsv2, mysep='_' )



  zz=antspymm.aggregate_antspymm_results_sdf( studycsv_all,
      subject_col='subjectID', date_col='date', image_col='imageID',  base_path=bd,
      splitsep='_', idsep='-', wild_card_modality_id=True, verbose=True)

  ```



  NRG format details [here](https://htmlpreview.github.io/?https://github.com/stnava/biomedicalDataOrganization/blob/master/src/nrg_data_organization_summary.html)

  ```
  imagesNRG/
  └── ANTPD
      └── sub-RC4125
          └── ses-1
              ├── DTI
              │   └── 000
              │       ├── ANTPD_sub-RC4125_ses-1_DTI_000.bval
              │       ├── ANTPD_sub-RC4125_ses-1_DTI_000.bvec
              │       ├── ANTPD_sub-RC4125_ses-1_DTI_000.json
              │       └── ANTPD_sub-RC4125_ses-1_DTI_000.nii.gz
              ├── T1w
              │   └── 000
              │       └── ANTPD_sub-RC4125_ses-1_T1w_000.nii.gz
              └── rsfMRI
                  └── 000
                      └── ANTPD_sub-RC4125_ses-1_rsfMRI_000.nii.gz
  ```



  ```python
  import antspymm
  import pandas as pd
  import glob as glob
  t1fn=glob.glob("imagesNRG/ANTPD/sub-RC4125/ses-*/*/*/*T1w*gz")[0]

  dtfn=glob.glob("imagesNRG/ANTPD/sub-RC4125/ses-*/*/*/*DTI*gz")
  rsfn=glob.glob("imagesNRG/ANTPD/sub-RC4125/ses-*/*/*/*rsfMRI*gz")
  studycsv = antspymm.generate_mm_dataframe(
      'ANTPD',
      'sub-RC4125',
      'ses-1',
      '000',
      'T1w',
      '/Users/stnava/data/openneuro/imagesNRG/',
      '/Users/stnava/data/openneuro/processed/',
      t1fn,
      rsf_filenames=rsfn,
      dti_filenames=dtfn
  )
  studycsv2 = studycsv.dropna(axis=1)
  mmrun = antspymm.mm_csv( studycsv2, mysep='_' )
  ```




  Large population studies may need more care to ensure everything is reproducibly organized and processed.  In this case, we recommend:



  first run the blind qc function that would look like `tests/blind_qc.py`.
  this gives a quick view of the relevant data to be processed. it provides
  both figures and summary data for each 3D and 4D (potential) input image.



  the outlierness function gives one an idea of how each image relates to
  the others in terms of similarity.  it may or may not succeed in detecting
  true outliers but does a reasonable job of providing some rank ordering
  of quality when there is repeated data.  see `tests/outlierness.py`.



  this occurs at the end of `tests/outlierness.py`.  the output of the
  function will select the best quality time point multiple modality
  collection and will define the antspymm cohort in a reproducible manner.



  for each subject/timepoint, one would run:

  ```python

  studyfn="matched_mm_data2.csv"
  df=pd.read_csv( studyfn )
  index = 20 # 20th subject/timepoint
  csvfns = df['filename']
  csvrow = df[ df['filename'] == csvfns[index] ]
  csvrow['projectID']='MyStudy'


  template = ants.image_read("~/.antspymm/PPMI_template0.nii.gz")
  bxt = ants.image_read("~/.antspymm/PPMI_template0_brainmask.nii.gz")
  template = template * bxt
  template = ants.crop_image( template, ants.iMath( bxt, "MD", 12 ) )
  studycsv2 = antspymm.study_dataframe_from_matched_dataframe(
          csvrow,
          rootdir + "nrgdata/data/",
          rootdir + "processed/", verbose=True)
  mmrun = antspymm.mm_csv( studycsv2,
                          dti_motion_correct='SyN',
                          dti_denoise=True,
                          normalization_template=template,
                          normalization_template_output='ppmi',
                          normalization_template_transform_type='antsRegistrationSyNQuickRepro[s]',
                          normalization_template_spacing=[1,1,1])
  ```



  if you have a large population study then the last step would look like this:

  ```python
  import antspymm
  import glob as glob
  import re
  import pandas as pd
  import os
  df = pd.read_csv( "matched_mm_data2.csv" )
  pdir='./processed/'
  df['projectID']='MYSTUDY'
  merged = antspymm.merge_wides_to_study_dataframe( df, pdir, verbose=False, report_missing=False, progress=100 )
  print(merged.shape)
  merged.to_csv("mystudy_results_antspymm.csv")
  ```




  * [dcm2niix](https://github.com/rordenlab/dcm2niix)

  * [dicom2nifti](https://dicom2nifti.readthedocs.io/en/latest/)

  ```python
  import dicom2nifti

  dicom2nifti.convert_directory(dicom_directory, output_folder, compression=True, reorient=True)
  ```

  * [simpleitk](https://pypi.org/project/SimpleITK/)

  ```python
  import SimpleITK as sitk
  import sys
  import os
  import glob as glob
  import ants
  dd='dicom'
  oo='dicom2nifti'
  folders=glob.glob('dicom/*')
  k=0
  for f in folders:
      print(f)
      reader = sitk.ImageSeriesReader()
      ff=glob.glob(f+"/*")
      dicom_names = reader.GetGDCMSeriesFileNames(ff[0])
      if len(ff) > 0:
          fnout='dicom2nifti/image_'+str(k).zfill(4)+'.nii.gz'
          if not exists(fnout):
              failed=False
              reader.SetFileNames(dicom_names)
              try:
                  image = reader.Execute()
              except:
                  failed=True
                  pass
              if not failed:
                  size = image.GetSpacing()
                  print( image.GetMetaDataKeys( ) )
                  print( size )
                  sitk.WriteImage(image, fnout )
                  img=ants.image_read( fnout )
                  img=ants.iMath(img,'TruncateIntensity',0.02,0.98)
                  ants.plot( img, nslices=21,ncol=7,axis=2, crop=True )
          else:
              print(f+ ": "+'empty')
      k=k+1
  ```



  ```
  pdoc -o ./docs antspymm --html
  ```



  if you get an odd certificate error when calling `force_download`, try:

  ```python
  import ssl
  ssl._create_default_https_context = ssl._create_unverified_context
  ```



  before doing this - make sure you have a recent run of `pip-compile pyproject.toml`

  ```
  rm -r -f build/ antspymm.egg-info/ dist/
  python3 -m  build .
  python3 -m pip install --upgrade twine
  python3 -m twine upload --repository antspymm dist/*
  ```


pkgId: 67e1c664063933c26a60e6120ae44112e5a30e5085dce3b972945536fd690df6
name: python-antspynet
arch: src
version: 0.2.9
epoch: 0
release: 1
url: https://pypi.org/project/antspynet/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antspynet-0.2.9-1.src.rpm
checksum_type: sha256
summary:
  A collection of deep learning architectures ported to the python language and tools for basic medical image processing.

description:
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/antspynet?label=pypi%20downloads)](https://pypi.org/project/antspynet/)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](code_of_conduct.md)
  [![PubMed](https://img.shields.io/badge/ANTsX_paper-Open_Access-8DABFF?logo=pubmed)](https://pubmed.ncbi.nlm.nih.gov/33907199/)



  A collection of deep learning architectures and applications ported to the Python language and tools for basic medical image processing. Based on `keras` and `tensorflow` with cross-compatibility with our R analog [ANTsRNet](https://github.com/ANTsX/ANTsRNet/). ANTsPyNet provides three high-level features:

  - A large collection of common deep learning architectures for medical imaging that can be initialized
  - Various pre-trained deep learning models to perform key medical imaging tasks
  - Utility functions to improve training and evaluating of deep learning models on medical images

  <p align="middle">
    <img src="docs/figures/coreANTsXNetTools.png" width="600" />
  </p>



  <details>
  <summary>Installation</summary>



  The easiest way to install ANTsPyNet is via pip.

  ```
  python -m pip install antspynet
  ```



  Alternatively, you can download and install from source.

  ```
  git clone https://github.com/ANTsX/ANTsPyNet
  cd ANTsPyNet
  python -m pip install .
  ```

  </details>

  <!--


  The core functionality that ANTsPyNet provides is the ability to initialize a Deep Learning model based on our large collection of model architectures specifically tailored for medical images. You can then train these initialized models using your standard `keras` or `tensorflow` workflows.

  An example of initializing a deep learning model based on the is provided here:

  ```python
  from antspynet.architectures import create_autoencoder_model
  model = create_autoencoder_model((784, 500, 500, 2000, 10))
  model.summary()
  ```

  We also provide a collection of pre-trained models that can perform key medical imaging processing tasks such as brain extraction, segmentation, cortical thickness, and more. An example of reading a brain image using `ANTsPy` and then performing brain extraction using our pre-trained model in `ANTsPyNet` is presented here:

  ```python
  import ants
  import antspynet

  t1 = ants.image_read(antspynet.get_antsxnet_data('mprage_hippmapp3r'))

  seg = antspynet.brain_extraction(t1, modality="t1", verbose=True)
  ants.plot(t1, overlay=seg, overlay_alpha=0.5)
  ```
  -->

  <details>
  <summary>Architectures</summary>



  - [U-Net (2-D, 3-D)](https://arxiv.org/abs/1505.04597)
  - [U-Net + ResNet (2-D, 3-D)](https://arxiv.org/abs/1608.04117)
  - [Dense U-Net (2-D, 3-D)](https://arxiv.org/pdf/1709.07330.pdf)



  - [AlexNet (2-D, 3-D)](http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf)
  - [VGG (2-D, 3-D)](https://arxiv.org/abs/1409.1556)
  - [ResNet (2-D, 3-D)](https://arxiv.org/abs/1512.03385)
  - [ResNeXt (2-D, 3-D)](https://arxiv.org/abs/1611.05431)
  - [WideResNet (2-D, 3-D)](http://arxiv.org/abs/1605.07146)
  - [DenseNet (2-D, 3-D)](https://arxiv.org/abs/1608.06993)





  - [Super-resolution convolutional neural network (SRCNN) (2-D, 3-D)](https://arxiv.org/abs/1501.00092)
  - [Expanded super-resolution (ESRCNN) (2-D, 3-D)](https://arxiv.org/abs/1501.00092)
  - [Denoising auto encoder super-resolution (DSRCNN) (2-D, 3-D)]()
  - [Deep denoise super-resolution (DDSRCNN) (2-D, 3-D)](https://arxiv.org/abs/1606.08921)
  - [ResNet super-resolution (SRResNet) (2-D, 3-D)](https://arxiv.org/abs/1609.04802)
  - [Deep back-projection network (DBPN) (2-D, 3-D)](https://arxiv.org/abs/1803.02735)
  - [Super resolution GAN](https://arxiv.org/abs/1609.04802)



  - [Spatial transformer network (STN) (2-D, 3-D)](https://arxiv.org/abs/1506.02025)



  - [Generative adverserial network (GAN)](https://arxiv.org/abs/1406.2661)
  - [Deep Convolutional GAN](https://arxiv.org/abs/1511.06434)
  - [Wasserstein GAN](https://arxiv.org/abs/1701.07875)
  - [Improved Wasserstein GAN](https://arxiv.org/abs/1704.00028)
  - [Cycle GAN](https://arxiv.org/abs/1703.10593)
  - [Super resolution GAN](https://arxiv.org/abs/1609.04802)



  - [Deep embedded clustering (DEC)](https://arxiv.org/abs/1511.06335)
  - [Deep convolutional embedded clustering (DCEC)](https://xifengguo.github.io/papers/ICONIP17-DCEC.pdf)

  </details>

  <details>
  <summary>Applications</summary>

  * [Brain applications](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#brain-applications)

      * [Multi-modal brain extraction](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#brain-extraction)
      * [Deep Atropos (Six-tissue brain segmentation)](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#deep-atropos)
      * [Cortical thickness](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#cortical-thickness)
      * [Desikan-Killiany-Tourville parcellation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#desikan-killiany-tourville-parcellation)
      * [DeepFLASH (medial temporal lobe parcellation)](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#deepflash-medial-temporal-lobe-parcellation)
      * [Hippmapp3r (hippocampal segmentation)](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#hippmapp3r)
      * [Brain AGE](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#brain-age)
      * [Claustrum segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#claustrum-segmentation)
      * [Hypothalamus segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#hypothalamus-segmentation)
      * [Cerebellum morphology](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#cerebellum-morphology)
      * White matter hyperintensities segmentation
          * [SYSU](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#white-matter-hyperintensities-segmentation-sysu)
          * [Hypermapp3r](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#white-matter-hyperintensities-segmentation-hypermapp3r)
          * [SHIVA](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#white-matter-hyperintensities-segmentation-shiva)
          * [ANTsXNet](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#white-matter-hyperintensities-segmentation-antsxnet)
      * [Perivascular spaces segmentation (SHIVA)](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#perivascular-spaces-segmentation-shiva)
      * [Brain tumor segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#brain-tumor-segmentation)
      * [MRA-TOF vessel segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#mra-tof-vessel-segmentation)
      * [Lesion segmentation (WIP)](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#lesion-segmentation-wip)
      * [Whole head inpainting](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#whole-head-inpainting)

  * [Lung applications](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#lung-applications)

      * [Lung extraction](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#lung-extraction)
      * [Functional lung segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#functional-lung-segmentation)
      * [Pulmonary artery segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#pulmonary-artery-segmentation)
      * [Pulmonary airway segmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#pulmonary-airway-segmentation)
      * [CheXNet](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#chexnet)

  * [Mouse applications](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#mouse-applications)
      * [Mouse brain extraction](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#mouse-brain-extraction)
      * [Mouse brain parcellation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#mouse-brain-parcellation)
      * [Mouse cortical thickness](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#mouse-cortical-thickness)

  * [General applications](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#general-applications)

      * [MRI super resolution](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#mri-super-resolution)
      * [No reference image quality assesment using TID](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#no-reference-image-quality-assesment-using-tid)
      * [Full reference image quality assessment](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#full-reference-image-quality-assessment)

  * [Data augmentation](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#data-augmentation)

      * [Noise](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#noise)
      * [Histogram intensity warping](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#histogram-intensity-warping)
      * [Simulate bias field](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#simulate-bias-field)
      * [Random spatial transformations](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#random-spatial-transformations)
      * [Combined](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#combined)

  </details>

  <details>
  <summary>Publications</summary>

  - Nicholas J. Tustison, Min Chen, Fae N. Kronman, Jeffrey T. Duda, Clare Gamlin, Mia G. Tustison, Michael Kunst, Rachel Dalley, Staci Sorenson, Quanxi Wang, Lydia Ng, Yongsoo Kim, and James C. Gee.  The ANTsX Ecosystem for Mapping the Mouse Brain. [(biorxiv)](https://www.biorxiv.org/content/10.1101/2024.05.01.592056v1)

  - Nicholas J. Tustison, Michael A. Yassa, Batool Rizvi, Philip A. Cook, Andrew J. Holbrook, Mithra Sathishkumar, Mia G. Tustison, James C. Gee, James R. Stone, and Brian B. Avants. ANTsX neuroimaging-derived structural phenotypes of UK Biobank. _Scientific Reports_, 14(1):8848, Apr 2024. [(pubmed)](https://pubmed.ncbi.nlm.nih.gov/38632390/)

  - Nicholas J. Tustison, Talissa A. Altes, Kun Qing, Mu He, G. Wilson Miller, Brian B. Avants, Yun M. Shim, James C. Gee, John P. Mugler III, and Jaime F. Mata. Image- versus histogram-based considerations in semantic segmentation of pulmonary hyperpolarized gas images. _Magnetic Resonance in Medicine_, 86(5):2822-2836, Nov 2021. [(pubmed)](https://pubmed.ncbi.nlm.nih.gov/34227163/)

  - Andrew T. Grainger, Arun Krishnaraj, Michael H. Quinones, Nicholas J. Tustison, Samantha Epstein, Daniela Fuller, Aakash Jha, Kevin L. Allman, Weibin Shi. Deep Learning-based Quantification of Abdominal Subcutaneous and Visceral Fat Volume on CT Images, _Academic Radiology_, 28(11):1481-1487, Nov 2021. [(pubmed)](https://pubmed.ncbi.nlm.nih.gov/32771313/)

  - Nicholas J. Tustison, Philip A. Cook, Andrew J. Holbrook, Hans J. Johnson, John Muschelli, Gabriel A. Devenyi, Jeffrey T. Duda, Sandhitsu R. Das, Nicholas C. Cullen, Daniel L. Gillen, Michael A. Yassa, James R. Stone, James C. Gee, and Brian B. Avants for the Alzheimer’s Disease Neuroimaging Initiative. The ANTsX ecosystem for quantitative biological and medical imaging. _Scientific Reports_. 11(1):9068, Apr 2021. [(pubmed)](https://pubmed.ncbi.nlm.nih.gov/33907199/)

  - Nicholas J. Tustison, Brian B. Avants, and James C. Gee. Learning image-based spatial transformations via convolutional neural networks: a review, _Magnetic Resonance Imaging_, 64:142-153, Dec 2019. [(pubmed)](https://www.ncbi.nlm.nih.gov/pubmed/31200026)

  - Nicholas J. Tustison, Brian B. Avants, Zixuan Lin, Xue Feng, Nicholas Cullen, Jaime F. Mata, Lucia Flors, James C. Gee, Talissa A. Altes, John P. Mugler III, and Kun Qing. Convolutional Neural Networks with Template-Based Data Augmentation for Functional Lung Image Quantification, _Academic Radiology_, 26(3):412-423, Mar 2019. [(pubmed)](https://www.ncbi.nlm.nih.gov/pubmed/30195415)

  - Andrew T. Grainger, Nicholas J. Tustison, Kun Qing, Rene Roy, Stuart S. Berr, and Weibin Shi. Deep learning-based quantification of abdominal fat on magnetic resonance images. _PLoS One_, 13(9):e0204071, Sep 2018. [(pubmed)](https://www.ncbi.nlm.nih.gov/pubmed/30235253)

  - Cullen N.C., Avants B.B. (2018) Convolutional Neural Networks for Rapid and Simultaneous Brain Extraction and Tissue Segmentation. In: Spalletta G., Piras F., Gili T. (eds) Brain Morphometry. Neuromethods, vol 136. Humana Press, New York, NY [doi](https://doi.org/10.1007/978-1-4939-7647-8_2)

  </details>

  <details><summary>License</summary>

  The ANTsPyNet package is released under an [Apache License](https://github.com/ANTsX/ANTsPyNet/blob/master/LICENSE.md).

  </details>

  <details>
  <summary>Acknowledgements</summary>

  - We gratefully acknowledge the support of the NVIDIA Corporation with the donation of two Titan Xp GPUs used for this research.

  - We gratefully acknowledge the grant support of the [Office of Naval Research](https://www.onr.navy.mil) and [Cohen Veterans Bioscience](https://www.cohenveteransbioscience.org).

  </details>

  <!--


  If you encounter an issue, have questions about using ANTsPyNet, or want to request a feature, please feel free to [file an issue](https://github.com/ANTsX/ANTsPyNet/issues). If you plan to contribute new code to ANTsPyNet, we would be very appreciative. The best place to start is again by opening an issue and discussing the potential feature with us.
  -->

  <!--


  before doing this - make sure you have a recent run of `pip-compile pyproject.toml`

  ```
  rm -r -f build/ antspynet.egg-info/ dist/
  python3 -m  build .
  python3 -m pip install --upgrade twine
  python3 -m twine upload --repository antspynet dist/*
  ```
  -->



  [ANTsPyNet Documentation](https://antsx.github.io/ANTsPyNet/)

  [ANTsXNet self-contained examples](https://gist.github.com/ntustison/12a656a5fc2f6f9c4494c88dc09c5621#antsxnet)


pkgId: d8291d49300ef21906995e9e9647fdd7121c319dfd625b53a1106654b0351afa
name: python-antspyt1w
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: T1w human neuroimage processing with antspyx
url: https://pypi.org/project/antspyt1w/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antspyt1w-0.9.4-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/stnava/ANTsPyT1w/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/stnava/ANTsPyT1w/tree/main)



  the outputs of these processes can be used for data inspection/cleaning/triage
  as well for interrogating neuroscientific hypotheses.

  this package also keeps track of the latest preferred algorithm variations for
  production environments.

  install by calling (within the source directory):

  ```
  python setup.py install
  ```

  or install via `pip install antspyt1w`



  - provide example data

  - brain extraction

  - denoising

  - n4 bias correction

  - brain parcellation into tissues, hemispheres, lobes and regions

  - hippocampus specific segmentation

  - t1 hypointensity segmentation and classification *exploratory*

  - deformable registration with robust and repeatable parameters

  - registration-based labeling of major white matter tracts

  - helpers that organize and annotate segmentation variables into data frames

  - hypothalamus segmentation *FIXME/TODO*


  the two most time-consuming processes are hippocampus-specific segentation
  (because it uses augmentation) and registration.  both take 10-20 minutes
  depending on your available computational resources and the data.  both
  could be made computationally cheaper at the cost of accuracy/reliability.



  ```python
  import antspyt1w
  antspyt1w.get_data()
  ```

  NOTE: `get_data` has a `force_download` option to make sure the latest
  package data is installed.



  ```python
  import os
  os.environ["TF_NUM_INTEROP_THREADS"] = "8"
  os.environ["TF_NUM_INTRAOP_THREADS"] = "8"
  os.environ["ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS"] = "8"

  import antspyt1w
  import antspynet
  import ants





  fn = antspyt1w.get_data('PPMI-3803-20120814-MRI_T1-I340756', target_extension='.nii.gz' )
  img = ants.image_read( fn )


  myresults = antspyt1w.hierarchical( img, output_prefix = '/tmp/XXX' )







  ```

  An example "full study" (at small scale) is illustrated in `~/.antspyt1w/run_dlbs.py`
  which demonstrates/comments on:
  - how to aggregate dataframes
  - how to pivot to wide format
  - how to join with a demographic/metadata file
  - visualizing basic outcomes.



  if you get an odd certificate error when calling `force_download`, try:

  ```python
  import ssl
  ssl._create_default_https_context = ssl._create_unverified_context
  ```



  before doing this - make sure you have a recent run of `pip-compile pyproject.toml`

  ```
  rm -r -f build/ antspyt1w.egg-info/ dist/
  python3 -m  build .
  python3 -m pip install --upgrade twine
  python3 -m twine upload --repository antspyt1w dist/*
  ```


pkgId: 4a4dc48309b82c6360784d5f9b82c070fed5877f59dc5d2fa2e7ca0044e63ee3
name: python-antx
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Transfer annotations from source text to destination using diff match patch.
url: https://github.com/Esukhia/annotation_transfer
rpm_license: Apache2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-antx-0.1.11-1.src.rpm
checksum_type: sha256
description:
  Transfer annotations from source text to destination using diff match patch.

  ![Test](https://github.com/Esukhia/annotation_transfer/workflows/Test/badge.svg)
  [![PyPI version](https://badge.fury.io/py/antx.svg)](https://badge.fury.io/py/antx)




  ```
  $ pip install antx
  ```


  ```
  from antx import transfer
  ```


  ```
  new_target = transfer(source_text, annotations, target_text, output="txt")
  ```
  **source_text** := contains source text

  **annotations** := contains list of annotations in source text that you want to transfer to target text

  **target_text** := contains target text

  **output** := Flag to indicate type of output. It can be txt or yaml.


  **Example**

  ```python
  source_text =  """༄༅། །ཕྱག་ཆེན་སྔོན་འགྲོ་བཞི་སྦྱོར་དང་དངོས་གཞིའི་ཁྲིད་རིམ་མདོར་བསྡུས་ངེས་དོན་སྒྲོན་མེ་ཞེས་བྱ་བ་བཞུགས་སོ། །
  <𰵀auམཛད་པ་པོ། འཇམ་མགོན་ཀོང་སྤྲུལ་བློ་གྲོས་མཐའ་ཡས། །>
  ༄༅། །ཕྱག་ཆེན་སྔོན་འགྲོ་བཞི་སྦྱོར་དང་དངོས་གཞིའི་ཁྲིད་རིམ་མདོར་བསྡུས་ངེས་དོན་སྒྲོན་མེ་ཞེས་བྱ་བ་བཞུགས་སོ། །
  ""
  ```
  ```python
  target_text =  """༄༅། །ཕྱག་ཆེན་སྔོན་འགྲོ་བཞི་སྦྱོར་དང་དངོས་གཞིའི་ཁྲིད་རིམ་མདོར་བསྡུས་ངེས་དོན་སྒྲོན་མེ་ཞེས་བྱ་བ་བཞུགས་སོ། །
  མཛད་པ་པོ། འཇམ་མགོན་ཀོང་སྤྲུལ་བློ་གྲོས་མཐའ་ཡས། །
  ༄༅། །ཕྱག་ཆེན་སྔོན་འགྲོ་བཞི་སྦྱོར་དང་དངོས་གཞིའི་ཁྲིད་རིམ་མདོར་བསྡུས་ངེས་དོན་སྒྲོན་མེ་ཞེས་བྱ་བ་བཞུགས་སོ། །
  ༄༅། །གྲུབ་བརྒྱའི་སྤྱི་མེས་མར་མི་དྭགས་གསུམ་ནས། །དཔལ་ལྡན་དུས་གསུམ་མཁྱེན་པའི་བཀའ་བརྒྱུད་ནི།
  """
  ```
  ```python
  annotations = [['author_start', r"(\<[𰵀-󴉱]?au)"], ['author_end', r"(\>)"]]
  ```
  ```python
  result = transfer(src, annotations, trg, output="txt")

  Annotation transfer started...
  Mapping annotations to tofu-IDs
  [INFO] Computing diffs ...
  [INFO] Diff computed!
  Transfering annotations...
  ```
  ```python
  print(result)
  ༄༅། །ཕྱག་ཆེན་སྔོན་འགྲོ་བཞི་སྦྱོར་དང་དངོས་གཞིའི་ཁྲིད་རིམ་མདོར་བསྡུས་ངེས་དོན་སྒྲོན་མེ་ཞེས་བྱ་བ་བཞུགས་སོ། །
  <𰵀auམཛད་པ་པོ། འཇམ་མགོན་ཀོང་སྤྲུལ་བློ་གྲོས་མཐའ་ཡས། །>
  ༄༅། །ཕྱག་ཆེན་སྔོན་འགྲོ་བཞི་སྦྱོར་དང་དངོས་གཞིའི་ཁྲིད་རིམ་མདོར་བསྡུས་ངེས་དོན་སྒྲོན་མེ་ཞེས་བྱ་བ་བཞུགས་སོ། །
  ༄༅། །གྲུབ་བརྒྱའི་སྤྱི་མེས་མར་མི་དྭགས་གསུམ་ནས། །དཔལ་ལྡན་དུས་གསུམ་མཁྱེན་པའི་བཀའ་བརྒྱུད་ནི།


pkgId: e9ba9b6d6727cdbfeffc258842ec7cd90c8c0eb6dbac7861d4c8b8b2bb786cbf
name: python-anvil-parser
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: A Minecraft anvil file format parser
url: https://github.com/matcool/anvil-parser
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anvil-parser-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![CodeFactor](https://www.codefactor.io/repository/github/matcool/anvil-parser/badge/master)](https://www.codefactor.io/repository/github/matcool/anvil-parser/overview/master)
  [![Documentation Status](https://readthedocs.org/projects/anvil-parser/badge/?version=latest)](https://anvil-parser.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://travis-ci.org/matcool/anvil-parser.svg?branch=master)](https://travis-ci.org/matcool/anvil-parser)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/anvil-parser)](https://pypi.org/project/anvil-parser/)

  Simple parser for the [Minecraft anvil file format](https://minecraft.gamepedia.com/Anvil_file_format)

  This project is available on [PyPI](https://pypi.org/project/anvil-parser/) and can be installed with pip
  ```
  pip install anvil-parser
  ```
  or directly from github
  ```
  pip install git+https://github.com/matcool/anvil-parser.git
  ```


  ```python
  import anvil

  region = anvil.Region.from_file('r.0.0.mca')


  chunk = anvil.Chunk.from_region(region, 0, 0)



  block = chunk.get_block(0, 0, 0)

  print(block) # <Block(minecraft:air)>
  print(block.id) # air
  print(block.properties) # {}
  ```

  ```python
  import anvil
  from random import choice


  region = anvil.EmptyRegion(0, 0)


  stone = anvil.Block('minecraft', 'stone')
  dirt = anvil.Block('minecraft', 'dirt')


  for y in range(16):
      for z in range(16):
          for x in range(16):
              region.set_block(choice((stone, dirt)), x, y, z)


  region.save('r.0.0.mca')
  ```

  *things to do before 1.0.0*
  - [x] Proper documentation
  - [ ] Biomes
  - [x] CI
  - [ ] More tests
    - [ ] Tests for 20w17a+ BlockStates format

  Testing done in 1.14.4 and 1.15.2, should work fine for other versions.


pkgId: 825661264bab4b9870a87928f2aaca7fa8c1dce4d41425ddc66a8254f8ac2a60
name: python-anvil-uplink
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: The Anvil server uplink library
url: https://anvil.works
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anvil-uplink-0.5.1-1.src.rpm
checksum_type: sha256
description:
  Anvil Server Uplink Library


  This library allows you to write programs that communicate with Anvil apps (www.anvil.works).
  For more information, see: https://anvil.works/doc/#server_modules


pkgId: d85212eefa511ff146d614595c98a198b6f61bb6c44ebacc57256e08bf2b8c85
name: python-any-case
arch: src
version: 0.1.6
epoch: 0
release: 1
summary: Snake/Camel case converter with Django and Djnago REST framework integration
url: https://github.com/asduj/any_case
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-case-0.1.6-1.src.rpm
checksum_type: sha256
description:
  When developing a web application, you often have to choose the case format (snake_case/camelCase)
  will be used for the input and the output json data. If the backend is written in Python,
  the easiest option is to choose snake_case. On the one hand, this is good, because we have
  an obvious consistency, but on the other hand, the main consumers of the API (mobile and browser)
  prefer to use camelCase.
  If we care about our consumers, we will change the case format to camelCase. And it's good if we think
  about it in advance, before publishing API. But if this happens in an existing application,
  it becomes much more difficult to do so because there are consumers using the existing API.
  We have two options here:
  - introduce a new version of the api
  - send data in two cases at once
  The second option increases the size of the data, and the first option forces us to support two
  versions of the API without serious need. These options complicate the support and development of API.
  Things get a little more complicated when we have consumers who natively use snake_case,
  and using camelCase for them is not an option at all.
  As you can see, the use of one notation does not improve, but may worsen the situation.
  But why do we have to choose for the customer which case format they use?
  Why customers do not send and not receive data in the format, which would be more convenient to them?
  That's what this library is for. Consumers choose in what case they expect the data.
  If they specified an incorrect case or made a request without specifying a case,
  the data will be given as is.
  This approach allows existing consumers to work without changes with existing API, and for those
  consumers who want to use a single format, allows granular rewriting of the application.


pkgId: 08b88d649602e5c3ea90619bf1c01cb87899a427bc8eb27d3fbaefed79c49dbe
name: python-any-llm-client
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Add your description here
url: https://pypi.org/project/any-llm-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-llm-client-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A unified and lightweight asynchronous Python API for communicating with LLMs. It supports multiple providers, including OpenAI Chat Completions API (and any OpenAI-compatible API, such as Ollama and vLLM) and YandexGPT API.



  Before starting using any-llm-client, make sure you have it installed:

  ```sh
  uv add any-llm-client
  poetry add any-llm-client
  ```



  Here's a full example that uses Ollama and Qwen2.5-Coder:

  ```python
  import asyncio

  import httpx
  import pydantic

  import any_llm_client


  config = any_llm_client.OpenAIConfig(
      url=pydantic.HttpUrl("http://127.0.0.1:11434/v1/chat/completions"),
      model_name="qwen2.5-coder:1.5b",
  )


  async def main() -> None:
      async with httpx.AsyncClient() as httpx_client:
          response = await any_llm_client.get_client(config, httpx_client=httpx_client).request_llm_response(
              messages=[
                  any_llm_client.Message(role="system", text="Ты — опытный ассистент"),
                  any_llm_client.Message(role="user", text="Привет!"),
              ],
              temperature=0.1,
          )
          print(response)  # type(response) is str


  asyncio.run(main())
  ```

  To use `YandexGPT`, replace the config:

  ```python
  config = any_llm_client.YandexGPTConfig(
      auth_header=os.environ["YANDEX_AUTH_HEADER"],
      folder_id=os.environ["YANDEX_FOLDER_ID"],
      model_name="yandexgpt",
  )
  ```



  LLMs often take long time to respond fully. Here's an example of streaming API usage:

  ```python
  import asyncio
  import sys

  import httpx
  import pydantic

  import any_llm_client


  config = any_llm_client.OpenAIConfig(
      url=pydantic.HttpUrl("http://127.0.0.1:11434/v1/chat/completions"),
      model_name="qwen2.5-coder:1.5b",
  )


  async def main() -> None:
      async with (
          httpx.AsyncClient() as httpx_client,
          any_llm_client.get_client(config, httpx_client=httpx_client).stream_llm_partial_responses(
              messages=[
                  any_llm_client.Message(role="system", text="Ты — опытный ассистент"),
                  any_llm_client.Message(role="user", text="Привет!"),
              ],
              temperature=0.1,
          ) as partial_messages,
      ):
          async for one_message in partial_messages:  # type(one_message) is str
              sys.stdout.write(f"\r{one_message}")
              sys.stdout.flush()


  asyncio.run(main())
  ```

  Note that this will yield partial growing message, not message chunks, for example: "Hi", "Hi there!", "Hi there! How can I help you?".





  You can use a mock client for testing:

  ```python
  config = any_llm_client.MockLLMConfig(
      response_message=...,
      stream_messages=["Hi!"],
  )
  llm_client = any_llm_client.get_client(config, ...)
  ```



  ```python
  import os

  import pydantic_settings

  import any_llm_client


  class Settings(pydantic_settings.BaseSettings):
      llm_model: any_llm_client.AnyLLMConfig


  os.environ["LLM_MODEL"] = """{
      "api_type": "openai",
      "url": "http://127.0.0.1:11434/v1/chat/completions",
      "model_name": "qwen2.5-coder:1.5b"
  }"""
  settings = Settings()
  client = any_llm_client.get_client(settings.llm_model, ...)
  ```



  The recommended way to get LLM client is to call `any_llm_client.get_client()`. This way you can easily swap LLM models. If you prefer, you can use `any_llm_client.OpenAIClient` or `any_llm_client.YandexGPTClient` directly:

  ```python
  config = any_llm_client.OpenAIConfig(
      url=pydantic.HttpUrl("https://api.openai.com/v1/chat/completions"),
      auth_token=os.environ["OPENAI_API_KEY"],
      model_name="gpt-4o-mini",
  )
  llm_client = any_llm_client.OpenAIClient(config, ...)
  ```



  `any_llm_client.LLMClient.request_llm_response()` and `any_llm_client.LLMClient.stream_llm_partial_responses()` will raise `any_llm_client.LLMError` or `any_llm_client.OutOfTokensOrSymbolsError` when the LLM API responds with a failed HTTP status.



  By default, requests are retried 3 times on HTTP status errors. You can change the retry behaviour by supplying `request_retry` parameter:

  ```python
  llm_client = any_llm_client.get_client(..., request_retry=any_llm_client.RequestRetryConfig(attempts=5, ...))
  ```



  Configure timeouts or proxy directly in `httpx.AsyncClient()`:

  ```python
  import httpx

  import any_llm_client


  async with httpx.AsyncClient(
      proxies={
          "https://api.openai.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
      },
      timeout=httpx.Timeout(None, connect=5.0),
  ) as httpx_client:
      llm_client = any_llm_client.get_client(..., httpx_client=httpx_client)
  ```


pkgId: 5c804b2cb21a0ab453890512653e49884dfdb974d67e9aa5ae89ecc97e543fbc
name: python-any-llm-client
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Add your description here
url: https://pypi.org/project/any-llm-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-llm-client-1.3.0-1.src.rpm
checksum_type: sha256
description:
  A unified and lightweight asynchronous Python API for communicating with LLMs.

  Supports multiple providers, including OpenAI Chat Completions API (and any OpenAI-compatible API, such as Ollama and vLLM) and YandexGPT API.



  Before starting using any-llm-client, make sure you have it installed:

  ```sh
  uv add any-llm-client
  poetry add any-llm-client
  ```



  Here's a full example that uses Ollama and Qwen2.5-Coder:

  ```python
  import asyncio

  import any_llm_client


  config = any_llm_client.OpenAIConfig(url="http://127.0.0.1:11434/v1/chat/completions", model_name="qwen2.5-coder:1.5b")


  async def main() -> None:
      async with any_llm_client.get_client(config) as client:
          print(await client.request_llm_message("Кек, чо как вообще на нарах?"))


  asyncio.run(main())
  ```

  To use `YandexGPT`, replace the config:

  ```python
  config = any_llm_client.YandexGPTConfig(
      auth_header=os.environ["YANDEX_AUTH_HEADER"], folder_id=os.environ["YANDEX_FOLDER_ID"], model_name="yandexgpt"
  )
  ```



  LLMs often take long time to respond fully. Here's an example of streaming API usage:

  ```python
  import asyncio

  import any_llm_client


  config = any_llm_client.OpenAIConfig(url="http://127.0.0.1:11434/v1/chat/completions", model_name="qwen2.5-coder:1.5b")


  async def main() -> None:
      async with (
          any_llm_client.get_client(config) as client,
          client.stream_llm_partial_messages("Кек, чо как вообще на нарах?") as partial_messages,
      ):
          async for message in partial_messages:
              print("\033[2J")  # clear screen
              print(message)


  asyncio.run(main())
  ```

  Note that this will yield partial growing message, not message chunks, for example: "Hi", "Hi there!", "Hi there! How can I help you?".



  You can pass list of messages instead of `str` as the first argument, and set `temperature`:

  ```python
  async with (
      any_llm_client.get_client(config) as client,
      client.stream_llm_partial_messages(
          messages=[
              any_llm_client.SystemMessage("Ты — опытный ассистент"),
              any_llm_client.UserMessage("Кек, чо как вообще на нарах?"),
          ],
          temperature=1.0,
      ) as partial_messages,
  ):
      ...
  ```





  You can use a mock client for testing:

  ```python
  config = any_llm_client.MockLLMConfig(
      response_message=...,
      stream_messages=["Hi!"],
  )

  async with any_llm_client.get_client(config, ...) as client:
      ...
  ```





  Instead of passing credentials directly, you can set corresponding environment variables:

  - OpenAI: `ANY_LLM_CLIENT_OPENAI_AUTH_TOKEN`,
  - YandexGPT: `ANY_LLM_CLIENT_YANDEXGPT_AUTH_HEADER`, `ANY_LLM_CLIENT_YANDEXGPT_FOLDER_ID`.



  ```python
  import os

  import pydantic_settings

  import any_llm_client


  class Settings(pydantic_settings.BaseSettings):
      llm_model: any_llm_client.AnyLLMConfig


  os.environ["LLM_MODEL"] = """{
      "api_type": "openai",
      "url": "http://127.0.0.1:11434/v1/chat/completions",
      "model_name": "qwen2.5-coder:1.5b"
  }"""
  settings = Settings()

  async with any_llm_client.get_client(settings.llm_model, ...) as client:
      ...
  ```

  Combining with environment variables from previous section, you can keep LLM model configuration and secrets separate.



  The recommended way to get LLM client is to call `any_llm_client.get_client()`. This way you can easily swap LLM models. If you prefer, you can use `any_llm_client.OpenAIClient` or `any_llm_client.YandexGPTClient` directly:

  ```python
  config = any_llm_client.OpenAIConfig(
      url=pydantic.HttpUrl("https://api.openai.com/v1/chat/completions"),
      auth_token=os.environ["OPENAI_API_KEY"],
      model_name="gpt-4o-mini",
  )

  async with any_llm_client.OpenAIClient(config, ...) as client:
      ...
  ```



  `any_llm_client.LLMClient.request_llm_message()` and `any_llm_client.LLMClient.stream_llm_partial_messages()` will raise `any_llm_client.LLMError` or `any_llm_client.OutOfTokensOrSymbolsError` when the LLM API responds with a failed HTTP status.




  Pass custom [niquests](https://niquests.readthedocs.io) kwargs to `any_llm_client.get_client()`:

  ```python
  import urllib3

  import any_llm_client


  async with any_llm_client.get_client(
      ...,
      proxies={"https://api.openai.com": "http://localhost:8030"},
      timeout=urllib3.Timeout(total=10.0, connect=5.0),
  ) as client:
      ...
  ```

  Default timeout is `urllib3.Timeout(total=None, connect=5.0)`.



  By default, requests are retried 3 times on HTTP status errors. You can change the retry behaviour by supplying `request_retry` parameter:

  ```python
  async with any_llm_client.get_client(..., request_retry=any_llm_client.RequestRetryConfig(attempts=5, ...)) as client:
      ...
  ```



  ```python
  await client.request_llm_message("Кек, чо как вообще на нарах?", extra={"best_of": 3})
  ```


pkgId: 4d3cebe3eb6436aa8a7706c038bebc349289968acdbd0710a0043e1a7bf6998e
name: python-any-llm-client
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Add your description here
url: https://pypi.org/project/any-llm-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-llm-client-2.0.0-1.src.rpm
checksum_type: sha256
description:
  A unified and lightweight asynchronous Python API for communicating with LLMs.

  Supports multiple providers, including OpenAI Chat Completions API (and any OpenAI-compatible API, such as Ollama and vLLM) and YandexGPT API.



  Before starting using any-llm-client, make sure you have it installed:

  ```sh
  uv add any-llm-client
  poetry add any-llm-client
  ```



  Here's a full example that uses Ollama and Qwen2.5-Coder:

  ```python
  import asyncio

  import any_llm_client


  config = any_llm_client.OpenAIConfig(url="http://127.0.0.1:11434/v1/chat/completions", model_name="qwen2.5-coder:1.5b")


  async def main() -> None:
      async with any_llm_client.get_client(config) as client:
          print(await client.request_llm_message("Кек, чо как вообще на нарах?"))


  asyncio.run(main())
  ```

  To use `YandexGPT`, replace the config:

  ```python
  config = any_llm_client.YandexGPTConfig(
      auth_header=os.environ["YANDEX_AUTH_HEADER"], folder_id=os.environ["YANDEX_FOLDER_ID"], model_name="yandexgpt"
  )
  ```



  LLMs often take long time to respond fully. Here's an example of streaming API usage:

  ```python
  import asyncio

  import any_llm_client


  config = any_llm_client.OpenAIConfig(url="http://127.0.0.1:11434/v1/chat/completions", model_name="qwen2.5-coder:1.5b")


  async def main() -> None:
      async with (
          any_llm_client.get_client(config) as client,
          client.stream_llm_message_chunks("Кек, чо как вообще на нарах?") as message_chunks,
      ):
          async for chunk in message_chunks:
              print(chunk, end="", flush=True)


  asyncio.run(main())
  ```



  You can pass list of messages instead of `str` as the first argument, and set `temperature`:

  ```python
  async with (
      any_llm_client.get_client(config) as client,
      client.stream_llm_message_chunks(
          messages=[
              any_llm_client.SystemMessage("Ты — опытный ассистент"),
              any_llm_client.UserMessage("Кек, чо как вообще на нарах?"),
          ],
          temperature=1.0,
      ) as message_chunks,
  ):
      ...
  ```





  You can use a mock client for testing:

  ```python
  config = any_llm_client.MockLLMConfig(
      response_message=...,
      stream_messages=["Hi!"],
  )

  async with any_llm_client.get_client(config, ...) as client:
      ...
  ```





  Instead of passing credentials directly, you can set corresponding environment variables:

  - OpenAI: `ANY_LLM_CLIENT_OPENAI_AUTH_TOKEN`,
  - YandexGPT: `ANY_LLM_CLIENT_YANDEXGPT_AUTH_HEADER`, `ANY_LLM_CLIENT_YANDEXGPT_FOLDER_ID`.



  ```python
  import os

  import pydantic_settings

  import any_llm_client


  class Settings(pydantic_settings.BaseSettings):
      llm_model: any_llm_client.AnyLLMConfig


  os.environ["LLM_MODEL"] = """{
      "api_type": "openai",
      "url": "http://127.0.0.1:11434/v1/chat/completions",
      "model_name": "qwen2.5-coder:1.5b"
  }"""
  settings = Settings()

  async with any_llm_client.get_client(settings.llm_model, ...) as client:
      ...
  ```

  Combining with environment variables from previous section, you can keep LLM model configuration and secrets separate.



  The recommended way to get LLM client is to call `any_llm_client.get_client()`. This way you can easily swap LLM models. If you prefer, you can use `any_llm_client.OpenAIClient` or `any_llm_client.YandexGPTClient` directly:

  ```python
  config = any_llm_client.OpenAIConfig(
      url=pydantic.HttpUrl("https://api.openai.com/v1/chat/completions"),
      auth_token=os.environ["OPENAI_API_KEY"],
      model_name="gpt-4o-mini",
  )

  async with any_llm_client.OpenAIClient(config, ...) as client:
      ...
  ```



  `any_llm_client.LLMClient.request_llm_message()` and `any_llm_client.LLMClient.stream_llm_message_chunks()` will raise `any_llm_client.LLMError` or `any_llm_client.OutOfTokensOrSymbolsError` when the LLM API responds with a failed HTTP status.




  Pass custom [HTTPX](https://www.python-httpx.org) kwargs to `any_llm_client.get_client()`:

  ```python
  import httpx

  import any_llm_client


  async with any_llm_client.get_client(
      ...,
      mounts={"https://api.openai.com": httpx.AsyncHTTPTransport(proxy="http://localhost:8030")},
      timeout=httpx.Timeout(None, connect=5.0),
  ) as client:
      ...
  ```

  Default timeout is `httpx.Timeout(None, connect=5.0)` (5 seconds on connect, unlimited on read, write or pool).



  By default, requests are retried 3 times on HTTP status errors. You can change the retry behaviour by supplying `request_retry` parameter:

  ```python
  async with any_llm_client.get_client(..., request_retry=any_llm_client.RequestRetryConfig(attempts=5, ...)) as client:
      ...
  ```



  ```python
  await client.request_llm_message("Кек, чо как вообще на нарах?", extra={"best_of": 3})
  ```


pkgId: 45b3e914b037544294f6452161e91586d3e9a91f9cafe9e12c075b7d7c9a365c
name: python-any-parser
arch: src
version: 0.0.17
epoch: 0
release: 1
summary: Parser for all.
url: https://pypi.org/project/any-parser/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-parser-0.0.17-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://pypi.org/project/any-parser/"><img src="https://img.shields.io/pypi/v/any-parser.svg" alt="pypi_status" /></a>
    <a href="https://github.com/cambioml/any-parser/graphs/commit-activity"><img alt="Commit activity" src="https://img.shields.io/github/commit-activity/m/cambioml/any-parser?style=flat-square"/></a>
    <a href="https://join.slack.com/t/cambiomlworkspace/shared_invite/zt-1zes33rmt-20Rag043uvExUaUdvt5_xQ"><img src="https://badgen.net/badge/Join/Community/cyan?icon=slack" alt="Slack" /></a>
  </p>

  **AnyParser** provides an API to accurately extract unstructured data (e.g., PDFs, images, charts) into a structured format.



  To get started, generate your API key from the [Sandbox Account Page](https://www.cambioml.com/account). Each account comes with **100 free pages**.

  > ⚠️ **Note:** The free API is limited to 10 pages/call.

  For more information or to inquire about larger usage plans, feel free to contact us at info@cambioml.com.

  To set up your API key (`CAMBIO_API_KEY`), follow these steps:
  1. Create a `.env` file in the root directory of your project.
  2. Add the following line to the `.env` file:
  ```
  CAMBIO_API_KEY=0cam************************
  ```




  First, create and activate a new Conda environment, then install AnyParser:
  ```bash
  conda create -n any-parse python=3.10 -y
  conda activate any-parse
  pip3 install any-parser
  ```

  Use your API key to create an instance of AnyParser. Make sure you’ve set up your .env file to store your API key securely:
  ```python
  import os
  from dotenv import load_dotenv
  from any_parser import AnyParser


  load_dotenv(override=True)


  example_apikey = os.getenv("CAMBIO_API_KEY")


  ap = AnyParser(api_key=example_apikey)
  ```


  To extract data synchronously and receive immediate results:
  ```python

  markdown, total_time = ap.extract(file_path="./data/test.pdf")
  ```


  For asynchronous extraction, send the file for processing and fetch results later:
  ```python

  file_id = ap.async_extract(file_path="./data/test.pdf")


  markdown = ap.async_fetch(file_id=file_id)
  ```


  Check out these examples to see how you can utilize **AnyParser** to extract text, numbers, and symbols in fewer than 10 lines of code!


  Are you an AI engineer looking to **accurately** extract both the text and layout (e.g., table of contents or Markdown headers hierarchy) from a PDF? Check out this [3-minute notebook demo](https://github.com/CambioML/any-parser/blob/rt-migration/examples/pdf_to_markdown.ipynb).


  Are you a financial analyst needing to **accurately** extract numbers from a table within an image? Explore this [3-minute notebook example](https://github.com/CambioML/any-parser/blob/rt-migration/examples/image_to_markdown.ipynb).


pkgId: 8a20d21d163f23a8befa0ddf3263289f642d7406cfb40e62cdc9a9dc0189c0dd
name: python-any-parser
arch: src
version: 0.0.19
epoch: 0
release: 1
summary: Parser for all.
url: https://pypi.org/project/any-parser/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-parser-0.0.19-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://pypi.org/project/any-parser/"><img src="https://img.shields.io/pypi/v/any-parser.svg" alt="pypi_status" /></a>
    <a href="https://github.com/cambioml/any-parser/graphs/commit-activity"><img alt="Commit activity" src="https://img.shields.io/github/commit-activity/m/cambioml/any-parser?style=flat-square"/></a>
    <a href="https://join.slack.com/t/cambiomlworkspace/shared_invite/zt-1zes33rmt-20Rag043uvExUaUdvt5_xQ"><img src="https://badgen.net/badge/Join/Community/cyan?icon=slack" alt="Slack" /></a>
  </p>

  **AnyParser** provides an API to accurately extract unstructured data (e.g., PDFs, images, charts) into a structured format.



  To get started, generate your API key from the [Sandbox Account Page](https://www.cambioml.com/account). Each account comes with **100 free pages**.

  > ⚠️ **Note:** The free API is limited to 10 pages/call.

  For more information or to inquire about larger usage plans, feel free to contact us at info@cambioml.com.

  To set up your API key (`CAMBIO_API_KEY`), follow these steps:
  1. Create a `.env` file in the root directory of your project.
  2. Add the following line to the `.env` file:
  ```
  CAMBIO_API_KEY=0cam************************
  ```




  First, create and activate a new Conda environment, then install AnyParser:
  ```bash
  conda create -n any-parse python=3.10 -y
  conda activate any-parse
  pip3 install any-parser
  ```

  Use your API key to create an instance of AnyParser. Make sure you’ve set up your .env file to store your API key securely:
  ```python
  import os
  from dotenv import load_dotenv
  from any_parser import AnyParser


  load_dotenv(override=True)


  example_apikey = os.getenv("CAMBIO_API_KEY")


  ap = AnyParser(api_key=example_apikey)
  ```


  To extract data synchronously and receive immediate results:
  ```python

  markdown, total_time = ap.parse(file_path="./data/test.pdf")
  ```


  For asynchronous extraction, send the file for processing and fetch results later:
  ```python

  file_id = ap.async_parse(file_path="./data/test.pdf")


  markdown = ap.async_fetch(file_id=file_id)
  ```


  Check out these examples to see how you can utilize **AnyParser** to extract text, numbers, and symbols in fewer than 10 lines of code!


  Are you an AI engineer looking to **accurately** extract both the text and layout (e.g., table of contents or Markdown headers hierarchy) from a PDF? Check out this [3-minute notebook demo](https://github.com/CambioML/any-parser/blob/rt-migration/examples/pdf_to_markdown.ipynb).


  Are you a financial analyst needing to **accurately** extract numbers from a table within an image? Explore this [3-minute notebook example](https://github.com/CambioML/any-parser/blob/rt-migration/examples/image_to_markdown.ipynb).


pkgId: 3a52a606f5a497bc7d1c8210856c2fb57d92172a4a582a447a50273d9f516df5
name: python-any-parser-rt
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/any-parser-rt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-any-parser-rt-0.0.3-1.src.rpm
checksum_type: sha256
description:
  ```
  from any_parser_rt.any_parser_rt import AnyParserRT

  ap_rt = AnyParserRT(api_key="...")

  md_output, total_time = ap_rt.extract(file_path="./data/test.pdf")
  ```
  Check [example](example/example.ipynb)



  ```
  from any_parser_rt.any_parser_rt import AnyParserRT

  ap_rt = AnyParserRT(api_key="...")

  file_id = ap_rt.async_extract(file_path="./data/test.pdf")

  md = ap_rt.async_fetch(file_id=file_id)
  ```

  Check [example](example/async_example.ipynb)


pkgId: 2f664fb60945a1eaac023ec06b0d2f2e9dde057308c2b8ee708d1a955e303553
name: python-anyascii
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Unicode to ASCII transliteration
url: https://pypi.org/project/anyascii/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyascii-0.3.2-1.src.rpm
checksum_type: sha256
description:
  Unicode to ASCII transliteration

  [**Web Demo**](https://anyascii.com)

  Converts Unicode characters to their best ASCII representation

  AnyAscii provides ASCII-only replacement strings for practically all Unicode characters. Text is converted character-by-character without considering the context. The mappings for each script are based on popular existing romanization systems. Symbolic characters are converted based on their meaning or appearance. All ASCII characters in the input are left unchanged, every other character is replaced with printable ASCII characters. Unknown characters and some known characters are replaced with an empty string and removed.

  ```python
  from anyascii import anyascii

  s = anyascii('άνθρωποι')
  assert s == 'anthropoi'
  ```

  Python 3.3+ compatible

  `pip install anyascii`

  [**FULL README**](https://github.com/anyascii/anyascii)


pkgId: f7cebee1710055c69d9bd193e219f3f49d325e7b66cf5df5317b0994f9361bb5
name: python-anybadge
arch: src
version: 1.14.0
epoch: 0
release: 1
summary: Simple, flexible badge generator for project badges.
url: https://github.com/jongracecox/anybadge
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anybadge-1.14.0-1.src.rpm
checksum_type: sha256
description:
  Here are some usage specific command line examples that may save time on defining
  thresholds.
  Pylint::
  ```
  anybadge.py --value=2.22 --file=pylint.svg pylint
  anybadge.py --label=pylint --value=2.22 --file=pylint.svg 2=red 4=orange 8=yellow 10=green
  ```
  Coverage::
  ```
  anybadge.py --value=65 --file=coverage.svg coverage
  anybadge.py --label=coverage --value=65 --suffix='%' --file=coverage.svg 50=red 60=orange 80=yellow 100=green
  ```
  CI Pipeline::
  ```
  anybadge.py --label=pipeline --value=passing --file=pipeline.svg passing=green failing=red
  ```


pkgId: a3cbfdb8acaa06337cb7d90384b57156ea17c294cc41e65b6880e58850def904
name: python-anyblok_marshmallow
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: Add validator, serializer and deserializer to AnyBlok
url: https://anyblok-marshmallow.readthedocs.io/en/2.3.0
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyblok_marshmallow-2.3.0-1.src.rpm
checksum_type: sha256
description:
  Improve `AnyBlok <http://doc.anyblok.org>`_ to add validator, serializer and
  deserializer schema with `marshmallow <https://marshmallow.readthedocs.io/en/latest/>`_.
  This module is a wrapper of `marshmallow-sqlalchemy <https://marshmallow-sqlalchemy.readthedocs.io/en/latest/>`_,
  the goal is to give the SQLAlchemy Model build by AnyBlok to this librairy
  AnyBlok Marshmallow is released under the terms of the `Mozilla Public License`.
  See the `latest documentation <http://doc.anyblok-marshmallow.anyblok.org/>`_


pkgId: f72eefd1f5ec5030c88402df71b34c7181d32f4adb8f6679f399dc7a6412142f
name: python-anycache
arch: src
version: 2.2.0
epoch: 0
release: 1
summary: Cache any python object to file using improved pickling
url: https://pypi.org/project/anycache/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anycache-2.2.0-1.src.rpm
checksum_type: sha256
description:
  To install the `anycache` module run::
      pip install anycache
  If you do not have write-permissions to the python installation, try::
      pip install anycache --user


pkgId: 57b2e21e02ce74a7bc7f2a9988478338d67c3be09c98485ee7a8081e2d501c54
name: python-anycaptcha
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: All captcha solving services in one lib
url: https://github.com/alenkimov/anycaptcha
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anycaptcha-1.5.2-1.src.rpm
checksum_type: sha256
description:
  [![Telegram channel](https://img.shields.io/endpoint?url=https://runkit.io/damiankrawczyk/telegram-badge/branches/master?url=https://t.me/cum_insider)](https://t.me/cum_insider)
  [![PyPI version info](https://img.shields.io/pypi/v/anycaptcha.svg)](https://pypi.python.org/pypi/anycaptcha)
  [![PyPI supported Python versions](https://img.shields.io/pypi/pyversions/anycaptcha.svg)](https://pypi.python.org/pypi/anycaptcha)
  [![PyPI downloads per month](https://img.shields.io/pypi/dm/anycaptcha.svg)](https://pypi.python.org/pypi/anycaptcha)

  ```bash
  pip install anycaptcha
  ```

  anycaptcha is a unified Python API for CAPTCHA solving services.

  Special thanks to [unicaps](https://github.com/sergey-scat/unicaps) lib


  - A unified Python interface that is independent of the service used
  - Uses native service protocol/endpoints (eg, no needs in patching _hosts_ file)
  - Modern asynchronous client
  - Supports 10 types of CAPTCHAs
  - Written Pythonic way and is intended for humans
  - Supports proxies in any format thanks to [better-proxy](https://github.com/alenkimov/better_proxy)

  Supports 9 CAPTCHA solving services:
  - [2captcha.com](http://2captcha.com/?from=12016127)
  - [rucaptcha.com](https://rucaptcha.com?from=12016127)
  - [anti-captcha.com](https://getcaptchasolution.com/tmb2cervod)
  - [azcaptcha.com](https://azcaptcha.com)
  - [cap.guru](https://cap.guru/ru)
  - [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b)
  - [capsolver.com](https://dashboard.capsolver.com/passport/register?inviteCode=m-aE3NeBGZLU)
  - [capmonster.cloud](https://capmonster.cloud)
  - [multibot.in](https://multibot.in)


  ```python
  from pathlib import Path
  from anycaptcha import Solver, Service

  API_KEY = '<PLACE_YOUR_API_KEY_HERE>'


  async def main():
      async with Solver(Service.TWOCAPTCHA, API_KEY) as solver:
          solved = await solver.solve_image_captcha(
              Path("captcha.jpg"),
              is_phrase=False,
              is_case_sensitive=True
          )
          print(f'CAPTCHA text: {solved.solution.text}')
          await solved.report_good()
  ```



  | Service                                                                     | Image | Text | [reCAPTCHA v2](https://developers.google.com/recaptcha/docs/display) | [reCAPTCHA v3](https://developers.google.com/recaptcha/docs/v3) | [FunCaptcha](https://funcaptcha.com/fc/api/nojs/?pkey=69A21A01-CC7B-B9C6-0F9A-E7FA06677FFC) | [KeyCAPTCHA](https://www.keycaptcha.com/) | [Geetest](https://www.geetest.com/en/demo) | [Geetest v4](https://www.geetest.com/en/demo) | [hCaptcha](https://www.hcaptcha.com/) | [Capy](https://www.capy.me/) |
  |-----------------------------------------------------------------------------|:-----:|:----:|:--------------------------------------------------------------------:|:---------------------------------------------------------------:|:-------------------------------------------------------------------------------------------:|:-----------------------------------------:|:------------------------------------------:|:---------------------------------------------:|:-------------------------------------:|:----------------------------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |   ✅   |  ✅   |                                  ✅                                   |                                ✅                                |                                              ✅                                              |                     ✅                     |                     ✅                      |                       ✅                       |                   ✅                   |              ✅               |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |   ✅   |  ✅   |                                  ✅                                   |                                ✅                                |                                              ✅                                              |                     ✅                     |                     ✅                      |                       ✅                       |                   ✅                   |              ✅               |
  | [anti-captcha.com](https://getcaptchasolution.com/tmb2cervod)               |   ✅   |  ❌   |                                  ✅                                   |                                ✅                                |                                              ✅                                              |                     ❌                     |                     ✅                      |                       ✅                       |                   ✅                   |              ❌               |
  | [azcaptcha.com](https://azcaptcha.com)                                      |   ✅   |  ❌   |                                  ✅                                   |                                ✅                                |                                              ✅                                              |                     ❌                     |                     ❌                      |                       ❌                       |                   ✅                   |              ❌               |
  | [cap.guru](https://cap.guru/ru)                                             |   ✅   |  ❌   |                                  ✅                                   |                                ✅                                |                                              ❌                                              |                     ❌                     |                     ✅                      |                       ❌                       |                   ✅                   |              ❌               |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |   ✅   |  ❌   |                                  ✅                                   |                                ✅                                |                                              ✅                                              |                     ❌                     |                     ❌                      |                       ❌                       |                   ✅                   |              ❌               |



  | Service                                                                     | Regular | Case Sensitive | Phrase | Numbers only | Letters only | Math | Length |    Language    | Comment for worker |
  |-----------------------------------------------------------------------------|:-------:|:--------------:|:------:|:------------:|:------------:|:----:|:------:|:--------------:|:------------------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |       ✅        |   ✅    |      ✅       |      ✅       |  ✅   |   ✅    | Cyrillic/Latin |         ✅          |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |       ✅        |   ✅    |      ✅       |      ✅       |  ✅   |   ✅    | Cyrillic/Latin |         ✅          |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |       ✅        |   ✅    |      ✅       |      ✅       |  ✅   |   ✅    |     Latin      |         ✅          |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ✅    |       ❌        |   ❌    |      ❌       |      ❌       |  ❌   |   ❌    |     Latin      |         ✅          |
  | [cap.guru](https://cap.guru/ru)                                             |    ✅    |       ❌        |   ❌    |      ❌       |      ❌       |  ❌   |   ❌    |     Latin      |         ✅          |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ✅    |       ❌        |   ❌    |      ❌       |      ❌       |  ❌   |   ❌    |     Latin      |         ❌          |



  Text Captcha is a type of captcha that is represented as text and doesn't contain images.
  Usually you have to answer a question to pass the verification.
  For example: "If tomorrow is Saturday, what day is today?".

  | Service                                                                     |     Language     |
  |-----------------------------------------------------------------------------|:----------------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         | English, Russian |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        | English, Russian |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |        ❌         |
  | [azcaptcha.com](https://azcaptcha.com)                                      |        ❌         |
  | [cap.guru](https://cap.guru/ru)                                             |        ❌         |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |        ❌         |



  | Service                                                                     | Regular | Invisible | Enterprise | Google service<sup>1</sup> | Proxy<sup>2</sup> | Cookies<sup>3</sup> | User-Agent<sup>4</sup> |
  |-----------------------------------------------------------------------------|:-------:|:---------:|:----------:|:--------------------------:|:-----------------:|:-------------------:|:----------------------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |     ✅     |     ✅      |             ✅              |         ✅         |          ✅          |           ✅            |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |     ✅     |     ✅      |             ✅              |         ✅         |          ✅          |           ✅            |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |     ✅     |     ✅      |             ✅              |         ✅         |          ✅          |           ✅            |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ✅    |     ✅     |     ❌      |             ✅              |         ✅         |          ✅          |           ✅            |
  | [cap.guru](https://cap.guru/ru)                                             |    ✅    |     ✅     |     ❌      |             ✅              |         ✅         |          ✅          |           ✅            |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ✅    |     ✅     |     ❌      |             ✅              |         ✅         |          ❌          |           ❌            |

  <sup>1</sup> Support of solving reCAPTCHA on Google services (e.g. Google Search) </br>
  <sup>2</sup> Support of solving via proxy server </br>
  <sup>3</sup> Support of passing custom cookies </br>
  <sup>4</sup> Support of passing custom User-Agent header </br>



  | Service                                                                     | Regular | Enterprise | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:----------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |     ✅      |   ❌   |    ❌    |     ❌      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |     ✅      |   ❌   |    ❌    |     ❌      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |     ✅      |   ❌   |    ❌    |     ❌      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ✅    |     ❌      |   ✅   |    ❌    |     ❌      |
  | [cap.guru](https://cap.guru/ru)                                             |    ✅    |     ❌      |   ✅   |    ✅    |     ✅      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ✅    |     ❌      |   ✅   |    ❌    |     ❌      |



  | Service                                                                     | Regular | Data (BLOB) | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:-----------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |      ✅      |   ✅   |    ❌    |     ✅      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |      ✅      |   ✅   |    ❌    |     ✅      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |      ✅      |   ✅   |    ❌    |     ✅      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ✅    |      ✅      |   ✅   |    ❌    |     ✅      |
  | [cap.guru](https://cap.guru/ru)                                             |    ❌    |      ❌      |   ❌   |    ❌    |     ❌      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ✅    |      ❌      |   ✅   |    ❌    |     ❌      |



  | Service                                                                     | Regular | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |   ❌   |    ❌    |     ❌      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |   ❌   |    ❌    |     ❌      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ❌    |   ❌   |    ❌    |     ❌      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ❌    |   ❌   |    ❌    |     ❌      |
  | [cap.guru](https://cap.guru/ru)                                             |    ❌    |   ❌   |    ❌    |     ❌      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ❌    |   ❌   |    ❌    |     ❌      |



  | Service                                                                     | Regular | API server | GetLib | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:----------:|:------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |     ✅      |   ❌    |   ✅   |    ❌    |     ✅      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |     ✅      |   ❌    |   ✅   |    ❌    |     ✅      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |     ✅      |   ✅    |   ✅   |    ❌    |     ✅      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ❌    |     ❌      |   ❌    |   ❌   |    ❌    |     ❌      |
  | [cap.guru](https://captcha.guru/ru)                                         |    ✅    |     ❌      |   ❌    |   ✅   |    ❌    |     ❌      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ❌    |     ❌      |   ❌    |   ❌   |    ❌    |     ❌      |



  | Service                                                                     | Regular | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |   ✅   |    ❌    |     ✅      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |   ✅   |    ❌    |     ✅      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |   ✅   |    ❌    |     ✅      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ❌    |   ❌   |    ❌    |     ❌      |
  | [cap.guru](https://cap.guru/ru)                                             |    ❌    |   ❌   |    ❌    |     ❌      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ❌    |   ❌   |    ❌    |     ❌      |



  | Service                                                                     | Regular | Invisible | Custom Data | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:---------:|:-----------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |     ✅     |      ✅      |   ✅   |    ❌    |     ✅      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |     ✅     |      ✅      |   ✅   |    ❌    |     ✅      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ✅    |     ✅     |      ❌      |   ✅   |    ❌    |     ✅      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ✅    |     ❌     |      ❌      |   ✅   |    ❌    |     ❌      |
  | [cap.guru](https://cap.guru/ru)                                             |    ✅    |     ❌     |      ❌      |   ✅   |    ❌    |     ❌      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ✅    |     ❌     |      ❌      |   ✅   |    ❌    |     ❌      |



  | Service                                                                     | Regular | API server | Proxy | Cookies | User-Agent |
  |-----------------------------------------------------------------------------|:-------:|:----------:|:-----:|:-------:|:----------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |    ✅    |     ✅      |   ✅   |    ❌    |     ❌      |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |    ✅    |     ✅      |   ✅   |    ❌    |     ❌      |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |    ❌    |     ❌      |   ❌   |    ❌    |     ❌      |
  | [azcaptcha.com](https://azcaptcha.com)                                      |    ❌    |     ❌      |   ❌   |    ❌    |     ❌      |
  | [cap.guru](https://cap.guru/ru)                                             |    ❌    |     ❌      |   ❌   |    ❌    |     ❌      |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |    ❌    |     ❌      |   ❌   |    ❌    |     ❌      |



  | Service                                                                     | HTTP | HTTPS | SOCKS 4 | SOCKS 5 |
  |-----------------------------------------------------------------------------|:----:|:-----:|:-------:|:-------:|
  | [2captcha.com](http://2captcha.com/?from=12016127)	                         |  ✅   |   ✅   |    ✅    |    ✅    |
  | [rucaptcha.com](https://rucaptcha.com?from=12016127)                        |  ✅   |   ✅   |    ✅    |    ✅    |
  | [anti-captcha.com](http://getcaptchasolution.com/tmb2cervod)                |  ✅   |   ✅   |    ✅    |    ✅    |
  | [azcaptcha.com](https://azcaptcha.com)                                      |  ✅   |   ✅   |    ✅    |    ✅    |
  | [cap.guru](https://cap.guru/ru)                                             |  ✅   |   ✅   |    ✅    |    ✅    |
  | [deathbycaptcha.com](https://deathbycaptcha.com/register?refid=6184199718b) |  ✅   |   ❌   |    ❌    |    ❌    |





  <details>
  <summary>Get balance</summary>

  ```python
  from anycaptcha import Solver, Service


  async def main():
      async with Solver(Service.ANTI_CAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          balance = await solver.get_balance()
          ...
  ```

  </details>

  <details>
  <summary>Get service status (is the service is up?)</summary>

  ```python
  from anycaptcha import Solver, Service


  async def main():
      with Solver(Service.ANTI_CAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          status = await solver.get_status()
          ...
  ```

  </details>

  <details>
  <summary>Get technical details after solving</summary>

  ```python
  from anycaptcha import Solver, Service


  async def main():
      
      with Solver(Service.ANTI_CAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          solved = await solver.solve_...(...)

          
          cost = solved.cost

          
          cookies = solved.cookies

          
          await solved.report_good()

          
          await solved.report_bad()

          
          start_time = solved.start_time

          
          end_time = solved.end_time
  ```

  </details>



  <details>
  <summary>Solve Image CAPTCHA</summary>

  ```python
  from pathlib import Path

  from anycaptcha import Solver, Service
  from anycaptcha import CaptchaAlphabet
  from anycaptcha import CaptchaCharType


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_image_captcha(
              image=Path('captcha.jpg'),  # it can be a Path, file-object or bytes.
              char_type=CaptchaCharType.ALPHA,  # optional
              is_phrase=False,  # optional
              is_case_sensitive=True,  # optional
              is_math=False,  # optional
              min_len=4,  # optional
              max_len=6,  # optional
              alphabet=CaptchaAlphabet.LATIN,  # optional
              comment='Type RED letters only'  # optional
          )
          
          token = solved.solution.text
  ```

  </details>

  <details>
  <summary>Solve reCAPTCHA v2</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_recaptcha_v2(
              site_key=site_key,
              page_url=page_url,
              data_s='<data-s value>',  # optional
              api_domain='<"google.com" or "recaptcha.net">'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve reCAPTCHA v2 Invisible</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_recaptcha_v2(
              site_key=site_key,
              page_url=page_url,
              is_invisible=True,
              data_s='<data-s value>',  # optional
              api_domain='<"google.com" or "recaptcha.net">'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve reCAPTCHA v2 Enterprise</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...
  data_s = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_recaptcha_v2(
              site_key=site_key,
              page_url=page_url,
              is_enterprise=True,
              data_s=data_s,  # optional
              api_domain='<"google.com" or "recaptcha.net">'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve reCAPTCHA v3</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...
  action = ...
  min_score = 0.7


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_recaptcha_v3(
              site_key=site_key,
              page_url=page_url,
              action=action,  # optional
              min_score=min_score,  # optional
              api_domain='<"google.com" or "recaptcha.net">'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve reCAPTCHA v3 Enterprise</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...
  action = ...
  min_score = 0.7


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_recaptcha_v3(
              site_key=site_key,
              page_url=page_url,
              is_enterprise=True,
              action=action,  # optional
              min_score=min_score,  # optional
              api_domain='<"google.com" or "recaptcha.net">'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve hCaptcha</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_hcaptcha(
              site_key=site_key,
              page_url=page_url,
              api_domain='< "hcaptcha.com" or "js.hcaptcha.com" >'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve hCaptcha Invisible</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_hcaptcha(
              site_key=site_key,
              page_url=page_url,
              is_invisible=True,
              api_domain='< "hcaptcha.com" or "js.hcaptcha.com" >'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve FunCaptcha</summary>

  ```python
  from anycaptcha import Solver, Service


  public_key = ...
  page_url = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_funcaptcha(
              public_key=public_key,
              page_url=page_url,
              service_url='<value of surl parameter>',  # optional
              blob='<value of data[blob] parameter>'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve KeyCaptcha</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  user_id = ...
  session_id = ...
  ws_sign = ...
  ws_sign2 = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_keycaptcha(
              page_url=page_url,
              user_id=user_id,
              session_id=session_id,
              ws_sign=ws_sign,
              ws_sign2=ws_sign2
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve Geetest</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  gt_key = ...
  challenge = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_geetest(
              page_url=page_url,
              gt_key=gt_key,
              challenge=challenge,
              api_server='<value of api_server parameter>'  # optional
          )
          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Solve Geetest v4</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  captcha_id = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_geetest_v4(
              page_url=page_url,
              captcha_id=captcha_id
          )

          
          lot_number = solved.solution.lot_number
          pass_token = solved.solution.pass_token
          gen_time = solved.solution.gen_time
          captcha_output = solved.solution.captcha_output
  ```

  </details>

  <details>
  <summary>Solve Capy Puzzle</summary>

  ```python
  from anycaptcha import Solver, Service


  site_key = ...
  page_url = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_capy_puzzle(
              site_key=site_key,
              page_url=page_url,
              api_server='<for example "https://api.capy.me">',  # optional
              challenge_type='<"puzzle" or "avatar">'  # optional
          )

          
          captchakey = solved.solution.captchakey
          challengekey = solved.solution.challengekey
          answer = solved.solution.answer
  ```

  </details>

  <details>
  <summary>Solve a text CAPTCHA</summary>

  ```python
  from anycaptcha import Solver, Service
  from anycaptcha import CaptchaAlphabet
  from anycaptcha import WorkerLanguage


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_text_captcha(
              text='Si mañana es domingo, ¿qué día es hoy?',
              alphabet=CaptchaAlphabet.LATIN,  # optional
              language=WorkerLanguage.SPANISH  # optional
          )

          
          answer = solved.solution.text  # Sábado
  ```

  </details>



  <details>
  <summary>Catch exceptions</summary>

  ```python
  import anycaptcha
  from anycaptcha import Solver, Service


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          try:
              solved = solver.solve_recaptcha_v2(
                  site_key=site_key,
                  page_url=page_url,
              )
          except anycaptcha.AccessDeniedError:  # wrong API key or the current IP is banned
              pass
          except anycaptcha.LowBalanceError:  # low balance
              pass
          except anycaptcha.ServiceTooBusy:  # no available slots to solve CAPTCHA
              pass
          except anycaptcha.SolutionWaitTimeout:  # haven't received a solution within N minutes
              pass
          except anycaptcha.TooManyRequestsError:  # request limit exceeded
              pass
          except anycaptcha.BadInputDataError:  # bad CAPTCHA data (bad image, wrong URL, etc.)
              pass
          except anycaptcha.UnableToSolveError:  # CAPTCHA unsolvable
              pass
          except anycaptcha.ProxyError:  # bad proxy
              pass
          else:
              
              token = solved.solution.token
  ```

  </details>



  <details>
  <summary>Create a task and wait for the result</summary>

  ```python
  from anycaptcha import Solver, Service
  from anycaptcha.captcha import RecaptchaV2


  page_url = ...
  site_key = ...


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          task = solver.create_task(
              RecaptchaV2(site_key, page_url)
          )

          
          print(task.task_id)

          
          solved = task.wait()

          
          token = solved.solution.token
  ```

  </details>

  <details>
  <summary>Add proxy, cookies and User-Agent</summary>

  ```python
  from anycaptcha import Solver, Service


  page_url = ...
  site_key = ...
  proxy = 'http://user:password@domain.com:8080'  # any format
  user_agent = '<USER AGENT STRING>'
  cookies = {'name': 'value', ...}


  async def main():
      with Solver(Service.TWOCAPTCHA, "<PLACE YOUR API KEY HERE>") as solver:
          
          solved = solver.solve_recaptcha_v2(
              site_key=site_key,
              page_url=page_url,
              proxy=proxy,
              user_agent=user_agent,
              cookies=cookies
          )
          
          token = solved.solution.token
  ```

  </details>


pkgId: c6f02690bc85419729a866be83ec584d9b3ad755ed00bccfdcfb8dd781f96bb8
name: python-anyconfig
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Library provides common APIs to load and dump configuration files in various formats
url: https://github.com/ssato/python-anyconfig
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyconfig-0.14.0-1.src.rpm
checksum_type: sha256
description:
  python-anyconfig is a python library provides common APIs to load and dump
  configuration files in various formats with some useful features such as
  contents merge, templates, query, schema validation and generation support.

  - Home: https://github.com/ssato/python-anyconfig
  - Author: Satoru SATOH <satoru.satoh@gmail.com>
  - License: MIT


pkgId: a59fa5a86ee85eb61cec156fc3456be525f0148cf9a88cadf9483359813911e1
name: python-anycore-dbg-supplement
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: A bundle of auxiliary scripts for the Anycore project
url: https://github.com/s117/anycore-dbg-supplement.git
rpm_license: Other/Proprietary License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anycore-dbg-supplement-0.7.0-1.src.rpm
checksum_type: sha256
description:
  A new toolset to reliably packing, and spawning a RISC-V workload (app) for any simulation purpose.

  An app is packed into a `simenv`, which is basically the rootfs containing all the essentials for a simulation. The tool learns what are the essentials by analyzing the workload's syscall trace. When simulating with the proper PK/FESVR, the dynamic instruction stream is even reproducible.

  The motivation is to help Dr. Rotenberg's microarchitecture research group and ECE721 students using SPEC CPU2006 and CPU2017 workloads (usually checkpointed workloads) with ease.

  Run `atool-app-repo --help` to learn how to create a workload repository, and `atool-simenv --help` to learn how to use a workload repository.

  ```
  $ atool-app-repo --help
  Usage: atool-app-repo [OPTIONS] COMMAND [ARGS]...

    The app repository management utility

  Options:
    --help  Show this message and exit.

  Commands:
    addckpt     Import a checkpoint.
    addsysroot  Import a pristine sysroot.
    init        Create an empty app repository.
    learn       Analyze an app for how to create SimEnv.
    subrepo     Spawn a sub-repository with the selected apps.
  ```

  ```
  $ atool-simenv --help
  Usage: atool-simenv [OPTIONS] COMMAND [ARGS]...

    The simenv utility

  Options:
    --repo-path DIRECTORY  Override the SimEnv repository path given by the
                           environmental variable "ATOOL_SIMENV_REPO_PATH".

    --help                 Show this message and exit.

  Commands:
    list    List available apps and checkpoints in the SimEnv repository.
    mkgen   Generate a Makefile for a simenv, at current dir.
    spawn   Spawn a simenv.
    verify  Perform integrity checking for a simenv.
  ```

  \* If you are using bash/zsh/fish, you can:
  - run `eval "$(_ATOOL_SIMENV_COMPLETE=source_$(basename $SHELL) atool-simenv)"` to enable the auto completion for atool-simenv.
  - run `eval "$(_ATOOL_APP_REPO_COMPLETE=source_$(basename $SHELL) atool-app-repo)"` to enable the auto completion for atool-app-repo.



  - `SpecResultVerification/spike_trim.py` - Trim out the extra header/tail message produced by spike or pk during the simulation. Useful if you want to automatically verify the STDOUT output of a SPEC simulation.
  - `Checkpointing/ChkptDescFileGen/smpt2ckptdesc.py` - Convert the Simpoint output file to the checkpoint job description file accepted by Spike.
  - `Checkpointing/DumpHTIF/chkpt_htif_dump.py` - Show the HTIF syscalls recorded in a checkpoint file. When restoring a checkpoint, those syscalls will be executed in sequence to bring back the state of [HTIF FESVR](https://github.com/s117/riscv-fesvr).
  - `TetherSim/SimTetheringController.py` - Controller for [721sims](https://github.ncsu.edu/jli95/721sim/tree/trace_support) working in tethering mode.




  - `CpuTraceAnalysis/trace2google.py` - Analyze the trace dumped by [spike](https://github.com/s117/riscv-isa-sim/tree/WIB_trace_support) or [721sim](https://github.ncsu.edu/jli95/721sim/tree/trace_support) and output the result in Google's Trace Event Format.
  - To visualize the result, use [speedscope](https://github.com/jlfwong/speedscope) (recommend) or Chromium's *about://tracing* .
    - if `ignore_symbol.yaml` exists in CWD, it will be read to filter out the defined function calls. See `CpuTraceAnalysis/ignore_symbol.yaml` for an example.

  - `CpuTraceAnalysis/trace2tracevis.py` - Analyze and visualize the trace dumped by [spike](https://github.com/s117/riscv-isa-sim/tree/WIB_trace_support) or [721sim](https://github.ncsu.edu/jli95/721sim/tree/trace_support) in a homebrew timeline frontend (using [timeline-js](https://github.com/visjs/vis-timeline)).
    - if `ignore_symbol.yaml` exists in CWD - Will be read to filter out the defined function calls. See `CpuTraceAnalysis/ignore_symbol.yaml` for an example.
    - **It's recommended to use `trace2google.py`.** Because the trace_vis frontend uses timeline-js, which is not intended for visualizing tracing result, it can be very slow and unresponsive when working with trace with a large amount of event.

  ![image-20201105011703029](https://raw.githubusercontent.com/s117/anycore-dbg-supplement/master/README.assets/image-20201105011703029.png)

  <p align=center>Viewing the trace2google.py output with speedscope</p>

  ![image-20201105011839379](https://raw.githubusercontent.com/s117/anycore-dbg-supplement/master/README.assets/image-20201105011839379.png)

  <p align=center>Viewing the trace2google.py output with Chrome's about:tracing</p>

  ![image-20200813043919822](https://raw.githubusercontent.com/s117/anycore-dbg-supplement/master/README.assets/image-20200813043919822.png)

  <p align=center>Viewing the trace using homebrew TraceVis frontend (use timeline-js)</p>

  **WIP**.


pkgId: 5deab12ec7670c943bd9938723d582e6d8f645ed80b51851c5218e8d5e9db7a5
name: python-anyioutils
arch: src
version: 0.4.9
epoch: 0
release: 1
summary: Utility classes and functions for AnyIO
url: https://pypi.org/project/anyioutils/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyioutils-0.4.9-1.src.rpm
checksum_type: sha256
description:
  Utility classes and functions for AnyIO.



  `task = anyioutils.create_task(my_async_func(), task_group)` behaves the same as `task = asyncio.create_task(my_async_func())` except that an existing `task_group` has to be passed for the task to be launched in the background.

  You can also use `task = anyioutils.Task(my_async_func())` and then launch the `task` with `task_group.start_soon(task.wait)`, and/or await it with `result = await task.wait()`.

  ```py
  from anyioutils import CancelledError, Task, create_task
  from anyio import create_task_group, run, sleep

  async def foo():
      return 1

  async def bar():
      await sleep(float("inf"))

  async def main():
      async with create_task_group() as tg:
          task = Task(foo())
          assert await task.wait() == 1

      try:
          async with create_task_group() as tg:
              task = create_task(bar(), tg)
              await sleep(0.1)
              task.cancel()
      except BaseExceptionGroup as exc_group:
          assert len(exc_group.exceptions) == 1
          assert type(exc_group.exceptions[0]) == CancelledError

  run(main)
  ```



  `anyioutils.Future` behaves the same as `asyncio.Future` except that:
  - you cannot directly await an `anyioutils.Future` object, but through its `.wait()` method (unlike an `asyncio.Future`, but like an `asyncio.Event`),
  - cancelling an `anyioutils.Future` doesn't raise an `anyio.get_cancelled_exc_class()`, but an `anyioutils.CancelledError`.

  ```py
  from anyioutils import CancelledError, Future
  from anyio import create_task_group, run

  async def set_result(future):
      future.set_result("done")

  async def cancel(future):
      future.cancel()

  async def main():
      async with create_task_group() as tg:
          future0 = Future()
          tg.start_soon(set_result, future0)
          assert await future0.wait() == "done"

          future1 = Future()
          tg.start_soon(cancel, future1)
          try:
              await future1.wait()
          except CancelledError:
              assert future1.cancelled()

  run(main)
  ```



  `anyioutils.wait(aws, task_group)` behaves the same as `asyncio.wait(aws)` except that an existing `task_group` has to be passed.

  ```py
  from anyioutils import ALL_COMPLETED, Task, wait
  from anyio import create_task_group, run

  async def foo():
      return "foo"

  async def main():
      async with create_task_group() as tg:
          tasks = [Task(aw) for aw in (foo(), foo())]
          done, pending = await wait(tasks, tg, return_when=ALL_COMPLETED)
          assert done == set(tasks)
          assert not pending
          for task in done:
              assert task.result() == "foo"

  run(main)
  ```

rpm_license:
  Copyright (c) 2024 David Brochart  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: 3bfca5411832f6893d8cedd80b7eb54b24f2e9abc78beb70db1427352dedd61a
name: python-anylabeling
arch: src
version: 0.4.10
epoch: 0
release: 1
summary: Effortless data labeling with AI support
url: https://github.com/vietanhdev/anylabeling
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anylabeling-0.4.10-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img alt="AnyLabeling" style="width: 128px; max-width: 100%; height: auto;" src="https://user-images.githubusercontent.com/18329471/232250539-2b15b9ee-5593-41d0-ba22-e0442f314cce.png"/>
    <h1 align="center">🌟 AnyLabeling 🌟</h1>
    <p align="center">Effortless data labeling with AI support from <b>YOLO</b> and <b>Segment Anything</b>!</p>
    <p align="center"><b>AnyLabeling = LabelImg + Labelme + Improved UI + Auto-labeling</b></p>
  </p>

  ![](https://user-images.githubusercontent.com/18329471/234640541-a6a65fbc-d7a5-4ec3-9b65-55305b01a7aa.png)

  [![PyPI](https://img.shields.io/pypi/v/anylabeling)](https://pypi.org/project/anylabeling)
  [![license](https://img.shields.io/github/license/vietanhdev/anylabeling.svg)](https://github.com/vietanhdev/anylabeling/blob/master/LICENSE)
  [![open issues](https://isitmaintained.com/badge/open/vietanhdev/anylabeling.svg)](https://github.com/vietanhdev/anylabeling/issues)
  [![Pypi Downloads](https://pepy.tech/badge/anylabeling)](https://pypi.org/project/anylabeling/)
  [![Documentation](https://img.shields.io/badge/Read-Documentation-green)](https://anylabeling.nrl.ai/)
  [![Follow](https://img.shields.io/badge/+Follow-vietanhdev-blue)]([[https://anylabeling.nrl.ai/](https://twitter.com/vietanhdev)](https://twitter.com/vietanhdev))

  > +⭐ Follow [vietanhdev](https://twitter.com/vietanhdev) for project updates.

  <a href="https://youtu.be/5qVJiYNX5Kk">
    <img alt="AnyLabeling" src="https://raw.githubusercontent.com/vietanhdev/anylabeling/master/assets/screenshot.png"/>
  </a>

  **Auto Labeling with Segment Anything**

  <a href="https://youtu.be/5qVJiYNX5Kk">
    <img style="width: 800px; margin-left: auto; margin-right: auto; display: block;" alt="AnyLabeling-SegmentAnything" src="https://user-images.githubusercontent.com/18329471/236625792-07f01838-3f69-48b0-a12e-30bad27bd921.gif"/>
  </a>


  - **Youtube Demo:** [https://www.youtube.com/watch?v=5qVJiYNX5Kk](https://www.youtube.com/watch?v=5qVJiYNX5Kk)
  - **Documentation:** [https://anylabeling.nrl.ai](https://anylabeling.nrl.ai)

  **Features:**

  - [x] Image annotation for polygon, rectangle, circle, line and point.
  - [x] Auto-labeling YOLOv8, Segment Anything (SAM, SAM2).
  - [x] Text detection, recognition and KIE (Key Information Extraction) labeling.
  - [x] Multiple languages availables: English, Vietnamese, Chinese.





  - Download and run newest version from [Releases](https://github.com/vietanhdev/anylabeling/releases).
  - For MacOS:
    - After installing, go to Applications folder
    - Right click on the app and select Open
    - From the second time, you can open the app normally using Launchpad



  - Requirements: Python 3.10+. Recommended: Python 3.12.
  - Recommended: [Miniconda/Anaconda](https://docs.conda.io/en/latest/miniconda.html).

  - Create environment:

  ```bash
  conda create -n anylabeling python=3.12
  conda activate anylabeling
  ```

  - **(For macOS only)** Install PyQt5 using Conda:

  ```bash
  conda install -c conda-forge pyqt==5.15.9
  ```

  - Install anylabeling:

  ```bash
  pip install anylabeling # or pip install anylabeling-gpu for GPU support
  ```

  - Start labeling:

  ```bash
  anylabeling
  ```



  **Website:** [https://anylabeling.nrl.ai](https://anylabeling.nrl.ai)/



  | **Object Detection** | **Recognition** | **Facial Landmark Detection** | **2D Pose Estimation** |
  | :---: | :---: | :---: | :---: |
  | <img src='https://user-images.githubusercontent.com/72010077/273488633-fc31da5c-dfdd-434e-b5d0-874892807d95.png' height="126px" width="180px"> |  <img src='https://user-images.githubusercontent.com/72010077/277396071-79daec2c-6b0a-4d42-97cf-69fd098b3400.png' height="126px" width="180px"> |  <img src='https://user-images.githubusercontent.com/61035602/206095684-72f42233-c9c7-4bd8-9195-e34859bd08bf.jpg' height="126px" width="180px"> | <img src='https://user-images.githubusercontent.com/61035602/206100220-ab01d347-9ff9-4f17-9718-290ec14d4205.gif' height="126px" width="180px"> |
  |  **2D Lane Detection** | **OCR** | **Medical Imaging** | **Instance Segmentation** |
  | <img src='https://user-images.githubusercontent.com/72010077/273764641-65f456ed-27ce-4077-8fce-b30db093b988.jpg' height="126px" width="180px"> | <img src='https://user-images.githubusercontent.com/72010077/273421210-30d20e08-3b72-4f4d-8976-05b564e13d87.png' height="126px" width="180px"> | <img src='https://user-images.githubusercontent.com/72010077/273764318-e8b6a197-e733-478e-a210-e4386bafa1e4.png' height="126px" width="180px"> | <img src='https://user-images.githubusercontent.com/61035602/206095831-cc439557-1a23-4a99-b6b0-b6f2e97e8c57.jpg' height="126px" width="180px"> |
  |  **Image Tagging** | **Rotation** | **And more!** |
  | <img src='https://user-images.githubusercontent.com/72010077/277670825-8797ac7e-e593-45ea-be6a-65c3af17b12b.png' height="126px" width="180px"> | <img src='https://user-images.githubusercontent.com/72010077/277395955-aab54ea0-88f5-41af-ab0a-f4158a673f5e.png' height="126px" width="180px"> | Your applications here! |


  - Install packages:

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

  ```

  - Generate resources:

  ```bash
  pyrcc5 -o anylabeling/resources/resources.py anylabeling/resources/resources.qrc
  ```

  - Run app:

  ```bash
  python anylabeling/app.py
  ```



  - Install PyInstaller:

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

  - Build:

  ```bash
  bash build_executable.sh
  ```

  - Check the outputs in: `dist/`.



  If you want to contribute to **AnyLabeling**, please read [Contribution Guidelines](https://anylabeling.nrl.ai/docs/contribution).



  [![Star History Chart](https://api.star-history.com/svg?repos=vietanhdev/anylabeling&type=Date)](https://star-history.com/#vietanhdev/anylabeling&Date)



  - Labeling UI built with ideas and components from [LabelImg](https://github.com/heartexlabs/labelImg), [LabelMe](https://github.com/wkentaro/labelme).
  - Auto-labeling with [Segment Anything Models](https://segment-anything.com/), [MobileSAM](https://github.com/ChaoningZhang/MobileSAM).
  - Auto-labeling with [YOLOv8](https://github.com/ultralytics/ultralytics).


pkgId: 2d779153dcdeb87ed6d8d8f466f1968c483076900da2760354c790e9199c1cbb
name: python-anyleaf
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Driver for the Anyleaf pH sensor
url: https://anyleaf.org
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyleaf-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/anyleaf.svg)](https://python.org/pypi/anyleaf)




  [Homepage](https://anyleaf.org)


  To get started as quickly as possible on Raspberry Pi:
  - Activate I2C (pH and ORP module): Run `sudo raspi-config`. Select `Interfacing Options` â†’ `I2C` â†’ `Yes`.
  - Activate SPI (RTD temp module): Same as above, but select `SPI` instead of `I2C`.
  - Reboot

  Then run these commands from a terminal:
  - `sudo apt install python3-scipy`
  - `pip3 install anyleaf`
  - `git clone https://github.com/anyleaf/anyleaf-python.git`
  - `cd anyleaf-python/examples`
  - `python3 ph_orp.py`

  pH readings will display in your terminal.


  To install the `anyleaf` Python package, run `pip3 install anyleaf`, or
  `pip install anyleaf`, depending on how `pip` is set up on your operating system.


  ```python
  import time

  import board
  import busio
  from anyleaf import PhSensor, CalPt, CalSlot, OnBoard, OffBoard


  def main():
      i2c = busio.I2C(board.SCL, board.SDA)
      delay = 1  # Time between measurements, in seconds
      ph_sensor = PhSensor(i2c, delay)

      
      
      
      
      
      ph_sensor.calibrate_all(
          CalPt(0., 7., 25.), CalPt(0.17, 4., 25.)
      )

      
      
      
      
      
      

      
      

      while True:
          pH = ph_sensor.read(OnBoard())
          
          print(f"pH: {pH}")

          time.sleep(delay)


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


pkgId: 15b15c42d2346ec525689724305ddb6fecba82bf790229e42e0438adae7969aa
name: python-anymarkup
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Parse/serialize any markup format
url: https://github.com/bkabrda/anymarkup
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anymarkup-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Parse or serialize any markup. Currently supports ini, json, json5, toml, xml and yaml.
  Report bugs and new functionality requests at https://github.com/bkabrda/anymarkup/issues.
  Parsing::
    >>> import anymarkup
    >>> anymarkup.parse('foo: bar')
    {'foo': 'bar'}
    >>> anymarkup.parse_file('foo/bar.ini')
    {'section': {'subsection': {'opt2': 'bar'}, 'opt1': 'foo'}}
    $ cat foo/bar.ini
    [section]
    opt1=foo
    [[subsection]]
    opt2=bar
  Serializing::
    >>> import anymarkup
    >>> anymarkup.serialize({'foo': 'bar'}, 'json')
    b'{\n  "foo": "bar"\n}'
    >>> anymarkup.serialize_file({'foo': 'bar'}, 'foo/bar.json')
    $ cat foo/bar.json
    {
      "foo": "bar"
    }
  ``anymarkup`` is licensed under BSD license. You can download official releases
  from https://pypi.python.org/pypi/anymarkup or install them via ``pip install anymarkup``.
  ``anymarkup`` works with Python 2.7 and >= 3.3.


pkgId: 58ba8375a23da4d208913d4a4c7df7ff40d97df8107e87619c3fb5b70c535c64
name: python-anymarkup-core
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Core library for anymarkup
url: https://github.com/bkabrda/anymarkup-core
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anymarkup-core-0.8.1-1.src.rpm
checksum_type: sha256
description:
  This is the core library that implements functionality of https://github.com/bkabrda/anymarkup.
  You can install this if you only want to use a subset of anymarkup parsers. For example, you
  can do this::
    $ pip install anymarkup-core PyYAML
    $ python -c "import anymarkup_core; print(anymarkup_core.parse('foo: bar'))"
  in the same way you use anymarkup, except you have to import from `anymarkup_core`, obviously.


pkgId: 57ad876514da7899fddbd78d44138ab09a4e0697a337bb5d594c4f320a9edafa
name: python-anymotion-sdk
arch: src
version: 1.2.8
epoch: 0
release: 1
summary: AnyMotion SDK for Python
url: https://github.com/nttpc/anymotion-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anymotion-sdk-1.2.8-1.src.rpm
checksum_type: sha256
description:
  [![PyPi][pypi-version]][pypi] [![CircleCI][ci-status]][ci] [![codecov][codecov-status]][codecov]

  This is the Software Development Kit (SDK) for Python, which allows Python developers to write software that makes use of [AnyMotion](https://anymotion.nttpc.co.jp).
  It works on Python 3.6 or greater.



  Install using [pip](https://pip.pypa.io/en/stable/quickstart/):

  ```sh
  $ pip install anymotion-sdk
  ```

  If you want to use a [CV-based methods](#CV-based-methods):

  ```sh
  $ pip install anymotion-sdk[cv]
  ```



  To use AnyMotion Python SDK, you must first import it and tell it about your credentials which issued by the [AnyMotion Portal](https://portal.anymotion.jp/):

  ```py
  import anymotion_sdk


  client = anymotion_sdk.Client(client_id="your_client_id", client_secret="your_client_secret")
  ```

  You can also use environment variables:

  ```sh
  export ANYMOTION_CLIENT_ID=<your_client_id>
  export ANYMOTION_CLIENT_SECRET=<your_client_secret>
  ```

  ```py

  client = anymotion_sdk.Client()
  ```

  The following is how to upload an image and extract the keypoints:

  ```py

  upload_result = client.upload("image.jpg")


  keypoint_id = client.extract_keypoint(image_id=upload_result.image_id)
  extraction_result = client.wait_for_extraction(keypoint_id)


  keypoint = extraction_result.json
  ```

  You can get the uploaded data or the keypoint extracted data and so on as follows:

  ```py

  image = client.get_image(image_id)
  movie = client.get_movie(movie_id)
  keypoint = client.get_keypoint(keypoint_id)
  drawing = client.get_drawing(drawing_id)
  analysis = client.get_analysis(analysis_id)
  comparison = client.get_comparison(comparison_id)


  images = client.get_images()
  movies = client.get_movies()
  keypoints = client.get_keypoints()
  drawings = client.get_drawings()
  analyses = client.get_analyses()
  comparisons = client.get_comparisons()
  ```

  In `get_keypoint`, `get_drawing`, `get_analysis`, and `get_comparison`, you can use the `join_data` option to get the relevant data at the same time.

  ```py
  >>> client.get_keypoint(keypoint_id)
  {'id': 1, 'image': 2, 'movie': None, 'keypoint': [{'nose': [10, 20]}], 'execStatus': 'SUCCESS', 'failureDetail': None, 'createdAt': '2020-01-01T00:00:00.000000Z', 'updatedAt': '2020-01-01T00:00:00.000000Z'}

  >>> client.get_keypoint(keypoint_id, join_data=True)
  {'id': 1, 'image': {'id': 2, 'name': 'image', 'text': '', 'height': 100, 'width': 100, 'contentMd5': 'ecWkdCSrnBa9+EYREt/fbg==', 'createdAt': '2020-01-01T00:00:00.000000Z', 'updatedAt': '2020-01-01T00:00:00.000000Z'}, 'movie': None, 'keypoint': [{'nose': [10, 20]}], 'execStatus': 'SUCCESS', 'failureDetail': None, 'createdAt': '2020-01-01T00:00:00.000000Z', 'updatedAt': '2020-01-01T00:00:00.000000Z'}
  ```

  The way to output the log to stdout is as follows:

  ```py

  anymotion_sdk.set_stream_logger()



  anymotion_sdk.set_stream_logger(level=logging.DEBUG)
  ```

  For more examples, see [here](https://github.com/nttpc/anymotion-examples).



  If you install the extra package, `download_and_read` is available.
  `download_and_read` returns the downloaded image or video in numpy format.

  ```py
  data = client.download_and_read(drawing_id)
  ```

  **Warning**: Large videos use a lot of RAM.



  See [CHANGELOG.md](CHANGELOG.md).

  [pypi]: https://pypi.org/project/anymotion-sdk
  [pypi-version]: https://img.shields.io/pypi/v/anymotion-sdk
  [ci]: https://circleci.com/gh/nttpc/anymotion-python-sdk
  [ci-status]: https://circleci.com/gh/nttpc/anymotion-python-sdk/tree/master.svg?style=shield&circle-token=b9824650553efb30dabe07e3ab2b140ae2efa60c
  [codecov]: https://codecov.io/gh/nttpc/anymotion-python-sdk
  [codecov-status]: https://codecov.io/gh/nttpc/anymotion-python-sdk/branch/master/graph/badge.svg?token=5QG7KUBZ7K


pkgId: b85a0d77173fc13430f3114f760be2b01bad7e1b706da26c0feb7469a290e024
name: python-anynet
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Networking library based on anyio
url: https://github.com/kinnay/anynet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anynet-1.1.0-1.src.rpm
checksum_type: sha256
description:
  This is a simple asynchronous networking library that I'm using for hobby projects. It's based on anyio, so it can be used together with either asyncio or trio.


pkgId: aa8d091d55adcd6f44a5bd3936e9c157373d0cb96faf68bec281f4c26baa2029
name: python-anypay
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: Asynchronous AnyPay API wrapper
url: https://github.com/nikitalm8/anypay
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anypay-1.1.4-1.src.rpm
checksum_type: sha256
description:
  <div align="left">
      <h1>AnyPayAPI <img src="https://anypay.io/template/img/main/logo-start.svg" width=30 height=30></h1>
      <p align="left" >
          <a href="https://pypi.org/project/anypay/">
              <img src="https://img.shields.io/pypi/v/anypay?style=flat-square" alt="PyPI">
          </a>
          <a href="https://pypi.org/project/anypay/">
              <img src="https://img.shields.io/pypi/dm/anypay?style=flat-square" alt="PyPI">
          </a>
      </p>
  </div>

  A simple, yet powerful library for AnyPay [API](https://anypay.io/doc/api)




  With ``AnyPayAPI`` you can easily create and retrieve payment and payout info, get informaition about your account's balance and commissions, etc.



  Official docs can be found on the [API's webpage](https://anypay.io/doc/api)



  ```bash
  pip install anypay
  ```



   - ``Python 3.7+``
   - ``httpx``
   - ``pydantic``



   - ``Asynchronous``
   - ``Exception handling``
   - ``Pydantic return model``
   - ``LightWeight``



  ```python
  import asyncio

  from anypay import AnyPayAPI, AnyPayAPIError


  api = AnyPayAPI(
      'api_id', 'api_key', check=False,  # you can disable credentials check
  )


  async def main():

      try:

          await api.get_balance()

      except AnyPayAPIError as exc:

          print(exc)

      payments = await api.get_payments(project_id=1) # project_id can be provided in __init__
      print(payments[0].id, payments[0].status)

      bill = await api.create_payment(
          pay_id=1234,
          project_id=1,
          method='qiwi',
          email='test@mail.ru',
          amount=100,
          currency='RUB',
          description='Test payment',
      )
      print(bill.id, bill.url)

      bill = await api.create_bill( # easier way to create payment via SCI
          pay_id=1234,
          amount=100,
          project_id=1,
          project_secret='abcd',
      )
      print(bill.id, bill.url)

      
      print(api.balance)


  asyncio.run(main())
  ```

  Developed by Nikita Minaev (c) 2023


pkgId: e4795464599d20c22326a79729ee522493facee06849953abda54767a56b9bd7
name: python-anypytools
arch: src
version: 1.13.0
epoch: 0
release: 1
summary: Python tools and utilities for working with the AnyBody Modeling System
url: https://anybody-research-group.github.io/anypytools-docs/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anypytools-1.13.0-1.src.rpm
checksum_type: sha256
description:
  [![MIT License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![test](https://github.com/AnyBody-Research-Group/AnyPyTools/actions/workflows/test.yml/badge.svg)](https://github.com/AnyBody-Research-Group/AnyPyTools/actions/workflows/test.yml)
  [![](https://anaconda.org/conda-forge/anypytools/badges/downloads.svg)](https://anaconda.org/conda-forge/anypytools)
  [![](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
  [![JOSS paper](http://joss.theoj.org/papers/10.21105/joss.01108/status.svg)](https://doi.org/10.21105/joss.01108)

  AnyPyTools is a toolkit for working with the [AnyBody Modeling System (AMS)]
  from Python. It enables reproduceable research with the AnyBody Modeling System, and bridges the gap to whole ecosystem of open source scientific Python.

  The AnyPyTools Python package enables batch processing, parallization of model
  simulations, model sensitivity studies, and parameter studies, using either
  Monte-Carlo (random sampling) or Latin hypercube sampling. It makes reproducible
  research much easier and replaces the tedious process of manually automating the
  musculoskeletal simulations and aggregating the results.

  If you use the library for publications please **cite as:**

  > Lund et al., (2019). AnyPyTools: A Python package for reproducible research with the AnyBody Modeling System. Journal of Open Source Software, 4(33), 1108, <https://doi.org/10.21105/joss.01108>



  - Download and install the [Anaconda Python distribution]
  - After installation opens the Anaconda command prompt and type:

  ```bash
  conda config --add channels conda-forge
  conda install anypytools
  ```

  The library is also available on [PyPi](https://pypi.python.org/pypi/AnyPyTools) for installing using `pip`.




  The simplest case:

  ```python
  from anypytools import AnyPyProcess
  app = AnyPyProcess()
  macro = [
      'load "Model.main.any"',
      'operation Main.Study.InverseDynamics',
      'run',
  ]
  app.start_macro(macro)
  ```

  Please see the [Jupyter Notebook based tutorial], or check the the following for more information:

  - [AnyPyTools's Documentation](https://anybody-research-group.github.io/anypytools-docs)


  <img src="docs/_static/relax.png" alt="Don't panic" height="100px">


  [anaconda python distribution]: https://store.continuum.io/cshop/anaconda/
  [anybody modeling system (ams)]: http://www.anybodytech.com
  [jupyter notebook based tutorial]: http://nbviewer.jupyter.org/github/AnyBody-Research-Group/AnyPyTools/blob/master/docs/Tutorial/00_AnyPyTools_tutorial.ipynb

rpm_license:
  MIT License  Copyright (c) 2017 Morten Enemark Lund  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: aa4d2f83ca68cc5e56292db5776bf71e39fec432ecf63cc5d8c17d836f6c91fb
name: python-anyquote
arch: src
version: 0.3.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/anyquote/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyquote-0.3.11-1.src.rpm
checksum_type: sha256
description:
  a simple quote generator using python.



  ```python
  from PIL import Image

  from anyquote import quote
  from anyquote import quote_twitter

  img = Image.new("RGB", (128, 128))
  quote(user_name='hsn', user_avatar=img, context='Hello World', _time=datetime.now(), user_id='@hsn8086').show()

  quote_twitter("https://x.com/realDonaldTrump/status/1347555316863553542").show()
  ```



  ```bash
  pip install anyquote
  ```



  ```text
  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  We hope this program will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>.
  ```


pkgId: 4b54238bb13d3d813122a723b64cca954503ea13117c91158cdaea2ba8e2c5e8
name: python-anyrl
arch: src
version: 0.12.23
epoch: 0
release: 1
summary: A library for Reinforcement Learning
url: https://github.com/unixpickle/anyrl-py
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyrl-0.12.23-1.src.rpm
checksum_type: sha256
description:
  This is a Python remake (and makeover) of [anyrl](https://github.com/unixpickle/anyrl). It is a general-purpose library for Reinforcement Learning which aims to be as modular as possible.



  You can install anyrl with pip:

  ```
  pip install anyrl
  ```



  There are several different sub-modules in anyrl:

   * `models`: abstractions and concrete implementations of RL models. This includes actor-critic RNNs, MLPs, CNNs, etc. Takes care of sequence padding, BPTT, etc.
   * `envs`: APIs for dealing with environments, including wrappers and asynchronous environments.
   * `rollouts`: APIs for gathering and manipulating batches of episodes or partial episodes. Many RL algorithms include a "gather trajectories" step, and this sub-module fulfills that role.
   * `algos`: well-known learning algorithms like policy gradients or PPO. Also includes mini-algorithms like Generalized Advantage Estimation.
   * `spaces`: tools for using action and observation spaces. Includes parameterized probability distributions for implementing stochastic policies.



  Currently, most RL code out there is very restricted and not properly decoupled. In contrast, anyrl aims to be extremely modular and flexible. The goal is to decouple agents, learning algorithms, trajectories, and things like GAE.

  For example, anyrl decouples rollouts from the learning algorithm (when possible). This way, you can gather rollouts in several different ways and still feed the results into one learning algorithm. Further, and more obviously, you don't have to rewrite rollout code for every new RL algorithm you implement. However, algorithms like A3C and Evolution Strategies may have specific ways of performing rollouts that can't rely on the rollout API.



  This project relies on TensorFlow for models and training algorithms. However, anyrl APIs are framework-agnostic when possible. For example, the rollout API can be used with any policy, whether it's a TensorFlow neural network or a native-Python decision forest.



  I use `autopep8` and `flake8`. Here is the command you can use to run autopep8:

  ```
  autopep8 --recursive --in-place --max-line-length 100 .
  ```

  I recommend the following flag for flake8: `--max-line-length=100`


pkgId: b1cf22e23f5ca37afdcf55641a8bf4d564d67769ff77783c3896fac75c805fba
name: python-anys
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Matchers for pytest
url: https://github.com/jwodder/anys
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anys-0.3.0-1.src.rpm
checksum_type: sha256
description:
  ``anys`` requires Python 3.7 or higher.  Just use `pip <https://pip.pypa.io>`_
  for Python 3 (You have pip, right?) to install it::
      python3 -m pip install anys


pkgId: 76e891da3ced00862dd08593fc68930d2276f22bcb7199bac4b9fe0200f5aa03
name: python-anyscale
arch: src
version: 0.24.86
epoch: 0
release: 1
summary: Command Line Interface for Anyscale
url: https://pypi.org/project/anyscale/
rpm_license: AS License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyscale-0.24.86-1.src.rpm
checksum_type: sha256
description:
  This package contains the command line interface and the sdk for the Anyscale platform.

  View Anyscale docs [here](https://docs.anyscale.com)
  View CLI docs [here](https://docs.anyscale.com/reference/cli)
  View SDK docs [here](https://docs.anyscale.com/reference/python-sdk/api)


pkgId: b3d671a3d2a9509f438434045f69cf9692b46861bab614034284da20a1e0c422
name: python-anyserver
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Simple and generic python web server and utils
url: https://github.com/JohnnyBeProgramming/anyserver.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anyserver-0.3.4-1.src.rpm
checksum_type: sha256
description:
  Simple and generic python web server, designed with simplicity and extendability in mind.



  I really like the simplicity and elegance of frameworks like [`FastAPI`](https://fastapi.tiangolo.com/tutorial/first-steps/), [`Flask`](https://flask.palletsprojects.com/en/2.3.x/quickstart/#a-minimal-application), [`Express.js`](https://expressjs.com/en/starter/hello-world.html) and [`Koa.js`](https://koajs.com/#application).

  ```python

  app = FastAPI() # Or some other framework like flask

  @app.get("/")
  async def root():
      return {"message": "Hello World"}
  ```

  What I don't like, for very simple use cases, is the _boilerplate_ and dependencies.

  All of the above frameworks have some requirements and dependencies, meaning its not completely portable to all environments, without the need to download dependencies from the internet.

  At its core, this project was designed with the following features in mind:

  - Handle `HTTP` routes with a simple `request` - `response` model.
  - Support ways to serve static content from a folder (eg: HTML, CSS, JS).
  - A zero-dependency `server.py` that just works out of the box as a simple web server.
  - Supports multiple response types, with ability to render custom templated responses.

  With these basic requirements in place, rapid prototyping is possible with very little overhead.


pkgId: f9815b173ff346f0d4fe8a4c244e702f8a165599b5f79ddb39074b05ec1802d2
name: python-anystore
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Store and cache things anywhere
url: https://docs.investigraph.dev/lib/anystore
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anystore-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![anystore on pypi](https://img.shields.io/pypi/v/anystore)](https://pypi.org/project/anystore/)
  [![Python test and package](https://github.com/investigativedata/anystore/actions/workflows/python.yml/badge.svg)](https://github.com/investigativedata/anystore/actions/workflows/python.yml)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![Coverage Status](https://coveralls.io/repos/github/investigativedata/anystore/badge.svg?branch=main)](https://coveralls.io/github/investigativedata/anystore?branch=main)
  [![GPL-3.0 License](https://img.shields.io/pypi/l/anystore)](./LICENSE)



  Store anything anywhere. `anystore` provides a high-level storage and retrieval interface for various supported _store_ backends, such as `redis`, `sql`, `file`, `http`, cloud-storages and anything else supported by [`fsspec`](https://filesystem-spec.readthedocs.io/en/latest/index.html).

  Think of it as a `key -> value` store, and `anystore` acts as a cache backend. And when _keys_ become filenames and _values_ become byte blobs, `anystore` becomes actually a file-like storage backend – but always with the same and interchangeable interface.



  [In our several data engineering projects](https://investigativedata.io/projects) we always wrote boilerplate code that handles the featureset of `anystore` but not in a reusable way. This library shall be a stable foundation for data wrangling related python projects.





  ```shell
  anystore -i ./local/foo.txt -o s3://mybucket/other.txt

  echo "hello" | anystore -o sftp://user:password@host:/tmp/world.txt

  anystore -i https://investigativedata.io > index.html

  anystore --store sqlite:///db keys <prefix>

  anystore --store redis://localhost put foo "bar"

  anystore --store redis://localhost get foo  # -> "bar"
  ```


  ```python
  from anystore import smart_read, smart_write

  data = smart_read("s3://mybucket/data.txt")
  smart_write(".local/data", data)
  ```



  Use case: [`@anycache` is used for api view cache in `ftmq-api`](https://github.com/investigativedata/ftmq-api/blob/main/ftmq_api/views.py)

  ```python
  from anystore import get_store, anycache

  cache = get_store("redis://localhost")

  @anycache(store=cache, key_func=lambda q: f"api/list/{q.make_key()}", ttl=60)
  def get_list_view(q: Query) -> Response:
      result = ... # complex computing will be cached
      return result
  ```



  ```python
  from anystore import get_store

  source = get_store("https://example.org/documents/archive1")  # directory listing
  target = get_store("s3://mybucket/files", backend_config={"client_kwargs": {
      "aws_access_key_id": "my-key",
      "aws_secret_access_key": "***",
      "endpoint_url": "https://s3.local"
  }})  # can be configured via ENV as well

  for path in source.iterate_keys():
      
      with source.open(path) as i:
          with target.open(path, "wb") as o:
              i.write(o.read())
  ```



  Find the docs at [docs.investigraph.dev/lib/anystore](https://docs.investigraph.dev/lib/anystore)



  - [ftmq](https://github.com/investigativedata/ftmq), a query interface layer for [followthemoney](https://followthemoney.tech) data
  - [investigraph](https://github.com/investigativedata/investigraph),  a framework to manage collections of structured [followthemoney](https://followthemoney.tech) data
  - [ftmq-api](https://github.com/investigativedata/ftmq-api), a simple api on top off `ftmq` built with [FastApi](https://fastapi.tiangolo.com/)
  - [leakrfc](https://github.com/investigativedata/leakrfc), a library to crawl, sync and move around document collections (in progress)




  This package is using [poetry](https://python-poetry.org/) for packaging and dependencies management, so first [install it](https://python-poetry.org/docs/#installation).

  Clone this repository to a local destination.

  Within the repo directory, run

      poetry install --with dev

  This installs a few development dependencies, including [pre-commit](https://pre-commit.com/) which needs to be registered:

      poetry run pre-commit install

  Before creating a commit, this checks for correct code formatting (isort, black) and some other useful stuff (see: `.pre-commit-config.yaml`)



  `anystore` uses [pytest](https://docs.pytest.org/en/stable/) as the testing framework.

      make test


pkgId: 025a9bb2ff62934736ee6a0380906b0f1c4e1ab59b9ffbc07a8dd87c992e87de
name: python-anything
arch: src
version: 0.2.1
epoch: 0
release: 1
url: https://github.com/vilcans/anything
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anything-0.2.1-1.src.rpm
checksum_type: sha256
summary:
  Python constants that consider themselves equal to everything else. Useful for unit testing and more.

description:
  Defines the `Anything` and `Something` constants.
  `Anything` compares true with any other object::
      >>> Anything == 42
      True
      >>> 'hello' == Anything
      True
  You can use it to check that specific values in a data structure
  have a value, but it doesn't matter what they are,
  for example in a unit test::
      >>> [1, 2, 3] == [1, Anything, 3]
      True
      >>> {'x': 10, 'y': -3} == {'x': 10, 'y': Anything}
      True
      >>> {'x': 10} == {'x': 10, 'y': Anything}
      False
  Inequality behaves consistently with equality::
      >>> 'hello' != Anything
      False
  Even None is considered equal to Anything::
      >>> Anything == None
      True
  If you want to make sure that a value is not None, use `Something`
  instead::
      >>> Something == None
      False
      >>> Something == 1
      True
      >>> 1 == Something
      True
      >>> Something != None
      True
      >>> Something != 'foo'
      False
  `Something` only checks for None specifically, i.e. it does not accept any
  falsy value::
      >>> Something == False
      True
      >>> Something != False
      False
  Equality between the two constants works as you probably expect::
      >>> Anything == Anything
      True
      >>> Something == Something
      True
      >>> Anything == Something
      True
      >>> Something == Anything
      True


pkgId: 586cfc5ff68a29e74431dbd5d8e248def3b804ba5f7fa77069c1f0c6e548ad30
name: python-anything-world
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: Anything World API wrapper library and CLI
url: https://anything.world
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anything-world-0.1.8-1.src.rpm
checksum_type: sha256
description:
  Python library and CLI for Anything World API.

  To use this package you'll need to obtain a valid Anything World API key.
  Please, create an account in
  [our website](https://app.anything.world/register) and then visit
  [your profile page](https://app.anything.world/profile) to
  get access to your API key.

  Before sending your 3D models to be animated, please make sure to follow [our guidelines](https://anything-world.gitbook.io/anything-world/api/preparing-your-3d-model)
  on preparing your 3D model for success.

  To understand better the underlying web requests called by this
  Python package, please check our
  [API documentation](https://anything-world.gitbook.io/anything-world/api/rest-api-references).

  For more information of what changed between versions, please check the
  [CHANGELOG](./CHANGELOG.md) file.



  ```bash
  pip install anything-world
  ```



  First of all, create a new `.env` file with the right API key and URLs:

  ```bash
  AW_API_KEY=<YOUR API KEY>
  AW_API_URL=https://api.anything.world
  AW_POLLING_URL=https://api.anything.world/user-processed-model
  ```



  This library provides both synchronous and asynchronous implementations.
  The sync implementation is based on `requests` and tries to keep dependencies
  at minimum (i.e. no need to install `asyncio` nor `aiohttp`). However,
  if you use-case requires async calls, please follow the next section for its
  implementation.



  ```python
  from anything_world.sync_api import AWClient
  from dotenv import load_dotenv
  load_dotenv()


  client = AWClient()


  response = client.find('cats')


  response = client.animate(
      files_dir='./examples/cat',
      model_name='some_cat',
      model_type='cat',
      auto_rotate=True,
      is_symmetric=True
  )










  model_id = response["model_id"]



  model_data = client.get_animated_model(
      model_id=model_id,
      waiting_time=5,
      warmup_time=10,
      verbose=True
  )


  is_finished = client.is_animation_done(model_id)
  assert is_finished == True


  model_data = client.get_model(model_id)
  ```



  All `AWClient` methods are exposed as commands of the `anything` CLI tool.
  Just call the `anything` tool and it will display a manual page of the
  available commands:

  ```bash
  anything
  ```

  You can do exactly the same we did in Python before through the CLI:

  ```bash
  anything find "cat"
  anything animate ./examples/cat "some cat" --is_symmetric --auto_rotate
  anything get_animated_model <MODEL_ID> --verbose
  anything get_model <MODEL_ID>
  ```

  To know more about the parameters of a specific command, just run the
  command with no arguments to get a help message:

  ```bash
  anything find
  ```

  For more information about a command, please run the command with the `--help`
  suffix:

  ```bash
  anything find --help
  ```





  ```bash
  git clone git@github.com:anythingworld/anything-world-python.git
  cd anything-world-python
  python3 -m venv venv
  source venv/bin/activate
  pip install -e .
  ```



  ```bash
  pytest -v -s
  ```



  First bump the version in `pyproject.toml` and then:

  ```bash
  rm -rf dist/*
  python3 -m build
  python3 -m twine upload dist/* --username __token__ --password <password>
  ```



  This Python module has a MIT-style license, as found in the LICENSE file.

  The cat model in `examples/cat` folder is from Google Poly (CC-BY 4.0) license.

  The ASCII logo was generated by https://patorjk.com/software/taag/ using the
  original font fuzzy.flf by Juan Car (jc@juguete.quim.ucm.es).


pkgId: 69174dff05073616366b2f2e4bff8bce87f5004924383c9f2e4a6b16ab57702f
name: python-anything-world
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Anything World API wrapper library and CLI
url: https://anything.world
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anything-world-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Python library and CLI for Anything World API.

  To use this package you'll need to obtain a valid Anything World API key.
  Please, create an account in
  [our website](https://app.anything.world/register) and then visit
  [your profile page](https://app.anything.world/profile) to
  get access to your API key.

  Before sending your 3D models to be animated, please make sure to follow [our guidelines](https://anything-world.gitbook.io/anything-world/api/preparing-your-3d-model)
  on preparing your 3D model for success.

  To understand better the underlying web requests called by this
  Python package, please check our
  [API documentation](https://anything-world.gitbook.io/anything-world/api/rest-api-references).

  For more information of what changed between versions, please check the
  [CHANGELOG](./CHANGELOG.md) file.



  ```bash
  pip install anything-world
  ```



  First of all, create a new `.env` file with your Anything World API key:

  ```bash
  AW_API_KEY=<YOUR API KEY>
  ```



  This library provides both synchronous and asynchronous implementations.
  The sync implementation is based on `requests` and tries to keep dependencies
  at minimum (i.e. no need to install `asyncio` nor `aiohttp`). However,
  if you use-case requires async calls, please follow the next section for its
  implementation.





  ```python
  from anything_world.sync_api import AWClient
  from dotenv import load_dotenv
  load_dotenv()


  client = AWClient()


  response = client.find('cats')


  response = client.animate(
      files_dir='./examples/cat',
      model_name='some_cat',
      model_type='cat',
      auto_rotate=True,
      is_symmetric=True
  )


  response = client.animate(
      files_dir='./examples/cat',
      model_name='some_cat',
      auto_rotate=True,
      is_symmetric=True
  )


  model_id = response["model_id"]



  model_data = client.get_animated_model(
      model_id=model_id,
      waiting_time=5,
      warmup_time=10,
      verbose=True
  )


  is_finished = client.is_animation_done(model_id)
  assert is_finished == True


  model_data = client.get_model(model_id)
  ```



  You can also generate 3D models by providing a text prompt:

  ```python
  response = client.generate_from_text(
      prompt="cow using a helmet",
  )

  model_data = client.get_generated_model(
      model_id = response["model_id"]
  )
  ```

  Or by providing an image:

  ```python
  response = client.generate_from_image(
      file_path = "./examples/cowboy.jpg",
  )

  model_data = client.get_generated_model(
      model_id = response["model_id"]
  )
  ```



  Anything World is the only place where you can not only generate, but
  animate 3D models giving only a single text prompt:

  ```python
  response = client.generate_animated_from_text(
      prompt="cow using a helmet",
  )

  model_data = client.get_generated_model(
      model_id = response["model_id"]
  )
  ```

  Or by providing a single image:

  ```python
  response = client.generate_animated_from_image(
      file_path = "./examples/cowboy.jpg",
  )

  model_data = client.get_generated_model(
      model_id = response["model_id"]
  )
  ```



  All `AWClient` methods are exposed as commands of the `anything` CLI tool.
  Just call the `anything` tool and it will display a manual page of the
  available commands:

  ```bash
  anything
  ```

  You can do exactly the same we did in Python before through the CLI:

  ```bash
  anything find "cat"
  anything animate ./examples/cat "some cat" --is_symmetric --auto_rotate
  anything get_animated_model <MODEL_ID> --verbose
  anything get_model <MODEL_ID>

  anything generate_from_text "cow with a helmet"
  anything generate_from_image ./examples/cowboy.jpg "a cowboy"
  anything get_generated_model <MODEL_ID>

  anything generate_animated_from_text "soldier"
  anything generate_animated_from_image ./examples/cowboy.jpg "a cowboy"
  ```

  To know more about the parameters of a specific command, just run the
  command with no arguments to get a help message:

  ```bash
  anything find
  ```

  For more information about a command, please run the command with the `--help`
  suffix:

  ```bash
  anything find --help
  ```





  ```bash
  git clone git@github.com:anythingworld/anything-world-python.git
  cd anything-world-python
  python3 -m venv venv
  source venv/bin/activate
  pip install -e .
  ```



  ```bash
  pytest -v -s
  ```



  First bump the version in `pyproject.toml` and then:

  ```bash
  rm -rf dist/*
  python3 -m build
  python3 -m twine upload dist/* --username __token__ --password <password>
  ```



  This Python module has a MIT-style license, as found in the LICENSE file.

  The cat model in `examples/cat` folder is from Google Poly (CC-BY 4.0) license.

  The ASCII logo was generated by https://patorjk.com/software/taag/ using the
  original font fuzzy.flf by Juan Car (jc@juguete.quim.ucm.es).


pkgId: 06031886d657840565e82b7cd8763438c0268bdb965f7fd9b797b05aaa13874d
name: python-anywebscraper
arch: src
version: 0.1.3
epoch: 0
release: 1
url: https://github.com/pierjosvins/anywebscraper
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-anywebscraper-0.1.3-1.src.rpm
checksum_type: sha256
summary:
  anywebscraper is your ultimate web data extraction companion. We understand the challenges of web scraping, including dealing with anti-bot measures and the need for reliable proxies. We make web scraping easy and effective, even in the most challenging environments. Whether you're a data scientist, business analyst or developer looking to harness the power of web data, anywebscraper has you covered.

description:
  Have you ever tried to access data from a number of sites only to be blocked? The solution is often to use proxies, which may or may not work. Don't worry, **anywebscraper** is the solution to these problems.

  **anywebscraper** is your ultimate web data extraction companion. We understand the challenges of web scraping, including dealing with anti-bot measures and the need for reliable proxies. Our library is designed to make web scraping easy and effective, even in the most challenging environments. Whether you're a data scientist, business analyst, or developer looking to harness the power of web data, **anywebscraper** has you covered.

  We benchmarked our solution against websites such as https://www.g2.com and https://www.investing.com. The results are quite satisfactory, we have successfully web-scraped all the data without any problems.


  * **No Proxy Integration**: Say goodbye to IP bans and blocked access. **anywebscraper** does not integrate with proxies but ensures uninterrupted data retrieval.

  * **Universal Compatibility**: Our library can scrape data from virtually any type of website, including e-commerce platforms, social media networks, news sites, and more.

  * **Customisable and Scalable**: If you're familiar with BeautifulSoup, bingo! **anywebscraper** returns a BeautifulSoup-like object and is highly customizable to meet your specific scraping needs.

  * **Reliable Support**: Count on our dedicated support team to assist you with any questions or issues you encounter.


  ```bash
  pip install anywebscraper
  ```

  ```python
  from anywebscraper import AnyWebScraper


  webscraper = AnyWebScraper()


  url="your-website URL" # i.e url = "https://google.com"
  soup = webscraper.webScrape(url=url) # Returns 'BeautifulSoup' object
  soup.find("your-html-element", class_="your-class")
  ```
  Note that all BeautifulSoup methods can be applied to soup that our library returns: ```.prettify(), .find(), .find_all(), .get_text(), etc.```


  Let's try to collect historical bitcoin data from https://www.investing.com using the classic method, as shown in this image:

  ![Bitcoin Historical Data](images/bitcoin-data.png)

  To do that, we can use Python code below:
  ```python
  from urllib.request import urlopen
  url = "https://www.investing.com/crypto/bitcoin"
  page = urlopen(url)
  html_bytes = page.read()
  html = html_bytes.decode("utf-8")
  print(html)
  ```
  An error is displayed stating that it is forbidden to request this link, as shown in this image.
  ![Error from Classical Method](images/error-bitcoin.png)

  Now let's use **anywebscraper** to see the difference.
  ```python
  from anywebscraper import AnyWebScraper

  url = "https://www.investing.com/crypto/bitcoin"
  web_scraper = AnyWebScraper()

  html = web_scraper.webScrape(url=url)
  print(html.prettify())
  ```
  ![AnyWebScraper Method](images/anywebscraper.png)

  We can see that there is no forbidden error and that our library returns data from this link. Now all we need to do is collect the relevant data, as we do with BeautifulSoup, using the appropriate methods.


  Pull requests are welcome. For significant changes, please open an issue first to discuss what you want to change.


pkgId: 00d2f60d1eb392fd1213fa20237e8debdc9914f08af9f0c427936b98798f862a
name: python-ao3statscraper
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Scrape stats from your AO3 stats page.
url: https://gitlab.com/athenaslilowl1/AO3StatScraper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ao3statscraper-0.1.9-1.src.rpm
checksum_type: sha256
description:
  `AO3StatScraper` is a small python package that provides command line scripts to
  fetch your AO3 (*Archive Of Our Own*) statistics to store and display them.



  `AO3StatScraper` is available on
  [PyPI](https://pypi.org/project/ao3statscraper/), and can obtained any regular
  way you'd install a python package, e.g. using `pip`, `conda`, etc.

  For example, using `pip`:

  On Unix/OSX:

  ```
  python3 -m pip install ao3statscraper
  ```

  On Windows:

  ```
  py -m pip install ao3statscraper
  ```


  Alternately, the source code is available on
  [gitlab](https://gitlab.com/athenaslilowl1/AO3StatScraper).
  you can install a local version by cloning the repository using git.
  On OSX and Linux, you can use:

  ```
  git clone https://gitlab.com/athenaslilowl1/AO3StatScraper.git    # get you the git repository
  cd AO3StatScraper                                                 # go into the directory
  python3 -m pip install .                                          # install package
  ```







  `AO3StatScraper` simply downloads your AO3 stats page (pretty much the same as
  opening it in your browser and hitting `Save this page...`) and then extract the
  stats from that html content. To be able to access your stats, you need to log
  in to AO3, which is why `AO3StatScraper` will ask you for your username and
  password.


  By default `AO3StatScraper` (i.e. the script `ao3get`) will store your current
  stats as a snapshot. This includes both your total user statistics as well as
  your individual work statistics. The data is written in
  the csv (Comma Separated Values) format, so plenty of other software and
  packages should be able to read it in easily. Your total user statistics are
  stored in a separate file from your work statistics.





  The main use case for `AO3StatScraper` is to fetch and display your current AO3
  statistics using scripts provided by `AO3StatScraper`. Currently, there are 5
  scripts:

  - `ao3get` : The main script to fetch and display your AO3 stats.
  - `ao3plot`: Plots the stats stored with `ao3get`.
  - `ao3diff`: Show the difference in stats compared to an earlier date.
  - `ao3_hits_to_kudos`: List all your works in ascending order of their
    hits/kudos ratio
  - `ao3_purge`: Deletes saved stats such that there is a minumum time between the
    remaining ones

  The scripts are discussed in more detail further below.


  **IMPORTANT**: Before you can run the other scripts, you first need to configure
  `AO3StatScraper`. This is done by calling `ao3get`. It will launch the
  configuration dialogue automatically if it hasn't been configured yet. You can
  always re-configure it by invoking `ao3get -c`.






  This is the main script to fetch and store your AO3 stats. There are several
  running modes. When in doubt, invoke `ao3get --help` to see the available
  options.

  The default running mode is `--diff`.

  - `--all`: Fetch and store current stats from AO3 into a snapshot, and display
    stats for all works.
  - `--repeat`: Don't fetch new stats, but show the changes between the last two
    stored stats snapshots.
  - `--diff`: Fetch and store current stats from AO3 into a snapshot, and display
    only stats for works that have changed since the last snapshot. If there were
    no changes in work stats, it will display only the user's total stats.
  - `--config`: Run the configuration dialogue and exit.
  - `--remove-last`: Deletes the last snapshot `ao3get` stored and exits. May come
    in handy if you're nervously re-downloading your stats every minute.
  - `--no-write`: This flag modifies the behavious for `--all` and `--diff`
    running modes. While current stats are fetched from AO3, they won't be written
    into a snapshot.

  The list above does not cover all the available options. Please use
  `ao3get --help` to see all the available options.

  Using `ao3get` requires you to log in to your AO3 account. You can either type
  in your username and password each time you invoke it, or you can store it with
  `AO3StatScraper`, locked behind a master password. There are no restrictions on
  how sophisticated your master password needs to be, so if you can't be
  inconvenienced, you can even leave it empty. Alternately, you can opt out of
  using a master password at all, although this is not encouraged. But it would
  allow you to e.g. set up an automated way to fetch your stats at regular times.




  `ao3plot` will display some simple graphs based on the stored snapshots. It
  never stores snapshots itself, you will need to do that using `ao3get`.

  By default, `ao3plot` will ask you to select which work you would like to see
  graphs of stats for. You can also select to plot your total user statistics.

  Alternately, you can skip that dialogue by using the following flags:

  - `-u`: Show total user statistics.
  - `-i [ID]`: Show the statistics for the work with AO3 ID `[ID]`. For example,
    if your work is under the link `https://archiveofourown.org/works/24280306`,
    the ID would be `24280306`.
  - `<number>`: Show the statistics for the work with index `<number>`, where the
    index refers to the number of the work as shown in the selection dialogue
    when running `ao3plot` without any command line arguments.

  It is possible that the stats graphs aren't displayed nicely on all screens. If
  that is the case for you, you may want to try the `--no-prettify` flag to obtain
  a bare-bones plot without any prettifications. It may not look as nice, but at
  least you should be able to see the data.

  Finally, you can also try the `--diff` option to also display the difference
  in stats over time. By default, it shows the weekly differences between the
  stats.





  Fetch (but do not store) your AO3 stats and compare them to stats from the past.
  It never stores snapshots itself, you will need to do that using `ao3get`.
  By default, it will compare to your stats from a week ago, but you can also
  select a day, a week, a month, or a year back using the `-d`, `-w`, `-m`, or `-y`
  flag, respectively. Alternately, you can specify a date in the `YYYY-MM-DD`
  format.





  This script just reads in the last stored snapshot and prints out all your works
  in ascending order of their hits/kudos ratio.





  In case you find yourself in a situation where you feel you have stored way too
  many snapshots, `ao3_purge` offers you the option to delete stats snapshots such
  that there is some minimal time between them. By default, this frequency is set
  to 12h. You can provide the frequency you like using the `--frequency` flag.






  This is example output what `ao3get` will show you when you run it:

  ![default running mode, diff](webdata/ao3get-diff.png)

  It will only list the works that have changes since you last cheked (i.e. stored
  a snapshot).

  But you can also view all your works:

  ![show all works](webdata/ao3get-all.png)


  Plotting the total user statistics with `ao3plot` will show you something like
  this:

  ![plotting user stats](webdata/plot-user.png)


  Running `ao3plot` for a specific work will give you 2 plots:

  ![plotting work, Figure 1](webdata/plot-work1.png)
  ![plotting work, Figure 2](webdata/plot-work2.png)







  Please let me know by raising an issue on
  [gitlab](https://gitlab.com/athenaslilowl1/AO3StatScraper/-/issues).

  I'm using unix exclusively, so there may be issues on other operating systems.
  Testers and devs on OSX and windows are also very welcome to let me know what's
  working and what needs fixing.






  Help and contributions to maintain and extend this tool are very welcome!

  Some ideas what might be added in the future include
  - Writing/reading of file formats other than csv.
  - Maybe add a GUI for CLI-averse users. This tool was always intended to be a
    command line tool on my end. Having never programmed a GUI in my life, I don't
    intend to start now. However, if anybody is willing to pack this up in a nice
    simple portable GUI, you are very welcome and encouraged to do so! I'll gladly
    add it to the repository.

  I'm using unix exclusively, so there may be issues on other operating systems.
  Testers and devs on OSX and windows are also very welcome to let me know what's
  working and what needs fixing.





  Parts of the AO3 fetching mechanism is lifted from the [AO3 API
  package](https://github.com/ArmindoFlores/ao3_api).

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) 2024  Lars Ikarion  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) 2024  Lars Ikarion This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: de274b4c32490652c855fb23aef02a371547219d9da9118baa66d31e6a2f9923
name: python-ao3statscraper
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Scrape stats from your AO3 stats page.
url: https://gitlab.com/athenaslilowl1/AO3StatScraper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ao3statscraper-0.2.2-1.src.rpm
checksum_type: sha256
description:
  `AO3StatScraper` is a small python package that provides command line scripts to
  fetch your AO3 (*Archive Of Our Own*) statistics to store and display them.



  `AO3StatScraper` is available on
  [PyPI](https://pypi.org/project/ao3statscraper/), and can obtained any regular
  way you'd install a python package, e.g. using `pip`, `conda`, etc.

  For example, using `pip`:

  On Unix/OSX:

  ```
  python3 -m pip install ao3statscraper
  ```

  On Windows (make sure you [install Python first](https://www.python.org/downloads/windows/)),
  you can do the same in the `command prompt`:

  ```
  py -m pip install ao3statscraper
  ```


  Alternately, the source code is available on
  [gitlab](https://gitlab.com/athenaslilowl1/AO3StatScraper).
  you can install a local version by cloning the repository using git.
  On OSX and Linux, you can use:

  ```
  git clone https://gitlab.com/athenaslilowl1/AO3StatScraper.git    # get the git repository
  cd AO3StatScraper                                                 # go into the directory
  python3 -m pip install .                                          # install package
  ```


  On Windows (make sure you [install Python](https://www.python.org/downloads/windows/) and
  [git](https://git-scm.com/downloads) first), the equivalent steps are:

  ```
  git clone https://gitlab.com/athenaslilowl1/AO3StatScraper.git
  cd AO3StatScraper
  py -m pip install .
  ```











  - Run the `ao3get` command to display the differences to the last time you stored
  your stats with AO3StatScraper.
  - When running for the very first time, use `ao3get --all` instead.
  - Run `ao3plot` to plot the results.





  `AO3StatScraper` simply downloads your AO3 stats page (pretty much the same as
  opening it in your browser and hitting `Save this page...`) and then extract the
  stats from that html content. To be able to access your stats, you need to log
  in to AO3, which is why `AO3StatScraper` will ask you for your username and
  password.


  By default `AO3StatScraper` (i.e. the script `ao3get`) will store your current
  stats as a snapshot. This includes both your total user statistics as well as
  your individual work statistics. The data is written in
  the csv (Comma Separated Values) format, so plenty of other software and
  packages should be able to read it in easily. Your total user statistics are
  stored in a separate file from your work statistics.





  The main use case for `AO3StatScraper` is to fetch and display your current AO3
  statistics using scripts provided by `AO3StatScraper`. Currently, there are 5
  scripts:

  - `ao3get` : The main script to fetch and display your AO3 stats.
  - `ao3plot`: Plots the stats stored with `ao3get`.
  - `ao3diff`: Show the difference in stats compared to an earlier date.
  - `ao3_hits_to_kudos`: List all your works in ascending order of their
    hits/kudos ratio
  - `ao3_purge`: Deletes saved stats such that there is a minumum time between the
    remaining ones

  The scripts are discussed in more detail further below.


  **IMPORTANT**: Before you can run the other scripts, you first need to configure
  `AO3StatScraper`. This is done by calling `ao3get`. It will launch the
  configuration dialogue automatically if it hasn't been configured yet. You can
  always re-configure it by invoking `ao3get -c`.

  **IMPORTANT**: By default, `ao3get` will try and display the difference in your
  stats. This can't be done if there are no previous stats stored. For that reason,
  the very first time you call `ao3get`, use `ao3get --all` instead.







  This is the main script to fetch and store your AO3 stats. There are several
  running modes. When in doubt, invoke `ao3get --help` to see the available
  options.

  The default running mode is `--diff`.

  - `--all`: Fetch and store current stats from AO3 into a snapshot, and display
    stats for all works.
  - `--repeat`: Don't fetch new stats, but show the changes between the last two
    stored stats snapshots.
  - `--diff`: Fetch and store current stats from AO3 into a snapshot, and display
    only stats for works that have changed since the last snapshot. If there were
    no changes in work stats, it will display only the user's total stats.
  - `--config`: Run the configuration dialogue and exit.
  - `--remove-last`: Deletes the last snapshot `ao3get` stored and exits. May come
    in handy if you're nervously re-downloading your stats every minute.
  - `--no-write`: This flag modifies the behaviour for `--all` and `--diff`
    running modes. While current stats are fetched from AO3, they won't be written
    into a snapshot.

  The list above does not cover all the available options. Please use
  `ao3get --help` to see all the available options.

  Using `ao3get` requires you to log in to your AO3 account. You can either type
  in your username and password each time you invoke it, or you can store it with
  `AO3StatScraper`, locked behind a master password. There are no restrictions on
  how sophisticated your master password needs to be, so if you can't be
  inconvenienced, you can even leave it empty. Alternately, you can opt out of
  using a master password at all, although this is not encouraged. But it would
  allow you to e.g. set up an automated way to fetch your stats at regular times.




  `ao3plot` will display some simple graphs based on the stored snapshots. It
  never stores snapshots itself, you will need to do that using `ao3get`.

  By default, `ao3plot` will ask you to select which work you would like to see
  graphs of stats for. You can also select to plot your total user statistics.

  Alternately, you can skip that dialogue by using the following flags:

  - `-u`: Show total user statistics.
  - `-i [ID]`: Show the statistics for the work with AO3 ID `[ID]`. For example,
    if your work is under the link `https://archiveofourown.org/works/24280306`,
    the ID would be `24280306`.
  - `<number>`: Show the statistics for the work with index `<number>`, where the
    index refers to the number of the work as shown in the selection dialogue
    when running `ao3plot` without any command line arguments.

  It is possible that the stats graphs aren't displayed nicely on all screens. If
  that is the case for you, you may want to try the `--no-prettify` flag to obtain
  a bare-bones plot without any prettifications. It may not look as nice, but at
  least you should be able to see the data.

  Finally, you can also try the `--diff` option to additinally display the *difference*
  in stats over time in the plot as opposed to their actual value. By default, it
  shows the weekly differences between the stats.





  Fetch (but do not store) your AO3 stats and compare them to stats from the past.
  It never stores snapshots itself, you will need to do that using `ao3get`.
  By default, it will compare to your stats from a week ago, but you can also
  select a day, a week, a month, or a year back using the `-d`, `-w`, `-m`, or `-y`
  flag, respectively. Alternately, you can specify a date in the `YYYY-MM-DD`
  format.





  This script just reads in the last stored snapshot and prints out all your works
  in ascending order of their hits/kudos ratio.





  In case you find yourself in a situation where you feel you have stored way too
  many snapshots, `ao3_purge` offers you the option to delete stats snapshots such
  that there is some minimal time between them. By default, this frequency is set
  to 12h. You can provide the frequency you like using the `--frequency` flag.






  This is example output what `ao3get` will show you when you run it:

  ![default running mode, diff](webdata/ao3get-diff.png)

  It will only list the works that have changes since you last cheked (i.e. stored
  a snapshot).

  But you can also view all your works:

  ![show all works](webdata/ao3get-all.png)


  Plotting the total user statistics with `ao3plot` will show you something like
  this:

  ![plotting user stats](webdata/plot-user.png)


  Running `ao3plot` for a specific work will give you 2 plots:

  ![plotting work, Figure 1](webdata/plot-work1.png)
  ![plotting work, Figure 2](webdata/plot-work2.png)







  Please let me know by raising an issue on
  [gitlab](https://gitlab.com/athenaslilowl1/AO3StatScraper/-/issues) or reach out
  to me on twitter/bluesky on @athenaslilowl.

  I'm using unix exclusively, so there may be issues on other operating systems.
  Testers and devs on OSX and windows are also very welcome to let me know what's
  working and what needs fixing.








  ```
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "C:\Users\USER\testVenv\Lib\site-packages\matplotlib\__init__.py", line 263, in <module>
      _check_versions()
    File "C:\Users\USER\testVenv\Lib\site-packages\matplotlib\__init__.py", line 257, in _check_versions
      module = importlib.import_module(modname)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    File "C:\Users\USER\AppData\Local\Programs\Python\Python312\Lib\importlib\__init__.py", line 90, in import_module
      return _bootstrap._gcd_import(name[level:], package, level)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    File "C:\Users\USER\testVenv\Lib\site-packages\kiwisolver\__init__.py", line 8, in <module>
      from ._cext import (
  ImportError: DLL load failed while importing _cext: The specified module could not be found.
  ```


  The error appears to be related to the matplotlib installation. Try installing
  `msvc-runtime` **system wide, i.e. outside of a virtual environment**:


  ```
  py -m pip install msvc-runtime
  ```







  Help and contributions to maintain and extend this tool are very welcome!

  Some ideas what might be added in the future include
  - Writing/reading of file formats other than csv.
  - Maybe add a GUI for CLI-averse users. This tool was always intended to be a
    command line tool on my end. Having never programmed a GUI in my life, I don't
    intend to start now. However, if anybody is willing to pack this up in a nice
    simple portable GUI, you are very welcome and encouraged to do so! I'll gladly
    add it to the repository.

  I'm using unix exclusively, so there may be issues on other operating systems.
  Testers and devs on OSX and windows are also very welcome to let me know what's
  working and what needs fixing.





  Parts of the AO3 fetching mechanism is lifted from the [AO3 API
  package](https://github.com/ArmindoFlores/ao3_api).

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) 2024  Lars Ikarion  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) 2024  Lars Ikarion This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: ef6e1531f44033fd9be7be52d89b9cd4b8bdc4c6b10e0f550f7af4c5d2dc5c3e
name: python-aoc-helper
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: A helper package for Advent of Code
url: https://github.com/Starwort/aoc_helper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoc-helper-1.10.0-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  @salt-die's aoc_helper package, rewritten from the ground up



  This project aims to be compliant with the [Advent of Code Automation Guidelines](https://www.reddit.com/r/adventofcode/wiki/faqs/automation). Here are the strategies it uses:

  - Once inputs are downloaded, they are cached in `~/.config/aoc_helper/YEAR/DAY.in` (or a similar path for Windows users) - [`interface.fetch`](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L97-L155) (lines [107-108](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L107-L108), [152](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L152))
  - The `User-Agent` header declares the package name, version, and my contact info - [`data.HEADERS`](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/data.py#L20-L25), [used](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L118) [in](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L139) [every](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L210) [outbound](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L266) [request](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L341)
  - If requesting input before the puzzle unlocks, [the library will wait for unlock before sending any requests](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L130-L133) (except on day 1, where it will send a request to validate the session token)
  - If sending an answer too soon after an incorrect one, [the library will wait the cooldown specified in the response](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L231-L234) (sending only one extra request; it *is* however possible for a user to send multiple requests in quick succession, by repeatedly calling `submit` before the cooldown is over)
  - Advent of Code will not be queried at all [if the puzzle has already been solved](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L182-L190) or [if an answer has already been submitted](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/interface.py#L193-L199)
  - If, for some reason, the user decides they wish to clear their cache (for example, if they believe their input to be corrupted) they can do so by using the [`aoc clean`](https://github.com/Starwort/aoc_helper/blob/master/aoc_helper/main.py#L91-L121) command.



  Install `aoc_helper` with `pip`!

  ```bash
  pip install aoc_helper

  pip install aoc_helper[cli]

  pip install aoc_helper[fancy]

  pip install aoc_helper[cli,fancy]

  pip install aoc_helper[full]
  ```



  When you first use any function that interfaces with Advent of Code, you will be prompted to enter your session token.

  Your session token is stored as a *HTTPOnly cookie*. This means there is no way of extracting it with JavaScript, you either must
  use a browser extension such as [EditThisCookie](http://www.editthiscookie.com/), or follow [this guide](https://github.com/wimglenn/advent-of-code-wim/issues/1)

  This token is stored in `~/.config/aoc_helper/token.txt` (`C:\Users\YOUR_USERNAME\.config\aoc_helper\token.txt` on Windows,
  probably), and other `aoc_helper` data is stored in this folder (such as your input and submission caches).

  If, for whatever reason, you feel the need to clear your caches, you can do so by deleting the relevant folders in `aoc_helper`'s
  configuration folder.



  `aoc_helper` has a command line interface, accessed by running `python -m aoc_helper` or `aoc` followed by the command line arguments. Its commands are detailed below:



  `aoc fetch <DAY> [--year <YEAR>]`

  Fetch your input for a given day.
  YEAR is the current year by default.

  Examples (written during 2020):

  ```bash
  aoc fetch 2 # fetches input for 2020 day 2
  aoc fetch 24 --year 2019 # fetches input for 2019 day 24
  ```



  `aoc submit <DAY> <PART> <ANSWER> [--year <YEAR>]`

  Submits your answer for a given day and part.
  YEAR is the current year by default.

  Examples (written during 2020):

  ```bash
  aoc submit 2 1 643 # submits 643 as the answer for 2020 day 2 part 1
  aoc submit 24 1 12531574 --year 2019 # submits 12531574 as the answer for 2019 day 2 part 1
  ```



  `aoc template <DAYS> [--year YEAR]`

  Generates templates for your advent of code folder.
  YEAR is the current year by default.

  `DAYS` must be a comma-separated list of date ranges, which may be one of:

  - `all`, to generate a template for every day in the year
  - A single integer in the range \[1, 25] to generate a single template
  - A pair of integers in the range \[1, 25], separated with a hyphen, to generate template for each day in the range

  Note that even if a day is included in the list of days more than once (including implicitly, within ranges or `all`), it will only be generated once.

  Filenames are formatted as `day_NUMBER.py` where `NUMBER` is the 2-digit day number.

  Examples (written during 2020):

  ```bash
  aoc template all # generates day_01.py to day_25.py, with aoc_helper methods referencing 2020, in the current folder
  aoc template 3 --year 2019 # generates day_03.py, with aoc_helper methods referencing 2019, in the current folder
  aoc template 3-5 --year 2017 # generates day_03.py to day_05.py, with aoc_helper methods referencing 2017, in the current folder
  aoc template 3-5,7,9,9-10 # generates files for days 3, 4, 5, 7, 9, and 10
  ```


pkgId: 9cbe525f2dad2b7d262913317b5168bacb825cdda98a76d2591b35bb581dc348
name: python-aoc-lube
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Proper Advent of Code lubricant.
url: https://pypi.org/project/aoc-lube/
rpm_license: Unlicense
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoc-lube-1.2.0-1.src.rpm
checksum_type: sha256
description:
  * `pip install aoc-lube` for just `fetch` and `submit` functions or `pip install aoc-lube[utils]` for optional dependencies (networkx, numpy) for utility functions.
  * Save your user token to `~/.aoc_lube/.token`.
  * [Optional] Create a new directory for your solutions. In this directory, run the function `aoc_lube.setup_dir()` or from the command line, `python -m aoc_lube [-y YEAR] [-t TEMPLATE]`. (If no year is given, the current year will be used.)


pkgId: 3f44ad13e2702861f76679cf29f26bbefb377724c4308502a47e40ae79cefd8e
name: python-aoc-mod
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A library for Advent of Code containing utilities to use while solving problems!
url: https://pypi.org/project/aoc-mod/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoc-mod-0.1.5-1.src.rpm
checksum_type: sha256
description:
  A library for Advent of Code containing utilities to use while solving problems! If any issues or bugs are discovered, please submit an issue and I'll fix it!



  To install, simply run the following command.

  ```sh
  pip install aoc-mod
  ```

  AOC Mod can be used interactively from the command line or as a library to import into your Advent of Code challenge solutions with Python.

  You may follow the sections below to either utilize the command-line utility or see this example for using the library programmatically.

  ```py
  from aoc_mod.utilites import AOCMod

  aoc_mod = AOCMod()

  puzz_input = aoc_mod.get_puzzle_input({YEAR}, {DAY})
  instructions = aoc_mod.get_puzzle_instructions({YEAR}, {DAY})

  sol = do_the_solution_p1()

  aoc_mod.submit_answer({YEAR}, {DAY}, 1, sol)
  ```




  To grab puzzle instructions and input or submit an answer, you'll need the to store session ID from your login to Advent of Code as an environment variable.

  ```sh
  export SESSION_ID=cbef2304aaa12390fbc7absc3892
  ```



  ```sh
  usage: aoc-mod [-h] [--debug] {setup,submit} ...

  positional arguments:
    {setup,submit}
      setup         Initiate the setup of the files for AoC.
      submit        Initiate a submission of the answer for an AoC problem.

  options:
    -h, --help      show this help message and exit
    --debug         Enable debug print statements.
  ```



  ```sh
  usage: aoc-mod setup [-h] [-d YEAR:DAY]

  options:
    -h, --help            show this help message and exit
    -d YEAR:DAY, --date YEAR:DAY
                          Enter the year and day of the Advent of Code challenge you would like.
  ```



  ```sh
  usage: aoc-mod submit [-h] -a ANSWER -l {1,2} -d YEAR:DAY

  options:
    -h, --help            show this help message and exit
    -a ANSWER, --answer ANSWER
                          Answer to submit.
    -l {1,2}, --level {1,2}
                          Part A = 1; Part B = 2
    -d YEAR:DAY, --date YEAR:DAY
                          Enter the year and day of the Advent of Code challenge you would like.
  ```





  Initialize the AOCMod class and set up the current time and authentication variables.



  Set the authentication variables from environment variables.



  Get the current local time.

  **Returns:**
  - time.struct_time: The current local time.



  Verify if the provided date is valid for Advent of Code.

  **Args:**
  - year (int): The year to verify.
  - month (int): The month to verify.
  - day (int): The day to verify.

  **Returns:**
  - `bool`: True if the date is valid, False otherwise.





  The main URL template for Advent of Code puzzles.



  The URL template for Advent of Code puzzle input.



  The URL template for Advent of Code puzzle answer submission.





  A logger instance for the module.



  - os
  - logging
  - time
  - requests
  - markdownify
  - bs4.BeautifulSoup



  If you feel that you have new features to contribute, don't hesitate to submit a pull request!



  ```sh
  $(realpath `which python3`) -m venv .venv
  source .venv/bin/activate

  pip install -e .[build,test]

  python -m build
  ```



  After following the build steps, run `pytest`.

  ```sh
  pytest -vv
  ```


pkgId: e05d2db9aa7f6749d5c67ecac802faad227e85ec32e0d0db5e1e7ba607792079
name: python-aoc-tiles
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Fancy Advent of Code README tiles showing the completion status of the challenges per day
url: https://pypi.org/project/aoc-tiles/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoc-tiles-0.6.2-1.src.rpm
checksum_type: sha256
description:
  This script creates a graphic for each day for each year of the Advent of Code.
  A tile is an image which represents both parts of a day, it looks like this:

  ![AoC Tiles](examples/showcase.png)

  It uses the personal [AoC Leaderboard](https://adventofcode.com/2023/leaderboard/self) to get the data for each day using your cookie.




  For this year (2023) I have rewritten this script to make it a lot easier to use.
  Now you **only** need to install `pre-commit`, add a pre-commit hook and add two HTML comments to your README. More details below.



  ```bash
  pip install pre-commit
  ```

  or the more modern way below (either is fine, modern pip in Python 3.11+
  will [not allow the above command to run though](https://veronneau.org/python-311-pip-and-breaking-system-packages.html)):

  ```bash

  pipx install pre-commit
  ```



  Add this pre-commit hook to your `.pre-commit-config.yaml` (create it, if you don't have it):

  ```yaml
  repos:
      - repo: https://github.com/LiquidFun/aoc_tiles
        rev: 0.6.2
        hooks:
            - id: aoc-tiles
              
              
              
              
              
              
              
              
              
              
  ```

  Now **install** the hook with:

  ```
  pre-commit install --hook-type post-commit
  ```

  and you are done! The **--hook-type post-commit** flag is important, otherwise the hook will not run.

  There are a lot more flags, see [config.py](./aoc_tiles/config.py) for all of them.
  Auto add tiles is recommended as it will automatically add the tiles to your git repository, otherwise you might
  forget it and the tiles will not be updated. Note that this will amend your just created commit. If you do not want
  this, remove that flag.




  Add this to your .gitignore:

  ```
  .aoc_tiles/*
  !.aoc_tiles/tiles/
  ```

  Now add `<!-- AOC TILES BEGIN -->` and `<!-- AOC TILES END -->` in your README, everything between these 2 tags
  will always be replaced by the script, so do not add additional information there. Note that these are HTML comments,
  so they will not be visible in the rendered README.



  If you care about your submit-time and rank, you need to add your session cookie to the script.
  By default, if no session cookie is found, checkmarks will be used instead of the time and rank.
  Add it either in the root of the repository as `session.cookie` or in the `.aoc_tiles` directory as `session.cookie`.
  Make sure that this file is in your `.gitignore`!
  It should contain a single line, the "session" cookie from https://adventofcode.com when you are logged in.
  No prefix is needed, only the string of length 128.





  There are various flags which can be set to change the look of your tiles. Some of them are listed here
  with examples showing how it changes the look.

  <!-- **Note that in order to regenerate images you have to either delete the images or delete the .aoc-tiles-cache!** -->

  * `--what-to-show-on-right-side=`:

  | `auto` (default)                                         | `checkmark`               | `time_and_rank`                |
  |----------------------------------------------------------|---------------------------|--------------------------------|
  | `time_and_rank` if cookie is available, else `checkmark` | ![](examples/01checkmarks.png) | ![](examples/01basic.png) |

  * `--contrast-improvement-type=`:

  | `outline` (default)          | `dark`                 | `none`                 |
  |-----------------------------|--------------------------|--------------------------|
  | ![](examples/05outline.png) | ![](examples/05dark.png) | ![](examples/05none.png) |


pkgId: f5c36379330dde82b9235e5ed89c0de3bca852e80200ecfd3da7f68c002cf470
name: python-aocd-example-parser
arch: src
version: 2023.12.17
epoch: 0
release: 1
summary: Implementation of example parser plugins for advent-of-code-data
url: https://pypi.org/project/aocd-example-parser/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aocd-example-parser-2023.12.17-1.src.rpm
checksum_type: sha256
description:
  The annual programming challenge [Advent of Code](https://adventofcode.com/) frequently provides some example data (and solutions) for you to test your code against, which are usually scaled-down versions of the real input data you're supposed to be solving with each day.
  Although the real puzzle inputs and answers differ by user, the example data is written directly in the puzzle prose and is available to unauthenticated users too.
  To illustrate what this means, the first puzzle of 2022 was [`--- Day 1: Calorie Counting ---`](https://adventofcode.com/2022/day/1) and it has the following example data (54 bytes):
  ```
  1000
  2000
  3000
  4000
  5000
  6000
  7000
  8000
  9000
  10000
  ```
  The correct answers corresponding to this sample data were `24000` for part a, and `45000` for part b. The example data text was found in the first `<pre>` tag, and the answers were found in the last `<code>` blocks from each of the two `<article>` sections in the puzzle page HTML. Note that the first half of the puzzle must be solved before the second `<article>` tag shows up, so the second article is not visible to unauthenticated users.
  In 2022, this same pattern of example data locations in the HTML was repeated for four more days, consecutively, before varying on [`--- Day 6: Tuning Trouble ---`](https://adventofcode.com/2022/day/6).


pkgId: d011197bf3a9c4226f99b5186576d50299b3b68eefd6eb624884722a8a8b7156
name: python-aocs-lab
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: 姿轨控工具箱
url: https://pypi.org/project/aocs-lab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aocs-lab-0.0.7-1.src.rpm
checksum_type: sha256
description:
  安装 (使用清华源)

  `pip install -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple aocs-lab`

  升级到最新版

  `pip install -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple --upgrade aocs-lab`

  使用示例

  ```py
  import aocs_lab.sun_time as st
  import numpy as np

  if __name__ == "__main__":
      
      beta_angle = np.deg2rad(31)
      st.sun_time(beta_angle, 6900e3)
  ```



  当前功能

  1. 回归圈数分析
  2. SAR 天线受照分析
  3. 偏置对日分析
  4. 星敏布局分析
  5. 光照阴影分析
  6. 对日转对地过程的能源情况
  7. 阳照区时间分析
  8. F10.7 分析
  9. 衰减率计算
  10. 等效迎风面面积
  11. 星敏失效时间分析
  12. 飞轮惯滑时间计算
  13. Python 驱动 STK
  14. 星敏精测数据处理




  ![alt text](https://i.postimg.cc/rwys18wF/image.png)



  ![alt text](https://i.postimg.cc/8c8sMMjq/07b726e3-adbe-4110-91e6-374c52536e0c.png)



  ![alt text](https://i.postimg.cc/vHtDx1MN/beb2cc20-1e08-4764-8d2d-fa639751145d.png)



  ![alt text](https://i.postimg.cc/GpHpfqDW/image-1.png)



  ![alt text](https://i.postimg.cc/XNFr3HP3/b2d38290-2901-4392-83c5-190958959a8d.png)



  ![alt text](https://i.postimg.cc/j5nLDZdH/3cce67ab-0b2e-469f-a6e5-ee13b9b8874d.png)



  ![alt text](https://i.postimg.cc/sDrv2PFW/977604f2-567a-492a-a0db-02f48094ef5b.png)



  ![alt text](https://i.postimg.cc/hv9vrvmh/589514ff-5b7a-4dbf-8748-22a92947639c.png)


pkgId: e734d406a534b82fac6f5da077e57721811563472ec6ecda9cfdf014de53645f
name: python-aoirint-matvtool
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A command line tool to handle a multi audio track video file
url: https://github.com/aoirint/matvtoolpy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoirint-matvtool-0.5.0-1.src.rpm
checksum_type: sha256
description:
  A command line tool to handle a multi audio track video file.

  マルチオーディオトラック動画ファイルを取り扱うためのコマンドラインツール



  基本的にFFmpegのラッパーです。別途FFmpegのインストールが必要です。
  FFmpeg 4.2（Ubuntu 20.04の標準バージョン）および4.4（Ubuntu 22.04の標準バージョン）をサポートしています。

  - <https://ffmpeg.org/download.html>

  `matvtool`本体は、以下からダウンロード・インストールできます。
  Pythonパッケージとして導入する場合、Python 3.11をサポートしています。

  - バイナリ（Windows, Linux, macOS）
    - GitHub Release: <https://github.com/aoirint/matvtoolpy/releases>
  - Pythonパッケージ: `pip3 install aoirint_matvtool`
    - PyPI: <https://pypi.org/project/aoirint-matvtool/>
  - Dockerイメージ
    - Docker Hub: <https://hub.docker.com/r/aoirint/matvtoolpy>
      - CPU: `docker run --rm -v "$PWD:/work" aoirint/matvtoolpy:ubuntu-latest --help`
      - NVIDIA GPU: `docker run --rm --gpus all -v "$PWD:/work" aoirint/matvtoolpy:nvidia-latest --help`



  OBS Studioの録画機能やGeForce Experienceの録画機能などで作成した、マルチオーディオトラック動画ファイルを、
  マルチオーディオトラックの状態を保ったまま簡易に編集し、後に高度な動画編集ソフトで使う素材として使いやすい形に整えるためのツール。





  再エンコードしないため、高速ですが時間精度が低いです。
  長時間の録画をおおまかに分割する用途を想定しています。
  フレーム単位でクリップしたい場合、後段の動画編集ソフトで改めて加工してください。

  ```shell
  matvtool slice -ss 00:05:00 -to 00:10:00 -i input.mkv output.mkv
  ```



  `-vcodec`/`--video_codec`オプションで出力映像コーデックを指定できます（未指定時は既定のエンコーダを使用）。

  ```shell

  matvtool crop_scale -i input.mkv --crop w=1600:h=900:x=0:y=0 --scale 1920:1080 output.mkv


  matvtool crop_scale -i input.mkv --crop w=1600:h=900:x=iw-ow:y=ih-oh --scale 1920:1080 output.mkv


  matvtool crop_scale -i input.mkv --crop w=1600:h=900:x=0:y=0 --scale 1920:1080 -vcodec libx264 output.mkv


  matvtool crop_scale -i input.mkv --crop w=1600:h=900:x=0:y=0 --scale 1920:1080 -vcodec nvenc_h264 output.mkv


  matvtool crop_scale -i input.mkv --crop w=1600:h=900:x=0:y=0 --scale 1920:1080 -vcodec nvenc_hevc output.mkv
  ```



  動画のスナップショットやクロップ画像を使用して、出現時間・出現フレームを検索します。
  特定シーンの頭出しやチャプターを作成する用途を想定しています。
  確実・正確に検出できるとは限りません。
  出力は、VSCodeのマルチカーソル機能や`seq`コマンドなどを使って手動処理することを想定しています（試合1～試合10までの連番文字列生成：`seq -f "試合%g" 1 10`）。

  `slice`と同様のオプションで検索範囲の時間を指定できます。`--fps`オプションで比較処理におけるフレームの読み飛ばしができます（コーデックにおけるフレーム間予測の関係で、全フレームのデコードは発生すると思われるため、デコード処理時間が支配的な場合はあまり意味がないと思われます）。
  出力は、内部処理における時間・フレームと、入力動画における時間・フレームが併記されます。

  `-icrop`/`--input_video_crop`オプション、`-refcrop`/`--reference_image_crop`オプションで、入力動画や参照画像の一部を使用した検索ができます。値は`crop_scale`の`--crop`オプションと同様です。
  特定のアイコンが含まれることがわかっているが、フレーム中の他の部分が大きく違うケースの検索に有用です。

  `-it`/`--output_interval`オプションで、連続出現時の出力を抑制できます。手動処理を減らすためのオプションです。
  例えば、`-it 10`を指定すると、前回出現してから10秒間のフレームで再び出現を検出しても、ログ出力しません（[YouTubeのチャプター機能](https://support.google.com/youtube/answer/9884579)では、最小チャプター間隔は10秒）。

  `-p`, `--progress_type`オプションで、処理の進捗状況の出力方法を変更できます。
  値は、`tqdm` 標準エラー出力・インタラクティブシェル用（デフォルト）、`plain` 標準エラー出力・逐次出力、`none` 出力なし、が利用できます。

  処理に時間のかかる長い動画を入力するときは、`tee`コマンドなどで出力を永続化したり、`tmux`コマンドなどでバックグラウンド処理したりすると便利です。うまく出力が表示されないときは、一時的に環境変数`PYTHONUNBUFFERED=1`を設定すると改善するかもしれません。

  ```shell

  matvtool find_image -i input.mkv -ref reference.png


  matvtool find_image -i input.mkv -ref reference.png --fps 10


  matvtool find_image -i input.mkv -icrop w=1600:h=900:x=0:y=0 -ref reference.png -refcrop w=1600:h=900:x=0:y=0


  PYTHONUNBUFFERED=1 matvtool find_image -i input.mkv -icrop w=1600:h=900:x=0:y=0 -ref reference.png -refcrop w=1600:h=900:x=0:y=0 --fps 10 -it 10 | tee chapters.txt
  ```



  ```shell
  matvtool audio -i input.mkv
  ```



  ```shell
  matvtool select_audio -i input.mkv --audio_index 2 3 -- output.mkv
  ```




  Python 3.11を使って開発しています。



  依存関係の管理に[Poetry](https://python-poetry.org/docs/#installation)を使っています。

  ```shell

  poetry add pydantic
  poetry add --group dev pytest
  ```


pkgId: b1d6b13ef984d765d7d4890657a9cb9609df881792b43a4125378b3c66fa4772
name: python-aoirint-miyadaiku-theme-blog
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: Blog theme for miyadaiku static site generator
url: https://github.com/aoirint/aoirint-miyadaiku-theme-blog/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoirint-miyadaiku-theme-blog-0.1.15-1.src.rpm
checksum_type: sha256
description:
  - [Miyadaiku - Doc](https://miyadaiku.github.io/)
  - [Miyadaiku - GitHub](https://github.com/miyadaiku/miyadaiku)
  - [Miyadaiku - PyPI](https://pypi.org/project/miyadaiku/)

  ```
  pip3 install aoirint_miyadaiku_theme_blog
  ```

  ```

  miyadaiku-build -sw .
  ```


  ```yml



  site_url: https://www.example.com


  site_title: Your site title


  lang: ja-JP


  charset: utf-8


  timezone: Asia/Tokyo

  copyright: Copyright © 20xx Your Name.

  favicon: /favicon.ico



  twitter_name: example
  github_name: github



  themes:
    - aoirint_miyadaiku_theme_blog

  ```


pkgId: d0422c33d8c1b0dcf9f5771cf93ca7a48f811a58ecf90343fd77a259471b66a0
name: python-aoirint-psdlayer2dirpy
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: PSDファイルのレイヤー構造＋画像をディレクトリ構造＋PNGとしてダンプするスクリプト
url: https://github.com/aoirint/psdlayer2dirpy
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoirint-psdlayer2dirpy-0.1.11-1.src.rpm
checksum_type: sha256
description:
  - GitHub: <https://github.com/aoirint/psdlayer2dirpy>
  - PyPI: <https://pypi.org/project/aoirint-psdlayer2dirpy/>
  - Docker Hub: <https://hub.docker.com/r/aoirint/psdlayer2dirpy>






  Download from [Releases](https://github.com/aoirint/psdlayer2dirpy/releases).

  ```
  ./psdlayer2dir image.psd -o output/
  ```



  ```shell
  pip3 install aoirint_psdlayer2dirpy

  psdlayer2dir image.psd -o output/
  ```



  ```shell
  docker pull aoirint/psdlayer2dirpy

  docker run --rm -v "$PWD:/work" -w /work aoirint/psdlayer2dirpy image.psd -o output/
  ```




  This repository uses [Poetry](https://github.com/python-poetry/poetry).



  ```shell
  env PYTHON_CONFIGURE_OPTS="--enable-shared" pyenv install 3.10.10
  pyenv local 3.10.10

  poetry env remove python
  poetry env use python
  poetry install
  ```



  ```shell
  poetry run pysen run lint format
  ```



  ```shell

  poetry add {package_name}
  poetry add -G dev {package_name}


  poetry export --without-hashes -o requirements.txt
  poetry export --without-hashes --with dev -o requirements-dev.txt
  ```



  ```shell
  docker build -t psdlayer2dirpy .

  docker run --rm -v "./work:/work" -w /work psdlayer2dirpy image.psd -o output/
  ```




  - psd-tools: [Docs](https://psd-tools.readthedocs.io/en/latest/) [GitHub](https://github.com/psd-tools/psd-tools) [PyPI](https://pypi.org/project/psd-tools/)


pkgId: 4fb47be5b98532f4376dcf8f1a7779e903f6f1c45093120a128072fa85cb2c8b
name: python-aok
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Complex dictionary comparisons to simplify testing.
url: https://gitlab.com/rocket-boosters/a-ok
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aok-0.3.4-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/aok.svg)](https://pypi.org/project/aok/)
  [![build status](https://gitlab.com/rocket-boosters/a-ok/badges/main/pipeline.svg)](https://gitlab.com/rocket-boosters/a-ok/commits/main)
  [![coverage report](https://gitlab.com/rocket-boosters/a-ok/badges/main/coverage.svg)](https://gitlab.com/rocket-boosters/a-ok/commits/main)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Code style: flake8](https://img.shields.io/badge/code%20style-flake8-white)](https://gitlab.com/pycqa/flake8)
  [![Code style: mypy](https://img.shields.io/badge/code%20style-mypy-white)](http://mypy-lang.org/)
  [![PyPI - License](https://img.shields.io/pypi/l/aok)](https://pypi.org/project/aok/)

  *aok* is a library for simplifying the assertions of complex dictionary returns,
  which can be used within Python code or loaded via YAML files.

  ```python
  import aok

  import my_application


  def test_call():
      """Should return the expected dictionary from my application call."""
      result: dict = my_application.get_family("Jane Doe")
      ok = aok.Okay({
          "mother": {
              "age": aok.greater_or_equal(50),
              "full_name": aok.like("* Doe"),
          },
          "father": {
              "age": aok.greater_or_equal(50),
              "full_name": aok.like("* Doe"),
          },
          "younger_brother": {
              "age": aok.less(10),
              "full_name": aok.like("* Doe"),
          }
      })

      
      ok.assert_all(result)

      
      
      ok.assert_subset(result)
  ```

  The same thing can be archived from a YAML file:

  ```yaml
  ok: !aok
    mother:
      age: !aok.greater_or_equal 50
      full_name: !aok.like '* Doe'
    father:
      age: !aok.greater_or_equal 50
      full_name: !aok.like '* Doe'
    younger_brother:
      age: !aok.less 10
      full_name: !aok.like '* Doe'
  ```

  and this can be loaded into a test:

  ```python
  import aok
  import yaml
  import pathlib

  import my_application


  def test_call():
      """Should return the expected dictionary from my application call."""
      result: dict = my_application.get_family("Jane Doe")
      data: dict = yaml.full_load(pathlib.Path("expectations.yaml").read_text())
      ok: aok.Okay = data["ok"]
      ok.assert_all(result)
  ```

  It is also possible to do a comparison on lists with `aok.OkayList` and the `!aok_list`
  class replacing the `aok.Okay` and `!aok` values like shown in the example above.

  The available comparators are:
  - `aok.anything()` will always succeed, no matter what the observed value is.
  - `aok.between(min, max)` must be greater than or equal to min and less than or equal
    to the specified min and max values. This can be a numeric or string value.
  - `aok.equals(value)` must be an exact match between the values.
  - `aok.unequals(value)` must not be equal to the expected value.
  - `aok.greater(value)` must be greater than the specified value.
  - `aok.greater_or_equal(value)` must be greater than or equal to the specified value.
  - `aok.less(value)` must be less than the specified value.
  - `aok.less_or_equal(value)` must be less than or equal to the specified value.
  - `aok.contains(string_value)` must be a string that contains the specified substring
     exactly.
  - `aok.not_contains(string_value)` must be a string that does not contain the exact
     specified string value.
  - `aok.like(string_value)` string compares against case-insensitive, unix-shell-style
     wildcard expressions, e.g. "foo*" would match "foo-bar".
  - `aok.not_like(string_vlaue)` string compares against case-insensitive,
     unix-shell-style wildcard expressions, e.g. "*bar*", and expects not to find a match.
  - `aok.like_case(string_value)` string compares against case-sensitive,
     unix-shell-style wildcard expressions, e.g. "Foo*" would match "Foo-Bar".
  - `aok.match(string_regex_pattern)` matches the string against the specified regex
     pattern.
  - `aok.not_null(value)` must not be null/None, but can be anything else.
  - `aok.optional(value)` must equal the specified value or be null/None.
  - `aok.one_of(value)` must match one of the values in the specified list. Any of the
  - `aok.none_of(value)` must not match one of the values in the specified list. Any of
     the list items can also be a comparator that will be negated.
  - `aok.json_dict(dict)` parses a JSON-serialized string attribute and compares it to
     the dictionary/object in the same fashion as the `!aok` root object.
  - `aok.json_list(list)` parses a JSON-serialized string attribute nad compares it to
     the list object in the same fashion as the `!aok_list` root object.


pkgId: 9af58ccfda9b4edf6cc12910a92f39f551b385f6d78fa424bbf9bc12d5a4cb52
name: python-aom-sdk
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: AoM platform sdk
url: https://gitlab.com/age-of-minds/aom-framework
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aom-sdk-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This is the python API for making use of the AoM framework when working with the Python programming language.


pkgId: 2534c94c81cacdb1cf8f5565c8385f9e741e7a01b3e30a4f8afc0cc3aeb6b429
name: python-aoquality
arch: src
version: 0.2.6
epoch: 0
release: 1
url: https://gitlab.com/flomertens/aoquality/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoquality-0.2.6-1.src.rpm
checksum_type: sha256
summary:
  Python module to access Measurement Sets' quality statistics produced by aoflagger, aoquality or DPPP.

description:
  Python module to access Measurement Sets' quality statistics produced by aoflagger, aoquality or DPPP.



  pyaoquality can be installed via pip:

      $ pip install aoquality

  and requires Python 3.6.0 or higher.



  Example to retrieve baseline statistics:


  ```python
  aoq = aoquality.AOQualityBaselineStat(ms_file)


  plt.plot(aoq.blenght, aoq.SNR)


  plt.plot(aoq.ant1, aoq.SNR)

  ```

  To retrieve time statistics:


  ```python
  aot = aoquality.AOQualityTimeStat(ms_file)


  plt.plot(aot.time, aot.RFIPercentage)

  ```

  To retrieve frequency statistics:


  ```python
  aof = aoquality.AOQualityFrequencyStat(ms_file)


  plt.plot(aof.freqs, aof.Std)

  ```



  There is also a command line tool, aostats, which usage is as follow:

      Usage: aostats plot [OPTIONS] MS_FILES... [Mean|Std|DStd|Count|DCount|Sum|DSum
                          |DSumP2|Variance|DVariance|SNR|RFICount|RFIPercentage]

        Plot Statistics from AO Quality Tables

        MS_FILES: Input MS files STAT_NAME: Statistic Name

      Options:
        -o, --out_prefix TEXT    Prefix to the output filename  [default: stat]
        -p, --pol INTEGER RANGE  Polarization index: 0->XX, 1->XY, 2->YX, 3->YY
                                 [default: 0]

        --log                    Plot in log scale
        --vmin FLOAT             Minimum value
        --vmax FLOAT             Maximum value
        --name TEXT              Title of the plot
        --help                   Show this message and exit.


pkgId: ab3b7be2ef4894893578b29da0f0e10f02d4240a8fdbc84704d04e5a549ed52a
name: python-aoricaan-cli
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/aoricaan-cli/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aoricaan-cli-0.3.4-1.src.rpm
checksum_type: sha256
description:
  A cli for manage a project.


  for use:

  Recommendation:

  Create and activate a virtual environment.
  ````commandline
  python -m venv venv
  ````

  ````commandline
  sorurce ./venv/Scripts/activate

  or

  ./venv/Scripts/activate
  ````

  now you can install the CLI

  ````commandline
  pip install aoricaan-cli
  ````

  for start to work

  ````commandline
  apm init
  pip install -r requirements.txt
  apm project install
  ````

  All ready!

  You can start developing you api.

  for more information read the readme created within your project.


pkgId: 8c99f7d7945c851f85a44d281fb1611148de01dd96cb0ab742286e96a1d349ef
name: python-aospdtgen
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Create an Android device tree from a device dump
url: https://github.com/sebaubuntu-python/aospdtgen
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aospdtgen-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/aospdtgen)](https://pypi.org/project/aospdtgen/)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/0ec14174bf9840458f27062444b1e375)](https://www.codacy.com/gh/sebaubuntu-python/aospdtgen/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=sebaubuntu-python/aospdtgen&amp;utm_campaign=Badge_Grade)

  Create a [LineageOS](https://github.com/LineageOS)-compatible device tree from an Android stock ROM dump (made with [dumpyara](https://github.com/SebaUbuntu/dumpyara)).
  This script supports any Android firmware from a Treble-enabled device (Higher than Android 8.0 and with VNDK enabled, you can check it with [Treble Info](https://play.google.com/store/apps/details?id=tk.hack5.treblecheck) or with `adb shell getprop ro.treble.enabled`).
  For pre-Treble devices please use [twrpdtgen](https://github.com/twrpdtgen/twrpdtgen).

  Requires Python 3.8 or greater



  ```sh
  pip3 install aospdtgen
  ```



  ```
  $ python3 -m aospdtgen -h
  Android device tree generator
  Version 0.1.0

  usage: python3 -m aospdtgen [-h] [-o OUTPUT] dump_path

  positional arguments:
    dump_path             path to an Android dump made with dumpyara

  optional arguments:
    -h, --help            show this help message and exit
    -o OUTPUT, --output OUTPUT
                          custom output folder
  ```



  ```





  ```


pkgId: 0a53620cd2af626732d1b654778a7d003c870d8b9af6849bee9e4a64840ab0d1
name: python-aostats
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/mazurwiktor/albion-online-stats
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aostats-1.0.5-1.src.rpm
checksum_type: sha256
description:
  Albion online stats is an extension to MMORPG game - Albion Online. It tracks network traffic and displays various statistics, such as damage and DPS meter calculated from in-game actions.

  ![0.7.0](https://user-images.githubusercontent.com/11301109/71000581-d9124000-20db-11ea-8c19-4d7f69a2c155.png)

  [![Video](http://img.youtube.com/vi/Dy3YyherSmw/0.jpg)](http://www.youtube.com/watch?v=Dy3YyherSmw "Albion online stats")

  > **Note** this section does not require any coding knowledge. Those simple two steps are required to use this software :)

  1. On windows make sure that WinPcap is installed in your system. [Npcap 0.9983 installer for Windows Vista/2008, 7/2008R2, 8/2012, 8.1/2012R2, 10/2016 (x86 and x64)](https://nmap.org/npcap/dist/npcap-0.9983.exe) **Make sure to install with the "Install Npcap in WinPcap API-compatible Mode"**
  2. Install python [all platforms installation instructions](https://docs.python.org/3/using/) or via [Microsoft Store](https://www.microsoft.com/en-us/p/python-39/9p7qfqmjrfp7).
  3. Download latest launcher from https://github.com/mazurwiktor/albion-online-stats/releases/latest (albion-online-stats.bat for windows albion-online-stats.sh for linux and mac)
  3. Enjoy :)

  After first execution the app is going to create default configuration file named `albion-online-stats.cfg`. Feel free to edit it according to your needs.

  <p align="center">
      <img src="assets/sbistatement.png">
  </p>
  - [x] Only monitors your own party
  - [x] Does not modify our game client
  - [x] Does not track players that are not within the player's view
  - [x] Does not have an overlay to the game
  > **Note** this traits of the application are true from version 0.9.0+.

  [![Become a patron](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/wiktormazur)


  - Python installed (python3.6+)
  - *Windows only prerequisites*  https://github.com/libpnet/libpnet#windows

  1. Clone repository:
      ```shell
      git clone https://github.com/mazurwiktor/albion-online-stats.git
      ```
  2. [optional] Create and activate python virtualenv
      ```shell
      python -m venv env
      [linux/mac] . env/bin/activate
      [windows powershell] .\env\Scripts\activate.ps1
      [windows cmd.exe] .\env\Scripts\activate.bat
      ```
  3. Install package
      ```shell
      python setup.py install
      ```
  4. Run the application
      ```shell
      aostats
      ```

  Check out [wiki page](https://github.com/mazurwiktor/albion-online-stats/wiki)

  Licensed under either of
    * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
    * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
  at your option.


pkgId: 2ee3b71fd4f709fcf99976e3830e467cf02db741e967424cae643134ea3a4b2e
name: python-aotools
arch: src
version: 1.0.7
epoch: 0
release: 1
summary: A set of useful functions for Adaptive Optics in Python
url: https://github.com/aotools/aotools
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aotools-1.0.7-1.src.rpm
checksum_type: sha256
description:
  Useful tools for Adaptive Optics analysis for the Python Programming Language. If using this code for a publication please cite the `aotools paper <https://www.osapublishing.org/oe/abstract.cfm?uri=oe-27-22-31316>`_ (M. J. Townson, O. J. D. Farley, G. Orban de Xivry, J. Osborn, and A. P. Reeves, "AOtools: a Python package for adaptive optics modelling and analysis," Opt. Express 27, 31316-31329 (2019))


pkgId: 5e11fa4142c875b65eebafb2abfaff1bf5605d476ab43da20680dd6cf462d376
name: python-aotpy
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Helper package for handling Adaptive Optics Telemetry (AOT) standard files
url: https://pypi.org/project/aotpy/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-aotpy-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8187229.svg)](https://doi.org/10.5281/zenodo.8187229)
  [![Documentation Status](https://readthedocs.org/projects/aotpy/badge/?version=latest)](https://aotpy.readthedocs.io/en/latest/?badge=latest)


  Helper Python package for handling Adaptive Optics Telemetry (AOT) standard files.
  Basic [documentation available](https://aotpy.readthedocs.io/en/latest/).


  Support is offered for Python 3.10 or later.


      python -m pip install aotpy


  Clone the repository and then install with:

      python -m pip install path/to/aotpy

  where 'path/to/aotpy' is the path to the root of the cloned repository.





  Here we exemplify of how to create an AOT FITS file from scratch. In general terms, we create an AOSystem object,
  fill the relevant data fields and then write that object into a FITS file which follows the AOT specification.

  ```python
  import numpy as np

  import aotpy


  system = aotpy.AOSystem(ao_mode='GLAO')
  system.main_telescope = aotpy.MainTelescope("Example telescope")


  dm = aotpy.DeformableMirror("Example DM", n_valid_actuators=32, telescope=system.main_telescope)
  system.wavefront_correctors.append(dm)


  ngs = aotpy.NaturalGuideStar("Example NGS")
  lgs = aotpy.SodiumLaserGuideStar("Example LGS")
  system.sources = [ngs, lgs]


  ngs_wfs = aotpy.ShackHartmann("WFS1", source=ngs, n_valid_subapertures=4,
                                measurements=aotpy.Image("NGS slopes", data=np.ones((10000, 2, 4))))

  ngs_wfs.detector = aotpy.Detector("DET1", pixel_intensities=aotpy.Image("Pixels", data=np.random.random((100, 20, 20))))


  lgs_wfs = aotpy.ShackHartmann("WFS2", source=lgs, n_valid_subapertures=8,
                                measurements=aotpy.Image("LGS slopes", data=np.ones((10000, 2, 8))))
  system.wavefront_sensors = [ngs_wfs, lgs_wfs]



  lo_loop = aotpy.ControlLoop("LO loop", input_sensor=ngs_wfs, commanded_corrector=dm,
                              commands=aotpy.Image("LO commands", data=np.ones((10000, 32))),
                              control_matrix=aotpy.Image('LO control matrix', data=np.ones((32, 2, 4))))
  ho_loop = aotpy.ControlLoop("HO loop", input_sensor=lgs_wfs, commanded_corrector=dm,
                              commands=aotpy.Image("HO commands", data=np.ones((10000, 32))),
                              control_matrix=aotpy.Image('HO control matrix', data=np.ones((32, 2, 8))))
  system.loops = [lo_loop, ho_loop]


  system.write_to_file("example.fits")
  ```

  In this example we assume we already have an AOT file. We can easily read it and explore its data. For demonstration
  purposes, we assume matplotlib is installed, although it is not a requirement for this package.

  ```python
  import matplotlib.pyplot as plt

  import aotpy



  system = aotpy.AOSystem.read_from_file("example.fits")


  pixel_data = system.wavefront_sensors[0].detector.pixel_intensities.data

  plt.imshow(pixel_data[0])
  plt.show()
  ```


  This project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant
  agreement No. 101004719 (OPTICON–RadioNet Pilot).

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


