# packages

pkgId: aa5ecf9e6c17ed376a5ac4be8c8bffd7d6b2a1e3e031b6e475708f7bf14d11c2
name: python-3d-bin-packer-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for 3d-bin-packer
url: https://github.com/h3110Fr13nd/3d_bin_packing
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-3d-bin-packer-0.0.3-1.src.rpm
location_href: Packages/python-3d-bin-packer-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Credits: This is just a Python Implementation of the code from npm package https://www.npmjs.com/package/@owens3364/3d-bin-packing.


pkgId: b6f3cb42fd921b04cb7712994027a0531a512e53824e64f3d8fab077e6f69557
name: python-AGVlinkhou-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for AGVlinkhou
url: https://github.com/Huangri-believe/LinkHouAGV
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AGVlinkhou-1.0.1-1.src.rpm
location_href: Packages/python-AGVlinkhou-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
      本项目是对灵猴底盘API调用所建立的。
      可以通过WebSocket协议对底盘进行操控


      见requirement.txt文件


      ├── ReadMe.md           // 帮助文档

      ├── example.py    // 测试底盘的python文件

      ├── linkhouWebSocketClient.py    // 包含WebSocket连接以及底盘API调用的接口


  主要功能

   CreateTask(self,stationId,stationName,actionType = 0,) // 用于创建导航任务，stationId = 站台编号，stationName = 站台名称 actionType = 动作类型

   CancelTask(self,id) //取消任务，id = 任务编号

   GetState(self,id) // 获取机器人状态，id = 机器人编号


  1.增加了输入了机器人ID，便于调用不同机器人


pkgId: 433a180b27252fbfe5c67453311ea5d2b6fd23a3f7e26140649d4dc6bf28e5b4
name: python-AIStructDynSolve-help
arch: noarch
version: 1.2
epoch: 0
release: 1
summary: Development documents and examples for AIStructDynSolve
url: https://pypi.org/project/AIStructDynSolve/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AIStructDynSolve-1.2-1.src.rpm
location_href: Packages/python-AIStructDynSolve-help-1.2-1.noarch.rpm
checksum_type: sha256
description:
  A framework focused on solving structural dynamics problems using artificial intelligence (AI) methods
  solve the following ODE of MDOF
  M*U_dotdot+C*U_dot+K*U=Pt
  initial condition: U(t=0)=InitialU, and U_dot(t=0)=InitialU_dot
  Author: Ke Du(鏉滆讲) duke@iem.ac.cn
  Date: 2023/12/26


pkgId: 7f4c317b75ce00519f6fd7eb83b20a15b2aaf8ddce1e07dfe484a6295787f1c6
name: python-AMR-help
arch: noarch
version: 2.1.1.9117
epoch: 0
release: 1
summary: Development documents and examples for AMR
url: https://github.com/msberends/AMR
rpm_license: GPL 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AMR-2.1.1.9117-1.src.rpm
location_href: Packages/python-AMR-help-2.1.1.9117-1.noarch.rpm
checksum_type: sha256
description:
  The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python Package Index](https://pypi.org/project/AMR/).

  This Python package is a wrapper round the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code.



  1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run:

      ```bash
      pip install AMR
      ```

  2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically.

      For Linux:

      ```bash
      
      sudo apt install r-base
      
      sudo dnf install R
      
      sudo yum install R
      ```

      For macOS (using [Homebrew](https://brew.sh)):

      ```bash
      brew install r
      ```

      For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R.





  Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package:

  ```python
  import pandas as pd
  import AMR


  data = {
      "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'],
      "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin']
  }
  df = pd.DataFrame(data)


  df['MO_clean'] = AMR.mo_name(df['MOs'])
  df['Drug_clean'] = AMR.ab_name(df['Drug'])


  print(df)
  ```

  | MOs         | Drug      | MO_clean           | Drug_clean    |
  |-------------|-----------|--------------------|---------------|
  | E. coli     | Cipro     | Escherichia coli   | Ciprofloxacin |
  | ESCCOL      | CIP       | Escherichia coli   | Ciprofloxacin |
  | esco        | J01MA02   | Escherichia coli   | Ciprofloxacin |
  | Esche coli  | Ciproxin  | Escherichia coli   | Ciprofloxacin |



  * **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli".

  * **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin".




  As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antibiotics`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames:

  ```python
  AMR.microorganisms
  ```

  | mo           | fullname                           | status   | kingdom  | gbif      | gbif_parent | gbif_renamed_to | prevalence |
  |--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------|
  | B_GRAMN      | (unknown Gram-negatives)           | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_GRAMP      | (unknown Gram-positives)           | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_ANAER-NEG  | (unknown anaerobic Gram-negatives) | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_ANAER-POS  | (unknown anaerobic Gram-positives) | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | B_ANAER      | (unknown anaerobic bacteria)       | unknown  | Bacteria | None      | None        | None            | 2.0        |
  | ...          | ...                                | ...      | ...      | ...       | ...         | ...             | ...        |
  | B_ZYMMN_POMC | Zymomonas pomaceae                 | accepted | Bacteria | 10744418  | 3221412     | None            | 2.0        |
  | B_ZYMPH      | Zymophilus                         | synonym  | Bacteria | None      | 9475166     | None            | 2.0        |
  | B_ZYMPH_PCVR | Zymophilus paucivorans             | synonym  | Bacteria | None      | None        | None            | 2.0        |
  | B_ZYMPH_RFFN | Zymophilus raffinosivorans         | synonym  | Bacteria | None      | None        | None            | 2.0        |
  | F_ZYZYG      | Zyzygomyces                        | unknown  | Fungi    | None      | 7581        | None            | 2.0        |

  ```python
  AMR.antibiotics
  ```

  | ab  | cid         | name                 | group                      | oral_ddd | oral_units | iv_ddd | iv_units |
  |-----|-------------|----------------------|----------------------------|----------|------------|--------|----------|
  | AMA | 4649.0      | 4-aminosalicylic acid| Antimycobacterials         | 12.00    | g          | NaN    | None     |
  | ACM | 6450012.0   | Acetylmidecamycin    | Macrolides/lincosamides    | NaN      | None       | NaN    | None     |
  | ASP | 49787020.0  | Acetylspiramycin     | Macrolides/lincosamides    | NaN      | None       | NaN    | None     |
  | ALS | 8954.0      | Aldesulfone sodium   | Other antibacterials       | 0.33     | g          | NaN    | None     |
  | AMK | 37768.0     | Amikacin             | Aminoglycosides            | NaN      | None       | 1.0    | g        |
  | ... | ...         | ...                  | ...                        | ...      | ...        | ...    | ...      |
  | VIR | 11979535.0  | Virginiamycine       | Other antibacterials       | NaN      | None       | NaN    | None     |
  | VOR | 71616.0     | Voriconazole         | Antifungals/antimycotics   | 0.40     | g          | 0.4    | g        |
  | XBR | 72144.0     | Xibornol             | Other antibacterials       | NaN      | None       | NaN    | None     |
  | ZID | 77846445.0  | Zidebactam           | Other antibacterials       | NaN      | None       | NaN    | None     |
  | ZFD | NaN         | Zoliflodacin         | None                       | NaN      | None       | NaN    | None     |




  ```python
  import AMR
  import pandas as pd

  df = AMR.example_isolates
  result = AMR.resistance(df["AMX"])
  print(result)
  ```

  ```
  [0.59555556]
  ```



  One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python:

  ```python
  result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]])
  print(result2a)
  ```

  | Pathogen        | Amoxicillin     | Ciprofloxacin   | Piperacillin/tazobactam  |
  |-----------------|-----------------|-----------------|--------------------------|
  | CoNS            | 7% (10/142)     | 73% (183/252)   | 30% (10/33)              |
  | E. coli         | 50% (196/392)   | 88% (399/456)   | 94% (393/416)            |
  | K. pneumoniae   | 0% (0/58)       | 96% (53/55)     | 89% (47/53)              |
  | P. aeruginosa   | 0% (0/30)       | 100% (30/30)    | None                     |
  | P. mirabilis    | None            | 94% (34/36)     | None                     |
  | S. aureus       | 6% (8/131)      | 90% (171/191)   | None                     |
  | S. epidermidis  | 1% (1/91)       | 64% (87/136)    | None                     |
  | S. hominis      | None            | 80% (56/70)     | None                     |
  | S. pneumoniae   | 100% (112/112)  | None            | 100% (112/112)           |


  ```python
  result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain")
  print(result2b)
  ```

  | Pathogen       | Amoxicillin     | Ciprofloxacin    | Piperacillin/tazobactam  |
  |----------------|-----------------|------------------|--------------------------|
  | Gram-negative  | 36% (226/631)   | 91% (621/684)    | 88% (565/641)            |
  | Gram-positive  | 43% (305/703)   | 77% (560/724)    | 86% (296/345)            |


  In this example, we generate an antibiogram by selecting various antibiotics.



  With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance.

  By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows.

  Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python.


pkgId: 7201b2005f26fb8c0a16d64fdcf306f22e20ecd6db57b407fa5c5ab7536f4d26
name: python-APIFlask-help
arch: noarch
version: 2.3.2
epoch: 0
release: 1
summary: Development documents and examples for APIFlask
url: https://pypi.org/project/APIFlask/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-APIFlask-2.3.2-1.src.rpm
location_href: Packages/python-APIFlask-help-2.3.2-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://apiflask.com/_assets/apiflask-logo.png)



  [![Build status](https://github.com/apiflask/apiflask/actions/workflows/tests.yml/badge.svg)](https://github.com/apiflask/apiflask/actions) [![codecov](https://codecov.io/gh/apiflask/apiflask/branch/main/graph/badge.svg?token=2CFPCZ1DMY)](https://codecov.io/gh/apiflask/apiflask)

  APIFlask is a lightweight Python web API framework based on [Flask](https://github.com/pallets/flask) and [marshmallow-code](https://github.com/marshmallow-code) projects. It's easy to use, highly customizable, ORM/ODM-agnostic, and 100% compatible with the Flask ecosystem.

  With APIFlask, you will have:

  - More sugars for view function (`@app.input()`, `@app.output()`, `@app.get()`, `@app.post()` and more)
  - Automatic request validation and deserialization
  - Automatic response formatting and serialization
  - Automatic [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification) (OAS, formerly Swagger Specification) document generation
  - Automatic interactive API documentation
  - API authentication support (with [Flask-HTTPAuth](https://github.com/miguelgrinberg/flask-httpauth))
  - Automatic JSON response for HTTP errors




  - Python 3.8+
  - Flask 2.0+




  For Linux and macOS:

  ```bash
  $ pip3 install apiflask
  ```

  For Windows:

  ```bash
  > pip install apiflask
  ```




  - Website: <https://apiflask.com>
  - Documentation: <https://apiflask.com/docs>
  - PyPI Releases: <https://pypi.python.org/pypi/APIFlask>
  - Change Log: <https://apiflask.com/changelog>
  - Source Code: <https://github.com/apiflask/apiflask>
  - Issue Tracker: <https://github.com/apiflask/apiflask/issues>
  - Discussion: <https://github.com/apiflask/apiflask/discussions>
  - Twitter: <https://twitter.com/apiflask>
  - Open Collective: <https://opencollective.com/apiflask>




  If you find APIFlask useful, please consider [donating](https://opencollective.com/apiflask) today. Your donation keeps APIFlask maintained and evolving.

  Thank you to all our backers and sponsors!



  [![](https://opencollective.com/apiflask/backers.svg?width=890)](https://opencollective.com/apiflask)



  [![](https://opencollective.com/apiflask/sponsors.svg?width=890)](https://opencollective.com/apiflask)



  ```python
  from apiflask import APIFlask, Schema, abort
  from apiflask.fields import Integer, String
  from apiflask.validators import Length, OneOf

  app = APIFlask(__name__)

  pets = [
      {'id': 0, 'name': 'Kitty', 'category': 'cat'},
      {'id': 1, 'name': 'Coco', 'category': 'dog'}
  ]


  class PetIn(Schema):
      name = String(required=True, validate=Length(0, 10))
      category = String(required=True, validate=OneOf(['dog', 'cat']))


  class PetOut(Schema):
      id = Integer()
      name = String()
      category = String()


  @app.get('/')
  def say_hello():
      
      return {'message': 'Hello!'}


  @app.get('/pets/<int:pet_id>')
  @app.output(PetOut)
  def get_pet(pet_id):
      if pet_id > len(pets) - 1:
          abort(404)
      
      
      return pets[pet_id]


  @app.patch('/pets/<int:pet_id>')
  @app.input(PetIn(partial=True))  # -> json_data
  @app.output(PetOut)
  def update_pet(pet_id, json_data):
      
      
      if pet_id > len(pets) - 1:
          abort(404)
      for attr, value in json_data.items():
          pets[pet_id][attr] = value
      return pets[pet_id]
  ```

  <details>
  <summary>You can also use class-based views based on <code>MethodView</code></summary>

  ```python
  from apiflask import APIFlask, Schema, abort
  from apiflask.fields import Integer, String
  from apiflask.validators import Length, OneOf
  from flask.views import MethodView

  app = APIFlask(__name__)

  pets = [
      {'id': 0, 'name': 'Kitty', 'category': 'cat'},
      {'id': 1, 'name': 'Coco', 'category': 'dog'}
  ]


  class PetIn(Schema):
      name = String(required=True, validate=Length(0, 10))
      category = String(required=True, validate=OneOf(['dog', 'cat']))


  class PetOut(Schema):
      id = Integer()
      name = String()
      category = String()


  class Hello(MethodView):

      
      def get(self):
          return {'message': 'Hello!'}


  class Pet(MethodView):

      @app.output(PetOut)
      def get(self, pet_id):
          """Get a pet"""
          if pet_id > len(pets) - 1:
              abort(404)
          return pets[pet_id]

      @app.input(PetIn(partial=True))
      @app.output(PetOut)
      def patch(self, pet_id, json_data):
          """Update a pet"""
          if pet_id > len(pets) - 1:
              abort(404)
          for attr, value in json_data.items():
              pets[pet_id][attr] = value
          return pets[pet_id]


  app.add_url_rule('/', view_func=Hello.as_view('hello'))
  app.add_url_rule('/pets/<int:pet_id>', view_func=Pet.as_view('pet'))
  ```
  </details>

  <details>
  <summary>Or use <code>async def</code></summary>

  ```bash
  $ pip install -U "apiflask[async]"
  ```

  ```python
  import asyncio

  from apiflask import APIFlask

  app = APIFlask(__name__)


  @app.get('/')
  async def say_hello():
      await asyncio.sleep(1)
      return {'message': 'Hello!'}
  ```

  See <em><a href="https://flask.palletsprojects.com/async-await">Using async and await</a></em> for the details of the async support in Flask 2.0.

  </details>

  Save this as `app.py`, then run it with:

  ```bash
  $ flask run --reload
  ```

  Or run in debug mode:

  ```bash
  $ flask run --debug
  ```

  Now visit the interactive API documentation (Swagger UI) at <http://localhost:5000/docs>:

  ![](https://apiflask.com/_assets/swagger-ui.png)

  Or you can change the API documentation UI when creating the APIFlask instance with the `docs_ui` parameter:

  ```py
  app = APIFlask(__name__, docs_ui='redoc')
  ```

  Now <http://localhost:5000/docs> will render the API documentation with Redoc.

  Supported `docs_ui` values (UI libraries) include:

  - `swagger-ui` (default value): [Swagger UI](https://github.com/swagger-api/swagger-ui)
  - `redoc`: [Redoc](https://github.com/Redocly/redoc)
  - `elements`: [Elements](https://github.com/stoplightio/elements)
  - `rapidoc`: [RapiDoc](https://github.com/rapi-doc/RapiDoc)
  - `rapipdf`: [RapiPDF](https://github.com/mrin9/RapiPdf)

  The auto-generated OpenAPI spec file is available at <http://localhost:5000/openapi.json>. You can also get the spec with [the `flask spec` command](https://apiflask.com/openapi/#the-flask-spec-command):

  ```bash
  $ flask spec
  ```

  For some complete examples, see [/examples](https://github.com/apiflask/apiflask/tree/main/examples).




  APIFlask is a thin wrapper on top of Flask. You only need to remember the following differences (see *[Migrating from Flask](https://apiflask.com/migrations/flask/)* for more details):

  - When creating an application instance, use `APIFlask` instead of `Flask`.
  - When creating a blueprint instance, use `APIBlueprint` instead of `Blueprint`.
  - The `abort()` function from APIFlask (`apiflask.abort`) returns JSON error response.

  For a minimal Flask application:

  ```python
  from flask import Flask, request
  from markupsafe import escape

  app = Flask(__name__)

  @app.route('/')
  def hello():
      name = request.args.get('name', 'Human')
      return f'Hello, {escape(name)}'
  ```

  Now change to APIFlask:

  ```python
  from apiflask import APIFlask  # step one
  from flask import request
  from markupsafe import escape

  app = APIFlask(__name__)  # step two

  @app.route('/')
  def hello():
      name = request.args.get('name', 'Human')
      return f'Hello, {escape(name)}'
  ```

  In a word, to make Web API development in Flask more easily, APIFlask provides `APIFlask` and `APIBlueprint` to extend Flask's `Flask` and `Blueprint` objects and it also ships with some helpful utilities. Other than that, you are actually using Flask.




  APIFlask accepts marshmallow schema as data schema, uses webargs to validate the request data against the schema, and uses apispec to generate the OpenAPI representation from the schema.

  You can build marshmallow schemas just like before, but APIFlask also exposes some marshmallow APIs for convenience:

  - `apiflask.Schema`: The base marshmallow schema class.
  - `apiflask.fields`: The marshmallow fields, contain the fields from both marshmallow and Flask-Marshmallow. Beware that the aliases (`Url`, `Str`, `Int`, `Bool`, etc.) were removed.
  - `apiflask.validators`: The marshmallow validators.

  ```python
  from apiflask import Schema
  from apiflask.fields import Integer, String
  from apiflask.validators import Length, OneOf
  from marshmallow import pre_load, post_dump, ValidationError
  ```



  APIFlask starts as a fork of [APIFairy](https://github.com/miguelgrinberg/APIFairy) and is inspired by [flask-smorest](https://github.com/marshmallow-code/flask-smorest) and [FastAPI](https://github.com/tiangolo/fastapi) (see *[Comparison and Motivations](https://apiflask.com/comparison)* for the comparison between these projects).


pkgId: b078995709c723a7f24b6a0269af132717fac02d8e60592e6d0ce5a5aec68b2e
name: python-ASTAligner-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for ASTAligner
url: https://pypi.org/project/ASTAligner/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ASTAligner-1.0.2-1.src.rpm
location_href: Packages/python-ASTAligner-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Aligns the tokens from a code snippet to their corresponding nodes in an AST representation.



  A Large Language Model (LLM) is a type of AI model designed to understand
  and generate human-like text based on vast amounts of data. Trained on diverse source code datasets, LLMs can automate Software Engineering tasks across various contexts, such as code translation, code summarization, test-case generation, and code completion. A critical component of LLMs is the tokenizer, which breaks down text into smaller units, typically words or subwords, that the model can process. The tokenizer's role is essential because it converts source code into a format the model can understand, ensuring efficient and accurate code processing and generation. In the context of Interpretability for AI, post-hoc techniques such as ASTScore, rely on alienation functions (phi) to match the tokens generated by an LLMâ€™s tokenizer with their corresponding nodes in the AST representation of a snippet. ASTAligner is designed to align tokens from source code snippets to Abstract Syntax Tree (AST) nodes using Tree-sitter for AST generation and various HuggingFace tokenizers for language tokenization. The library supports a wide range of programming languages and Fast tokenizers, enabling precise mapping between source code elements and their AST representations.



  This project has two goals:

  (1) Create a library for aligning the tokens from a code snippet to their corresponding nodes in the AST representation

  (2) Create a tool to visualize the alignment of the tokens with their matching AST.



  For more information regarding this project's background and dependencies, please refer to these readings:

  (1) [Evaluating and Explaining Large Language Models for Code Using
  Syntactic Structures](https://arxiv.org/abs/2308.03873)

  (2) [Tree-Sitter Programming Language Parser](https://github.com/tree-sitter/tree-sitter)

  (3) [Hugging Face Tokenizer](https://huggingface.co/learn/nlp-course/en/chapter2/4)



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install the ASTAligner package.

  ```bash
  pip install ASTAligner
  ```



  * 11 supported languages
      * Python
      * C
      * C++
      * C#
      * Java
      * JavaScript
      * Ruby
      * HTML
      * GO
      * Kotlin
      * Rust
  * 6 Tokenizers
      * [Bert-Base-Uncased](https://huggingface.co/google-bert/bert-base-uncased)
      * [CodeLlama](https://huggingface.co/docs/transformers/main/en/model_doc/code_llama)
      * [GPT2](https://huggingface.co/docs/transformers/en/model_doc/gpt2)
      * [DialoGPT](https://huggingface.co/microsoft/DialoGPT-small)
      * [Roberta-Base](https://huggingface.co/FacebookAI/roberta-base)
      * [Qwen](https://huggingface.co/Qwen/Qwen2-7B-Instruct)




  Using the ASTalign method asks that the user provide:
  * A snippet of `code` as a string, or a filepath to a text file containing code.
  * The `language` of the code snippet as one of the following strings:
      * python
      * c
      * cpp
      * csharp
      * java
      * javascript
      * ruby
      * html
      * go
      * kotlin
      * rust
      * haskell
  * A `tokenizer` specification as one of the following strings:
      * codellama
      * gpt2
      * bert-base-uncased
      * roberta-base
      * dialogpt
      * qwen
  * OR as an [AutoTokenizer compliant name or path](https://huggingface.co/docs/transformers/en/model_doc/auto#transformers.AutoTokenizer) for access to tokenizers available through the Hugging Face model hub.
  * (Optional) A tokenizer object can be passed into the `tokenizer` field when using the library through PyPI. It is recommended that users utilize the preset tokenizer strings, as custom tokenizers are not guaranteed to work as intended.
  * (Optional) `include_whitespace_and_special_tokens` flag. Set to False by default, this flag allows the user to specify whether or not to show whitespaces and special characters in the tokens.

  The method returns a dictionary of TSTree nodes to a list of tokens from the code snippet that overlap with those nodes. Example usage:

  `alignments[node]` yields `[tok1, tok2, ... , tokn]`



  The printAlignmentsTree method recursively prints out an entire tree with the provided node as the root of the tree. The method prints the type of each node and the tokens that are aligned to it. This method returns nothing.

  Using the method asks that the user provide:
  * A node inside the tree (such as the root node)
  * The alignments object returned by ASTalign

  Example usage:

  ```python
  test = r"""x = y + z"""
  alignments = ASTalign(test, 'python', "bert-base-uncased")
  root = getRootNode(alignments)
  printAlignmentsTree(root, alignments)
  ```
  Output:
  ```
  -> 0  'module'
        ['x', '=', 'y', '+', 'z']

      -> 1  'expression_statement'
            ['x', '=', 'y', '+', 'z']

          -> 2  'assignment'
                ['x', '=', 'y', '+', 'z']

              -> 3  'identifier'
                    ['x']

              -> 3  '='
                    ['=']

              -> 3  'binary_operator'
                    ['y', '+', 'z']

                  -> 4  'identifier'
                        ['y']

                  -> 4  '+'
                        ['+']

                  -> 4  'identifier'
                        ['z']
  ```




  The printAlignmentsNode method prints out the type of the provided node and the tokens that are aligned to it. This method returns nothing.

  Using the method asks that the user provide:
  * A node inside the tree (such as the root node)
  * The alignments object returned by the ASTalign method

  Example Usage:

  ```python
  test = r"""x = y + z"""
  alignments = ASTalign(test, 'python', "bert-base-uncased")
  root = getRootNode(alignments)
  printAlignmentsTree(root, alignments)
  ```
  Output:
  ```
  module
  ['x', '=', 'y', '+', 'z']
  ```


  The getRootNode method returns the root node of the tree from the provided alignments object.

  Using the method asks that the user provide:
  * An alignments object created by the ASTalign method

  Example Usage:
  ```python
  test = r"""x = y + z"""
  alignments = ASTalign(test, 'python', "bert-base-uncased")
  root = getRootNode(alignments)
  ```




  The rangeFinder method returns an index range (start, end] for a TSTree node in a string.

  Using the method asks that the user provide:

  * The `range` of a TSTree node.
  * A snippet of `code` as a string, or a filepath to a text file containing code.

  Example usage:

  If a node `identifier_node` corresponds to `num` in the code string `snippet = "num = 1"`, then
  ```
  rangeFinder(identifier_node.range, snippet)
  ```
  yields tuple `(0, 3)`.



  The ASTtokenFinder method takes an index range in a string of code (as tuple), a code snippet, a language, and a tokenizer, and returns a dictionary mapping nodes _whose text overlaps with the range_ to their tokens.

  Note that the method constructs an alignments dictionary from the provided code before selecting the target nodes from the resulting alignments.

  Using the method asks that the user provide:

  * An index `range` in a code string as (start, end].
  * A snippet of `code` as a string, or a filepath to a text file containing code.
  * The `language` of the code snippet as a string (see [ASTalign](#ASTalign) section for language strings).
  * A `tokenizer` specification as a string (see [ASTalign](#ASTalign) section for tokenizer strings).
  * (Optional) `include_whitespace_and_special_tokens` flag. Set to False by default, this flag allows the user to specify whether or not to show whitespaces and special characters in the tokens.
  * (Optional) `use_fast` flag. Set to True by default, this flag allows the user to specify whether or not to use the Fast (if available) or Slow implementation of the chosen tokenizer.


  Example usage:

  If a code string `snippet = "num = 1"` produces a tree of the form
  ```
  | assignment_expr -> "num = 1"
  --| identifier -> "num"
  --| assignment_op -> "="
  --| value -> "1"
  ```
  then
  ```
  ASTtokenFinder((0,3), snippet, language, tokenizer)
  ```
  may yield

  ```
  {assignment_exp : ['num', '=', '1'], identifier : ['num']}
  ```

  as the text of the `assignment_exp` and `identifier` nodes overlap the range (0, 3] in the code string.



  Semeru Lab ASTAligner Team: Lillie Ayer, Cassie Baker, Daniel Biedron, Peter Buddendeck,Cristian Charette-Lopez,and Stephen Ramotowski



  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 1041e071ddb8068488ac572090760e104e10bb9c17fc5b31ed8b854150756df2
name: python-AcraNetwork-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for AcraNetwork
url: https://github.com/diarmuidcwc/AcraNetwork
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AcraNetwork-1.0.0-1.src.rpm
location_href: Packages/python-AcraNetwork-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/acranetwork/badge/?version=latest)](https://acranetwork.readthedocs.io/en/latest/?badge=latest)
  ![Python App](https://github.com/diarmuidcwc/AcraNetwork/actions/workflows/python-app.yml/badge.svg)
  ![Python Published](https://github.com/diarmuidcwc/AcraNetwork/actions/workflows/python-publish.yml/badge.svg)
  ![PyPI](https://img.shields.io/pypi/v/AcraNetwork?label=pypi%20package)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/AcraNetwork)

  A collection of classes that can be used to decom network or PCM based FTI traffic. This module contains classes to handle various packet formats like, iNetX, IENA, Chapter10, DARv3 (NPD).

  It also contains a class to decom data from a SAM/DEC/008

  Full documentation is available here https://acranetwork.readthedocs.io/en/latest/



  * iNetX : Class for packing and unpacking iNetX objects
  * IENA  : Class for packing and unpacking IENA objects
  * SimpleEthernet : A  simplified set of classes for Ethernet, IP and UDP packets. These are not fully featured is sufficient for the network systems used in the KAM500 networks
  * Pcap : Class and helper methods for reading pcap files
  * Chapter10: Class for chapter10 and chapter11 packets
  * MPEGTS: MpegTransport stream packets




  Install using pip

  ```bash
  pip install AcraNetwork
  ```



  Browse the example folder for some example usage



  ```bash
  pip install pytest
  pytest
  pytest --doctest-modules AcraNetwork
  ```



  ```bash
  pip  install --upgrade pip wheel setuptools twine
  rm dist/*
  python ./setup.py sdist bdist_wheel --universal sdist
  twine upload dist/*
  ```


pkgId: 7958012370de4925c51028ee21afe5c810216e66271660fc6301d3c5a3a866f0
name: python-AlistMediaRename-help
arch: noarch
version: 3.0.2
epoch: 0
release: 1
summary: Development documents and examples for AlistMediaRename
url: https://pypi.org/project/AlistMediaRename/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AlistMediaRename-3.0.2-1.src.rpm
location_href: Packages/python-AlistMediaRename-help-3.0.2-1.noarch.rpm
checksum_type: sha256
description:
  从 The Movie Database(TMDb) 获取剧集/电影信息，并对 Alist 指定媒体文件重命名，便于播放器刮削识别剧集/电影。测试Kodi, Nplayer, Infuse均可正确识别媒体信息。

  ![](./tutorial.gif)





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





  **环境要求**

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

  **使用`pip`安装**

  ```shell

  pip install AlistMediaRename

  pip install --upgrade AlistMediaRename
  ```

  **使用`pipx`安装**

  ```shell



  pipx install AlistMediaRename

  pipx upgrade AlistMediaRename
  ```

  **使用`uv`安装**

  ```shell



  uv tool install AlistMediaRename

  uv tool upgrade AlistMediaRename
  ```

  **本地运行**

  ```shell

  git clone https://github.com/jkoor/Alist-Media-Rename.git

  cd Alist-Media-Rename

  pip install .
  ```





  **获取 TMDb API 密钥**

  首次运行会要去输入 TMDb API 密钥， 用于获取 TMDb 电影/剧集信息，可前往 [TMDb 开发者网站](https://www.themoviedb.org/settings/api)免费申请。

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

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

  **基本命令**

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

  ```shell

  amr [剧集关键字] -d [Alist 文件夹路径]


  amr [剧集id] -d [Alist 文件夹路径] -i


  amr [电影关键字] -d [Alist 文件夹路径] -m
  amr [电影id] -d [Alist 文件夹路径] -m -i


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


  amr [剧集关键字] -d [Alist 文件夹路径] -n [集号]

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1-

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1-4

  amr [剧集关键字] -d [Alist 文件夹路径] -n 2,3

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1,3-5,7,10-


  amr -h
  ```

  **举个例子**

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

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

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

  ```shell


  amr 刀剑神域 -d /阿里云盘/动漫/SAO


  amr -i 45782 -d /阿里云盘/动漫/SAO -p 123
  ```

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

  ```shell

  amr -m 刀剑神域 -d /阿里云盘/电影/SAO


  amr -m -i 413594 -d /阿里云盘/电影/SAO -p 123
  ```





  **运行参数**

  | 参数           | 必填 |      默认       | 说明                           |
  | -------------- | :--: | :-------------: | ------------------------------ |
  | keyword        |  ☑   |                 | TMDb 搜索字段                  |
  | -d             |  ☑   |                 | Alist 文件夹路径               |
  | --folder / --no-folder |  |  | 是否对父文件夹进行重命名 |
  | -i, --id       |      |                 | 根据 TMDb id 获取剧集/电影信息 |
  | -m, --movie    |      |                 | 查找电影信息，而不是剧集       |
  | -p, --password |      |     *None*      | Alist 文件夹访问密码           |
  | -n, --number   |      |                 | 指定集号进行重命名           |
  | -c, --config   |      | ./*config.yaml* | 指定配置文件路径               |
  | -h, --help     |      |                 | 显示使用帮助信息               |
  | -v, --version  |      |                 | 显示版本信息                   |

  **配置文件**

  配置文件`config.yaml`默认保存在当前运行目录中，除基本的登录参数外，还包含几个可配置项，根据注释修改即可。

  参考 [default.yaml](https://github.com/jkoor/Alist-Media-Rename/blob/main/src/AlistMediaRename/default.yaml)






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

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

  ```python
  from AlistMediaRename import Amr, Config


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

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


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

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

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

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

  ```





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

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

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

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

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


pkgId: 301e06d150c5efee2b766ab26ed882d8de8b50e1400c27a319245778673fd2ed
name: python-AlistMediaRename-help
arch: noarch
version: 3.1.2
epoch: 0
release: 1
summary: Development documents and examples for AlistMediaRename
url: https://pypi.org/project/AlistMediaRename/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AlistMediaRename-3.1.2-1.src.rpm
location_href: Packages/python-AlistMediaRename-help-3.1.2-1.noarch.rpm
checksum_type: sha256
description:
  从 The Movie Database(TMDb) 获取剧集/电影信息，并对 Alist 指定媒体文件重命名，便于播放器刮削识别剧集/电影。测试Kodi, Nplayer, Infuse均可正确识别媒体信息。

  ![](./tutorial.gif)





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





  **环境要求**

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

  **使用`pip`安装**

  ```shell

  pip install AlistMediaRename

  pip install --upgrade AlistMediaRename
  ```

  **使用`pipx`安装**

  ```shell



  pipx install AlistMediaRename

  pipx upgrade AlistMediaRename
  ```

  **使用`uv`安装**

  ```shell



  uv tool install AlistMediaRename

  uv tool upgrade AlistMediaRename
  ```

  **本地运行**

  ```shell

  git clone https://github.com/jkoor/Alist-Media-Rename.git

  cd Alist-Media-Rename

  pip install .
  ```





  **获取 TMDb API 密钥**

  首次运行会要去输入 TMDb API 密钥， 用于获取 TMDb 电影/剧集信息，可前往 [TMDb 开发者网站](https://www.themoviedb.org/settings/api)免费申请。

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

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

  **基本命令**

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

  ```shell

  amr [剧集关键字] -d [Alist 文件夹路径]


  amr [剧集id] -d [Alist 文件夹路径] -i


  amr [电影关键字] -d [Alist 文件夹路径] -m
  amr [电影id] -d [Alist 文件夹路径] -m -i


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


  amr [剧集关键字] -d [Alist 文件夹路径] -n [集号]

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1-

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1-4

  amr [剧集关键字] -d [Alist 文件夹路径] -n 2,3

  amr [剧集关键字] -d [Alist 文件夹路径] -n 1,3-5,7,10-


  amr -h
  ```

  **举个例子**

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

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

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

  ```shell


  amr 刀剑神域 -d /阿里云盘/动漫/SAO


  amr -i 45782 -d /阿里云盘/动漫/SAO -p 123
  ```

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

  ```shell

  amr -m 刀剑神域 -d /阿里云盘/电影/SAO


  amr -m -i 413594 -d /阿里云盘/电影/SAO -p 123
  ```





  **运行参数**

  | 参数           | 必填 |      默认       | 说明                           |
  | -------------- | :--: | :-------------: | ------------------------------ |
  | keyword        |  ☑   |                 | TMDb 搜索字段                  |
  | -d             |  ☑   |                 | Alist 文件夹路径               |
  | --folder / --no-folder |  |  | 是否对父文件夹进行重命名 |
  | -i, --id       |      |                 | 根据 TMDb id 获取剧集/电影信息 |
  | -m, --movie    |      |                 | 查找电影信息，而不是剧集       |
  | -p, --password |      |     *None*      | Alist 文件夹访问密码           |
  | -n, --number   |      |                 | 指定集号进行重命名           |
  | -c, --config   |      | ./*config.yaml* | 指定配置文件路径               |
  | -h, --help     |      |                 | 显示使用帮助信息               |
  | -v, --version  |      |                 | 显示版本信息                   |
  | --verbose | | | 显示详细输出日志 |

  **配置文件**

  配置文件`config.yaml`默认保存在当前运行目录中，除基本的登录参数外，还包含几个可配置项，根据注释修改即可。

  参考 [default.yaml](https://github.com/jkoor/Alist-Media-Rename/blob/main/src/AlistMediaRename/default.yaml)






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

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

  ```python
  from AlistMediaRename import Amr, Config


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

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


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

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

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

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

  ```





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

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

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

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

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


pkgId: 6e2b5a527d29c401b688693794723a382157215310c614cb812bb885ce980cc5
name: python-AnimeScraper-help
arch: noarch
version: 1.1.4
epoch: 0
release: 1
summary: Development documents and examples for AnimeScraper
url: https://github.com/togashigreat/AnimeScraper
rpm_license: GPL-V3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AnimeScraper-1.1.4-1.src.rpm
location_href: Packages/python-AnimeScraper-help-1.1.4-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  ![AnimeScraper Logo](./docs/assets/animescrapper.png)


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


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

  </div>




  - Fetch detailed anime and character details
  - Asynchronous Fast data retrieval
  - Caching
  - Easy-to-use API
  - Fully typed and documented
  - Supports Synchronous as well
  - Comes with a Cli too
  - FastAPI Server with Caching config




  You can install AnimeScraper using pip:

  ```bash
  pip install animescraper
  ```


  You can use AnimeScraper in your command line too. Type `animescraper` for Usage. Available commands `search-anime`, `get-anime`, `search-character` etc. look at the Documentation for more information.

  **Example:**

  <div align="center">

  ![AnimeScraper Cli Demo](./docs/assets/cli_demo_rikka.jpg)
  ![AnimeScraper Cli Demo](./docs/assets/cli_demo_anime.jpg)

  </div>







  This library supports both Synchronous and Asynchronous.

  **Searching and Fetching Anime**

  ```python
  from AnimeScraper import SyncKunYu

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

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

  ```
  **Searching and fetching Character**

  ```python
  from AnimeScraper import SyncKunYu

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

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





  **Searching Anime**

  ```python
  import asyncio
  from AnimeScraper import KunYu

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

  asyncio.run(main())
  ```


  **Searching Character**

  ```python
  import asyncio
  from AnimeScraper import KunYu

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

  asyncio.run(main())
  ```


  **Fetching Anime details**

  ```python
  import asyncio
  from AnimeScraper import KunYu

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

  asyncio.run(main())

  ```



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



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




  - Python 3.10+
  - aiohttp
  - httpx
  - pydantic
  - uvicorn



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


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



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


pkgId: ad077367e3360f07b0f180a98ea3c6f1d0bab53a0b03240f1c9df557c8723c34
name: python-AnomalyLab-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for AnomalyLab
url: https://pypi.org/project/AnomalyLab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AnomalyLab-0.3.1-1.src.rpm
location_href: Packages/python-AnomalyLab-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Chen Haiwei, Deng Haotian



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

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

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

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



  The package can be installed via:

  ```bash
  pip install anomalylab
  ```


pkgId: e7d47f618d6c3308f9203b75ed682eefcbd38e602fd5f689e371d3f38c5e4fab
name: python-AppOpenWeather-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for AppOpenWeather
url: https://github.com/nasirdn/prog/tree/main/sem5/lr3
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AppOpenWeather-0.1-1.src.rpm
location_href: Packages/python-AppOpenWeather-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  Приложение для получения данных о погоде с OpenWeather API
  Ссылка на GitHub:



  ```
  pip install AppOpenWeather
  ```


pkgId: e7aaf3e042c4df0562c6404c4d29c1b26be9860c18103b6d64078641ad7ad0c0
name: python-AppleMusicMP3-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for AppleMusicMP3
url: https://github.com/afriedsam/AppleMusicMP3
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AppleMusicMP3-0.1.0-1.src.rpm
location_href: Packages/python-AppleMusicMP3-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - Fetches song and artist details from Apple Music playlists.
  - Searches YouTube for matching audio content (e.g., "Official Audio").
  - Downloads the audio and saves it in **MP3 format**.
  - Provides a progress bar for each step of the process.


pkgId: c76d79506f0514c3aa76cc2c2b96df4849720b6f33075111268b7e2ffdd5927e
name: python-ArticleAnalyst-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for ArticleAnalyst
url: https://github.com/shi4712shi/ArticleAnalyst/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ArticleAnalyst-0.0.4-1.src.rpm
location_href: Packages/python-ArticleAnalyst-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  This is a package to process large-scale article data downloaded from PubMed.


  ___

  There are some contents to introduce workflow and functions for Article


  There are some contents to introduce workflow and functions for Article


  ___

  <ul>
      <li>Optimize logic for downloader creation </li>
  </ul>


  <ul>
      <li>Fix bugs in MeshAnalyst.returnIsInArticles</li>
      <li>Fix bugs in ArticleAnalyst.__init__</li>
      <li>Allow pass a MeSHDAG object when setMeSHDAG with meshAnalyst</li>
      <li>Fix bugs in functions.downloader.__eLink</li>
  </ul>


pkgId: c2cb37cd4257736f103753995d4093a335e9f4595d2e4c2c8e4660cdd7727eaa
name: python-AsmaGuiza-DATALIB-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for AsmaGuiza-DATALIB
url: https://pypi.org/project/AsmaGuiza-DATALIB/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AsmaGuiza-DATALIB-0.1.0-1.src.rpm
location_href: Packages/python-AsmaGuiza-DATALIB-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **DataLib** est une bibliothÃ¨que Python simple pour la manipulation, l'analyse et la visualisation des donnÃ©es. Elle fournit des outils pratiques pour normaliser des donnÃ©es, gÃ©rer les valeurs manquantes, calculer des statistiques descriptives et crÃ©er des visualisations courantes.



  - **Chargement et traitement des donnÃ©es** :
    - Chargement de fichiers CSV.
    - Normalisation des colonnes numÃ©riques.
    - Gestion des valeurs manquantes (remplissage ou suppression).

  - **Statistiques descriptives** :
    - Calcul de la moyenne, mÃ©diane et Ã©cart-type.
    - Analyse des corrÃ©lations entre colonnes.

  - **Visualisation** :
    - Histogrammes.
    - Matrices de corrÃ©lation.



  Vous pouvez installer la bibliothÃ¨que directement via pip aprÃ¨s publication sur PyPI :

  ```bash
  pip install datalib
  ```






  **Charger un fichier CSV :**

  ```python
  import DataLib

  data = DataLib.load_csv("path_to_file.csv")
  ```

  **Normaliser les colonnes numÃ©riques :**

  ```python
  normalized_data = DataLib.normalize(data)
  ```

  **GÃ©rer les valeurs manquantes (remplissage avec la moyenne) :**

  ```python
  clean_data = DataLib.fill_missing_values(normalized_data, method='mean')
  ```



  **Calculer la moyenne, la mÃ©diane et l'Ã©cart-type :**

  ```python
  mean = DataLib.mean(data)
  median = DataLib.median(data)
  std_dev = DataLib.std(data)
  ```

  **Analyser les corrÃ©lations entre les colonnes :**

  ```python
  correlation_matrix = DataLib.correlation(data)
  ```



  **CrÃ©er un histogramme pour une colonne spÃ©cifique :**

  ```python
  DataLib.plot_histogram(data, column='age')
  ```

  **CrÃ©er une matrice de corrÃ©lation :**

  ```python
  DataLib.plot_correlation_matrix(data)
  ```
  ```


pkgId: 5b65712a44bc545cba92177160fb549d1b0ad2442af7f37174b9f4b0ff0ba0fe
name: python-AudiooPy
arch: noarch
version: 0.5
epoch: 0
release: 1
summary: Audio manager in Python Object-Oriented Programming
url: https://audioopy.sourceforge.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AudiooPy-0.5-1.src.rpm
location_href: Packages/python-AudiooPy-0.5-1.noarch.rpm
checksum_type: sha256
description:
     █████╗  ██╗   ██╗ ██████╗  ██╗  ██████╗   ██████╗  ██████╗  ██╗   ██╗
    ██╔══██╗ ██║   ██║ ██╔══██╗ ██║ ██╔═══██╗ ██╔═══██╗ ██╔══██╗ ╚██╗ ██╔╝
    ███████║ ██║   ██║ ██║  ██║ ██║ ██║   ██║ ██║   ██║ ██████╔╝  ╚████╔╝
    ██╔══██║ ██║   ██║ ██║  ██║ ██║ ██║   ██║ ██║   ██║ ██╔═══╝    ╚██╔╝
    ██║  ██║ ╚██████╔╝ ██████╔╝ ██║ ╚██████╔╝ ╚██████╔╝ ██║         ██║
    ╚═╝  ╚═╝  ╚═════╝  ╚═════╝  ╚═╝  ╚═════╝   ╚═════╝  ╚═╝         ╚═╝
          an Audio manager in Python Object-Oriented Programming
                  Copyright (C) 2024 Brigitte Bigi, CNRS

rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 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 Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are 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.  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.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  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 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 work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero 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 Affero 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 Affero 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 Affero 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) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  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 Affero General Public License for more details.  You should have received a copy of the GNU Affero 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 your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.  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 AGPL, see <https://www.gnu.org/licenses/>.


pkgId: 94d4f760be5314f39000cd867a0e69ae9dfbb731026aed6e275ed1b3b4bc8e53
name: python-AutoWZRY-help
arch: noarch
version: 2.3.0a3
epoch: 0
release: 1
summary: Development documents and examples for AutoWZRY
url: https://github.com/cndaqiang/WZRY
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AutoWZRY-2.3.0a3-1.src.rpm
location_href: Packages/python-AutoWZRY-help-2.3.0a3-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1 align="center">
      <img src="http://wzry-doc.pages.dev/wzry.favicon.png" width="140">
      <br/>
      WZRY · 农活自动化助手
    </h1>
  </div>
  <div align="center">
    <img alt="WZRY Release" src="https://img.shields.io/github/v/release/cndaqiang/WZRY?style=flat-square&color=ff7fbf&label=WZRY" />
    <img alt="Stars" src="https://img.shields.io/github/stars/cndaqiang/WZRY?style=flat-square&color=66bb6a&label=Stars" />
    <img alt="Developer" src="https://img.shields.io/badge/cndaqiang-blue?style=flat-square&color=4096d8&label=Developer" />
  </div>

  <div align="center">
  使用方法, 请访问: <a href="https://wzry-doc.pages.dev">使用手册</a>.
  <br/>
  遇到问题, 请在提问前查看: <a href="https://wzry-doc.pages.dev/qa/qa/">常见问题</a>.
  </div>



  [WZRY](https://github.com/cndaqiang/WZRY)是基于[airtest-mobileauto](https://github.com/cndaqiang/airtest_mobileauto)开发的王者荣耀农活自动化免费开源脚本.



  真正的无人值守：自动对战、领取礼包、更新游戏、错误纠正

  * 开启关闭模拟器、容器、手机
  * 自动检测处理游戏闪退、模拟器关闭等各种错误
  * 健康系统自动休息启动
  * 自动切换熟练度,优先星耀人机模式,次数达到上限后切换青铜人机
  * 自动调整分路并选择熟练度最低的英雄



  5v5人机单人模式、组队模式、标准模式、快速模式、星耀难度、青铜难度

  - 挂机模式: 适合完成每日任务、战令任务、**提高熟练度**
  - TOUCH模式(移动+平A): 适合完成活动的**标准对战非挂机**对战要求

  王者模拟战单人模式、组队模式

  - 刷信誉分专用, 每日上限+5分.
  - 战令的每期任务: 20场娱乐模式, 可以用模拟战刷齐





  * 友情对战: 友情币领取、奖励兑换
  * 邮件礼包: 好友邮件、系统邮件
  * 妲己一键领奖
  * 战令礼包、战令任务礼包
  * 回忆礼册、灵宝互动
  * 祈愿页面领取祈愿币、玉镖夺魁的飞镖
  * 王者营地礼包
  * 王者体验服礼包
  * KPL观赛战令观赛领取经验升级
  * 战队商店领取英雄碎片
  * 商城每日免费钻石碎片随机礼包


  - *[Cloudiiink](https://github.com/Cloudiiink) 正在设计制作全新的项目图标，版权归其所有。*
    特别感谢 Cloudiiink 的精心创作！

  - 灵感和支持来自以下项目：
    - [airtest_mobileauto](https://github.com/cndaqiang/airtest_mobileauto)
    - [WZRY_AirtestIDE](https://github.com/XRSec/WZRY_AirtestIDE)
    - [Airtest Project](https://github.com/AirtestProject)

  - 感谢所有提问 issue 和为本项目打星的用户！


pkgId: 71e2f575c50f8b37a8970a7d92c19b97a499d6365b22b33656a49baf6f36572c
name: python-AutoWoE-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for AutoWoE
url: https://github.com/AILab-MLTools/AutoMLWhitebox
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AutoWoE-1.4.0-1.src.rpm
location_href: Packages/python-AutoWoE-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/autowoe?color=green&label=PyPI%20downloads&logo=pypi&logoColor=orange&style=plastic)


  This is the repository for **AutoWoE** library, developed by LightAutoML group. This library can be used for automatic creation of interpretable ML model based on feature binning, WoE features transformation, feature selection and Logistic Regression.

  **Authors:** Vakhrushev Anton, Grigorii Penkin, Alexander Kirilin

  **Library setup** can be done by one of three scenarios below:

  1. Installation from PyPI:
  ```bash
  pip install autowoe
  ```
  2. Installation from source code

  First of all you need to install [git](https://git-scm.com/downloads) and [poetry](https://python-poetry.org/docs/#installation).

  ```bash


  git clone https://github.com/AILab-MLTools/AutoMLWhitebox.git

  cd AutoMLWhiteBox/




  poetry config virtualenvs.in-project true


  poetry config virtualenvs.create false --local




  poetry install

  ```


  **Usage tutorials** are in Jupyter notebooks in the repository root. For **parameters description** take a look at `parameters_info.md`.

  **Bugs / Questions / Suggestions:**:
  - Vakhrushev Anton (btbpanda@gmail.com)


pkgId: b688b7981f2d4730d7815b14798d742210306c1fd68e4db77287e9383dd15864
name: python-AveyTense
arch: noarch
version: 0.3.32
epoch: 0
release: 1
summary: Library written in Python, includes several extensions for inbuilt Python solutions
url: https://aveyzan.glitch.me/tense/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AveyTense-0.3.32-1.src.rpm
location_href: Packages/python-AveyTense-0.3.32-1.noarch.rpm
checksum_type: sha256
description:
  **AveyTense** (formally *Tense*) is a library written by Aveyzan using Python, which provides especially extensions to inbuilt Python solutions.




  - the `abroad()` function being extended version of `range()` inbuilt Python function
  - the `reckon()` function being extended version of `len()` inbuilt Python function
  - the `Math` class featuring same and more math methods than `math` inbuilt Python module
  - the `Time` class featuring several time management methods using `datetime` inbuilt Python module
  - the `Tense` class featuring all methods from `Math` and `Time`, as well as `probability()` class method,
    methods for disassembling code, randomizing results, personalized `print()` and `input()` inbuilt functions
    implementations, methods for checking and converting
  - the `Color` class, which colorizes the output and features several font decorations as in ANSI, and supports
    `RGB` and `CMYK` class instances



  - the `tense.constants` submodule featuring some math constants, as well as some from gaming and Tense versions
  - the `tense.fencord` submodule featuring several Discord.py solutions
  - the `tense.games` submodule featuring class `Games`, which has some Tic-Tac-Toe methods and `mcEnchBook()` for
    generating Minecraft `/give enchanted_book` commands
  - the `tense.operators` submodule being extension of `operator` inbuilt Python module
  - the `tense.types_collection` submodule, which contains utility types from `typing`, `enum`, `types`, `inspect`,
    `subprocess` inbuilt Python modules, and from `typing_extensions` PyPi project



  To install AveyTense, you only need to have Python 3.9 or above, and run the following command:

  ```
  pip install AveyTense
  ```

  If you are out-of-date, consider checking out [releases section](https://pypi.org/project/AveyTense/#history), then
  use this command in the following way: `pip install AveyTense==<version>`, like `pip install AveyTense==0.3.31`.

  > **Note**: It is highly recommended to install latest final version of AveyTense. Do not rely on alpha, beta releases, and
  > release candidates before their final counterparts are published.

  > **Warning**: Since AveyTense 0.3.30, archive files will no longer be available on [this page](https://aveyzan.glitch.me/tense),
  > due to expiry of formula after orienting publication of next versions to PyPi. Instead of providing change log via file
  > `./tense/information/changes.txt` normally included in zip/7-zip files, changes will be now provided in [this Google document](https://docs.google.com/document/d/1GC_KAOXML65jNfBZA8GhVViqPnrMoFtbLv_jHvUhBlg/edit?usp=sharing).

  Next step, after installation process, open a Python file and simply do the following import, whenever you like;
  the all-important module included in AveyTense is `tense`.



  ```py
  from tense import *

  print(Color("Hello World!", 8, 69) % Color.BOLD_ITALIC_UNDERLINE)


  print(Tense.repeat(33, 3))


  ```


pkgId: 0af3876bd28055f877be8f52a7e6aa87ef80d8cf86cca41ef13a106313025832
name: python-AxonDeepSeg
arch: noarch
version: 4.9999999
epoch: 0
release: 1
summary: Python tool for automatic axon and myelin segmentation
url: https://github.com/neuropoly/axondeepseg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-AxonDeepSeg-4.9999999-1.src.rpm
location_href: Packages/python-AxonDeepSeg-4.9999999-1.noarch.rpm
checksum_type: sha256
description:
  Pipy installation of AxonDeepSeg is no longer supported, please visit https://github.com/axondeepseg/axondeepseg for installation isntructions.


pkgId: b67f94118e11ebd80f3555dec5181598159ed0783746e37026405e4afdb0a5d8
name: python-BMINet-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for BMINet
url: https://github.com/Spencer-JRWang/BMINet
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BMINet-0.1.4-1.src.rpm
location_href: Packages/python-BMINet-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  <div style="display: flex; justify-content: space-between; align-items: center;">
      <img src="https://raw.githubusercontent.com/Spencer-JRWang/BMINet/main/Example/LOGO.png" alt="Organization Logo" style="width: 100px; height: auto; margin-left: 20px;">
  </div>


pkgId: 33f4067a1b10037627afdee31f71c5ebd9ac8bef7d368967c212d4d80a4866fb
name: python-BOOK-NLP-fr-help
arch: noarch
version: 10000.100.31
epoch: 0
release: 1
summary: Development documents and examples for BOOK-NLP-fr
url: https://github.com/pypa/sampleproject
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BOOK-NLP-fr-10000.100.31-1.src.rpm
location_href: Packages/python-BOOK-NLP-fr-help-10000.100.31-1.noarch.rpm
checksum_type: sha256
description:
  This is a simple example package. You can use
  [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.


pkgId: 8d0cb386f56873c2f2a96bc251e992566c843da7a24364e7e3ef256af7546d8b
name: python-BeatPrints-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for BeatPrints
url: https://github.com/TrueMyst/BeatPrints
rpm_license: CC-BY-NC-4.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BeatPrints-1.0.2-1.src.rpm
location_href: Packages/python-BeatPrints-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  <h3 align="center">
      <img src="https://i.ibb.co/CWY693F/beatprints-logo.png" width="175"/>
  </h3>
  <h3 align="center">
      BeatPrints: Quick, stylish posters for your favorite tracks! 🎷☕️
  </h3>

  <p align="center">Create eye-catching, Pinterest-style music posters effortlessly. BeatPrints integrates with <b>Spotify</b> and <b>LRClib API</b> to help you design custom posters for your favorite tracks or albums. 🍀</p>

  <p align="center">
    <a href="https://gitHub.com/TrueMyst/BeatPrints/graphs/commit-activity">
      <img src="https://img.shields.io/badge/Maintained%3F-Yes-%23c4b9a6?style=for-the-badge&logo=Undertale&logoColor=%23b5a790&labelColor=%23312123" alt="Maintenance"></a>
    <a href="https://github.com/TrueMyst/BeatPrints/stargazers">
      <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/TrueMyst/BeatPrints?style=for-the-badge&logo=Apache%20Spark&logoColor=%23b5a790&labelColor=%23312123&color=%23c4b9a6"></a>
    <a href="https://github.com/psf/black">
      <img src="https://img.shields.io/badge/Code_Style-black-%23c4b9a6?style=for-the-badge&logo=CodeFactor&logoColor=%23b5a790&labelColor=%23312123" alt="Code Formatter"></a>
    <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
      <img alt="Static Badge" src="https://img.shields.io/badge/License-CC_BY--NC--SA_4.0-%23c4b9a6?style=for-the-badge&logo=Pinboard&logoColor=%23b5a790&labelColor=%23312123"></a>
  </p>

  ![examples](https://i.ibb.co.com/y0jKqHK/banner.png)

  <h3 align="center">📔 Check out the new documentation <a href="https://beatprints.readthedocs.io/en/latest/">here!</a></h3>



  You can install BeatPrints via `pip`:

  ```bash
  pip install BeatPrints
  ```

  Or, if you use Poetry:

  ```bash
  poetry add BeatPrints
  ```



  To get started with BeatPrints, you’ll need a `.env` file with these keys:

  ```env
  SPOTIFY_CLIENT_ID = "<your-client-id>"
  SPOTIFY_CLIENT_SECRET = "<your-client-secret>"
  ```

  You can get these from the [Spotify Developer Dashboard](https://developer.spotify.com/dashboard/) by creating a new app with **Web API** as the scope.




  Here’s how you can create your first poster:

  ```python
  import os, dotenv
  from BeatPrints import lyrics, poster, spotify

  dotenv.load_dotenv()


  CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID")
  CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET")


  ly = lyrics.Lyrics()
  ps = poster.Poster("./")
  sp = spotify.Spotify(CLIENT_ID, CLIENT_SECRET)


  search = sp.get_track("Saturn by SZA", limit=1)


  metadata = search[0]
  lyrics = ly.get_lyrics(metadata)
  highlighted_lyrics = ly.select_lines(lyrics, "5-9")


  ps.track(metadata, highlighted_lyrics)
  ```



  To get started with the BeatPrints CLI, you'll need to set up a configuration file.



  1. Create a folder named `BeatPrints` in the following directory:

  ```python
  C:\Users\<YourUsername>\AppData\Roaming\BeatPrints\
  ```

  2. Inside this folder, create a file called `config.toml` with the following contents:

  ```toml
  [general]
  search_limit = 7
  output_directory = "<path-to-save-your-posters>"

  [credentials]
  client_id = "your-client-id"
  client_secret = "your-client-secret"
  ```

  Replace `<path-to-save-your-posters>` with the path where you'd like to save the generated posters, and fill in the `client_id` and `client_secret` with your Spotify credentials.



  1. Create a folder named `BeatPrints` in your `~/.config/` directory:

  ```python
  ~/.config/BeatPrints/
  ```

  3. Inside this folder, create a file called `config.toml` with the same contents as mentioned above.



  Once the config file is set up, you can run the BeatPrints CLI:

  1. Open your terminal.
  2. Type `beatprints` and press Enter.

  Your poster will be saved in the output directory you specified in the `config.toml` file.



  Here are a few posters created with BeatPrints:

  | **Track: Saturn by SZA**                                             | **Album: Charm by Clairo**                                             |
  | -------------------------------------------------------------------- | ---------------------------------------------------------------------- |
  | ![Track Example](https://i.ibb.co.com/q5v8J9R/saturn-by-sza-1e3.png) | ![Album Example](https://i.ibb.co.com/TcrKKXV/charm-by-clairo-f8a.png) |

  For more examples, check out the [examples directory](https://github.com/TrueMyst/BeatPrints/tree/main/examples).




  - **Polaroid Filter for Covers**: Give your track or album covers a vintage Polaroid look.
  - **Multi-language Support**: Supports English, Hindi, Russian, Japanese, Chinese, and Korean.
  - **Custom Cover Images**: Personalize posters with your own images.
  - **Theme Customization**: Switch between Dark and Light themes.
  - **Track & Album Selection**: Highlight your favorite track or entire album.
  - **Lyrics Highlighting**: Feature impactful lyrics directly on your poster.




  Thank you to all contributors for making BeatPrints better!

  <p align="center">
   <a href="https://github.com/TrueMyst/BeatPrints/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=TrueMyst/BeatPrints" />
   </a>
  </p>




  I created this project after finding out that people sell these posters on [Etsy](https://www.etsy.com/market/spotify_poster) at high prices, offering only digital downloads instead of shipping actual posters.

  I wanted to make it free for everyone to print themselves, as I believe my posters are simpler, cleaner, and prettier.




  - A big thanks to [Spotify Poster Generator](https://github.com/AnveshakR/poster-generator/) by [@AnveshakR](https://github.com/AnveshakR) for inspiring BeatPrints with amazing ideas!
  - Shoutout to [@Magniquick](https://github.com/Magniquick), [@Krishna-Gunjan](https://github.com/Krishna-Gunjan), and [@itsnotrin](https://github.com/itsnotrin) for their awesome contributions!
  - Thanks to [@T-Dynamos](https://github.com/T-Dynamos) and [@cherriae](https://github.com/cherriae) for their great improvements and tweaks.
  - A special nod to [@itsnotrin](https://github.com/itsnotrin) for helping make album poster generation possible!




  BeatPrints is distributed under the **Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License**:

  - **Use**: Free to share and adapt.
  - **Attribution**: Provide credit and a link to the license.
  - **NonCommercial**: Not for commercial use.
  - **ShareAlike**: Adaptations must follow the same license.

  Read the full license [here](https://github.com/TrueMyst/BeatPrints/blob/main/LICENSE).


  <p align="center">
  Made with 💜 <br>
  elysianmyst, 2024
  </p>


pkgId: aa607d518d092d9aed0a2a4ff68ee53adc2b7dce62c9f0002107d2f7f4c92551
name: python-BgoKit-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for BgoKit
url: https://github.com/Bin-Cao/Bgolearn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BgoKit-0.0.5-1.src.rpm
location_href: Packages/python-BgoKit-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  __description__ = 'BgoKit, A tool package for Bgolearn'
  __documents__ = 'https://bgolearn.netlify.app/'
  __author__ = 'Bin Cao, Advanced Materials Thrust, Hong Kong University of Science and Technology (Guangzhou)'
  __author_email__ = 'binjacobcao@gmail.com'
  __url__ = 'https://github.com/Bin-Cao/Bgolearn'


  import Bgolearn.BGOsampling as BGOS
  import pandas as pd


  data = pd.read_csv('./data/data.csv')
  vs = pd.read_csv('./data/Visual_samples.csv')



  x = data.iloc[:,:-2] # 这行代码读取前四列，是特征

  y_T = data.iloc[:,-2] # 这行代码读取倒数第二列，是目标, 抗拉强度 T
  y_E = data.iloc[:,-1] # 这行代码读取倒数第一列，是目标, 断裂延伸率 E


  Bgolearn = BGOS.Bgolearn()


  Mymodel_T = Bgolearn.fit(data_matrix = x, Measured_response = y_T, virtual_samples = vs, min_search=False)
  score_T, rec_T = Mymodel_T.UCB()

  Mymodel_E = Bgolearn.fit(data_matrix = x, Measured_response = y_E, virtual_samples = vs, min_search=False)
  score_E, rec_E = Mymodel_E.UCB()


  from BgoKit import ToolKit

  Model = ToolKit.MultiOpt(vs,[score_T,score_E])
  Model.BiSearch()
  Model.plot_distribution()


pkgId: 178d217f4246813e5096752a321a09662f0ff4ccf3fc529039552ed28a65dafe
name: python-Bgolearn-help
arch: noarch
version: 2.3.2
epoch: 0
release: 1
summary: Development documents and examples for Bgolearn
url: https://github.com/Bin-Cao/Bgolearn
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Bgolearn-2.3.2-1.src.rpm
location_href: Packages/python-Bgolearn-help-2.3.2-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/badge/PyPI-caobin-blue)](https://pypi.org/project/Bgolearn/)




  ![Screen Shot 2022-07-11 at 9 13 28 AM](https://user-images.githubusercontent.com/86995074/178176016-8a79db81-fcfb-4af0-9b1c-aa4e6a113b5e.png)





  Reference paper : V. Picheny, T. Wagner, and D. Ginsbourger. “A Benchmark of Kriging-Based Infill Criteria for Noisy Optimization”. In: Structural and Multidisciplinary Optimization 48.3 (Sept. 2013), pp. 607–626. issn: 1615-1488.


  Written using Python, which is suitable for operating systems, e.g., Windows/Linux/MAC OS etc.


  Bgolearn guides subsequent material design based on existed experimental data. Which includes: 1.Expected Improvement algorithm, 2.Expected improvement with “plugin”，3.Augmented Expected Improvement，4.Expected Quantile Improvement，5.Reinterpolation Expected Improvement， 6.Upper confidence bound，7.Probability of Improvement，8.Predictive Entropy Search，9.Knowledge Gradient, a total of nine Utility Functions. Predictive Entropy Search，Knowledge Gradient are implemented based on Monte Carlo simulation.（贝叶斯优化设计，根据已有的实验数据对后续材料设计作出指导，本算法包共包括：期望最大化算法，期望最大化算法改进（考虑数据噪声），上确界方法，期望提升方法，熵搜索，知识梯度方法等在内的共计9种贝叶斯采样方法。其中熵搜索和知识梯度方法基于蒙特卡洛实现）


  pip install Bgolearn


  pip install --upgrade Bgolearn


  Maintained by Bin Cao. Please feel free to open issues in the Github or contact Bin Cao
  (bcao@shu.edu.cn) in case of any problems/comments/suggestions in using the code.


pkgId: 3d3272bcba263b54827c8e8e95862a2f96c4a37cf787076fffd0af9d7a8524ca
name: python-BiocFrame-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for BiocFrame
url: https://github.com/BiocPy/biocframe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BiocFrame-0.6.0-1.src.rpm
location_href: Packages/python-BiocFrame-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Built Status](https://api.cirrus-ci.com/github/<USER>/BiocFrame.svg?branch=main)](https://cirrus-ci.com/github/<USER>/BiocFrame)
  [![ReadTheDocs](https://readthedocs.org/projects/BiocFrame/badge/?version=latest)](https://BiocFrame.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/BiocFrame/main.svg)](https://coveralls.io/r/<USER>/BiocFrame)
  [![PyPI-Server](https://img.shields.io/pypi/v/BiocFrame.svg)](https://pypi.org/project/BiocFrame/)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/BiocFrame.svg)](https://anaconda.org/conda-forge/BiocFrame)
  [![Monthly Downloads](https://pepy.tech/badge/BiocFrame/month)](https://pepy.tech/project/BiocFrame)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/BiocFrame)
  -->

  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)
  [![PyPI-Server](https://img.shields.io/pypi/v/BiocFrame.svg)](https://pypi.org/project/BiocFrame/)
  ![Unit tests](https://github.com/BiocPy/BiocFrame/actions/workflows/pypi-test.yml/badge.svg)





  This package implements the `BiocFrame` class, a Bioconductor-friendly alternative to Pandas `DataFrame`.
  The main advantage is that the `BiocFrame` makes no assumption on the types of the columns -
  as long as an object has a length (`__len__`) and slicing methods (`__getitem__`), it can be used inside a `BiocFrame`.
  This allows us to accept arbitrarily complex objects as columns, which is often the case in Bioconductor objects.

  To get started, install the package from [PyPI](https://pypi.org/project/biocframe/):

  ```shell
  pip install biocframe


  pip install biocframe[optional]
  ```



  To construct a `BiocFrame` object, simply provide the data as a dictionary.

  ```python
  from biocframe import BiocFrame

  obj = {
      "ensembl": ["ENS00001", "ENS00002", "ENS00003"],
      "symbol": ["MAP1A", "BIN1", "ESR1"],
  }
  bframe = BiocFrame(obj)
  print(bframe)






  ```

  You can specify complex objects as columns, as long as they have some "length" equal to the number of rows.
  For example, we can nest a `BiocFrame` inside another `BiocFrame`:

  ```python
  obj = {
      "ensembl": ["ENS00001", "ENS00002", "ENS00002"],
      "symbol": ["MAP1A", "BIN1", "ESR1"],
      "ranges": BiocFrame({
          "chr": ["chr1", "chr2", "chr3"],
          "start": [1000, 1100, 5000],
          "end": [1100, 4000, 5500]
      }),
  }

  bframe2 = BiocFrame(obj, row_names=["row1", "row2", "row3"])
  print(bframe2)






  ```



  Properties can be accessed directly from the object:

  ```python
  print(bframe.shape)


  print(bframe.get_column_names())


  print(bframe.column_names) # same as above

  ```

  We can fetch individual columns:

  ```python
  bframe.get_column("ensembl")


  bframe["ensembl"]

  ```

  And we can get individual rows as a dictionary:

  ```python
  bframe.get_row(2)

  ```

  To extract a subset of the data in the `BiocFrame`, we use the subset (`[]`) operator.
  This accepts different subsetting arguments like a boolean vector, a `slice` object, a sequence of indices, or row/column names.

  ```python
  sliced = bframe[1:2, [True, False, False]]
  print(sliced)





  sliced = bframe[[0,2], ["symbol", "ensembl"]]
  print(sliced)







  bframe["ensembl"]

  ```





  To set `BiocFrame` properties, we encourage a functional style of programming that avoids mutating the object.
  This avoids inadvertent modification of `BiocFrame`s that are part of larger data structures.

  ```python
  modified = bframe.set_column_names(["column1", "column2"])
  print(modified)








  print(bframe.get_column_names())

  ```

  To add new columns, or replace existing columns:

  ```python
  modified = bframe.set_column("symbol", ["A", "B", "C"])
  print(modified)







  modified = bframe.set_column("new_col_name", range(2, 5))
  print(modified)






  ```

  Change the row or column names:

  ```python
  modified = bframe.\
      set_column_names(["FOO", "BAR"]).\
      set_row_names(['alpha', 'bravo', 'charlie'])
  print(modified)






  ```

  We also support Bioconductor's metadata concepts, either along the columns or for the entire object:

  ```python
  modified = bframe.\
      set_metadata({ "author": "Jayaram Kancherla" }).\
      set_column_data(BiocFrame({"column_source": ["Ensembl", "HGNC" ]}))
  print(modified)









  ```



  Properties can also be set by direct assignment for in-place modification.
  We prefer not to do it this way as it can silently mutate ``BiocFrame`` instances inside other data structures.
  Nonetheless:

  ```python
  testframe = BiocFrame({ "A": [1,2,3], "B": [4,5,6] })
  testframe.column_names = ["column1", "column2" ]
  print(testframe)






  ```

  Similarly, we could set or replace columns directly:

  ```python
  testframe["column2"] = ["A", "B", "C"]
  testframe[1:3, ["column1","column2"]] = BiocFrame({"x":[4, 5], "y":["E", "F"]})






  ```

  These assignments are the same as calling the corresponding `set_*()` methods with `in_place = True`.
  It is best to do this only if the `BiocFrame` object is not being used anywhere else;
  otherwise, it is safer to just create a (shallow) copy via the default `in_place = False`.



  **BiocFrame** implements methods for the various `combine` generics from [**BiocUtils**](https://github.com/BiocPy/biocutils).
  So, for example, to combine by row:

  ```python
  import biocutils

  bframe1 = BiocFrame(
      {
          "odd": [1, 3, 5, 7, 9],
          "even": [0, 2, 4, 6, 8],
      }
  )

  bframe2 = BiocFrame(
      {
          "odd": [11, 33, 55, 77, 99],
          "even": [0, 22, 44, 66, 88],
      }
  )

  combined = biocutils.combine_rows(bframe1, bframe2)
  print(combined)













  ```

  Similarly, to combine by column:

  ```python
  bframe3 = BiocFrame(
      {
          "foo": ["A", "B", "C", "D", "E"],
          "bar": [True, False, True, False, True]
      }
  )

  combined = biocutils.combine_columns(bframe1, bframe3)
  print(combined)
  BiocFrame with 5 rows and 4 columns
         odd   even    foo    bar
      <list> <list> <list> <list>
  [0]      1      0      A   True
  [1]      3      2      B  False
  [2]      5      4      C   True
  [3]      7      6      D  False
  [4]      9      8      E   True
  ```

  By default, both methods above assume that the number and identity of columns (for `combine_rows()`) or rows (for `combine_columns()`) are the same across objects.
  If this is not the case, e.g., with different columns across objects, we can use **BiocFrame**'s `relaxed_combine_rows()` instead:

  ```python
  from biocframe import relaxed_combine_rows
  modified2 = bframe2.set_column("foo", ["A", "B", "C", "D", "E"])
  combined = relaxed_combine_rows(bframe1, modified2)
  print(combined)













  ```

  Similarly, if the rows are different, we can use **BiocFrame**'s `merge` function:

  ```python
  from biocframe import merge
  modified1 = bframe1.set_row_names(["A", "B", "C", "D", "E"])
  modified3 = bframe3.set_row_names(["C", "D", "E", "F", "G"])
  combined = merge([modified1, modified3], by=None, join="outer")










  ```



  `BiocFrame` is intended for accurate representation of Bioconductor objects for interoperability with R.
  Most users will probably prefer to work with **pandas** `DataFrame` objects for their actual analyses.
  This conversion is easily achieved:

  ```python
  from biocframe import BiocFrame
  bframe = BiocFrame(
      {
          "foo": ["A", "B", "C", "D", "E"],
          "bar": [True, False, True, False, True]
      }
  )

  pd = bframe.to_pandas()
  print(pd)






  ```

  Conversion back to a ``BiocFrame`` is similarly easy:

  ```python
  out = BiocFrame.from_pandas(pd)
  print(out)








  ```



  Check out [the reference documentation](https://biocpy.github.io/BiocFrame/) for more details.

  Also see check out Bioconductor's [**S4Vectors**](https://bioconductor.org/packages/S4Vectors) package,
  which implements the `DFrame` class on which `BiocFrame` was based.


pkgId: dec687c677d1b0c26cde47b31d06f0292fa0c9ad5de5b9909f4096626694cf5e
name: python-BlueSkySight-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for BlueSkySight
url: https://github.com/CIRCL/BlueSkySight
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BlueSkySight-0.2.0-1.src.rpm
location_href: Packages/python-BlueSkySight-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  A client to gather vulnerability-related information from the Bluesky.
  The gathered data is subsequently transmitted to the
  [Vulnerability-Lookup](https://github.com/cve-search/vulnerability-lookup) API.




  [pipx](https://github.com/pypa/pipx) is an easy way to install and run Python applications in isolated environments.
  It's easy to [install](https://github.com/pypa/pipx?tab=readme-ov-file#on-linux).

  ```bash
  $ pipx install BlueSkySight
  $ export BLUESKYSIGHT_CONFIG=~/.BlueSkySight/conf.py
  ```

  The configuration for BlueSkySight should be defined in a Python file (e.g., ``~/.BlueSkySight/conf.py``).
  You must then set an environment variable (``BLUESKYSIGHT_CONFIG``) with the full path to this file.

  You can have a look at [this example](https://github.com/CIRCL/BlueSkySight/blob/main/blueskysight/conf_sample.py) of configuration.




  ``BlueSkySight-Stream`` streams data from the Bluesky firehose and uses PyVulnerabilityLookup to create sightings in Vulnerability-Lookup.

  ```bash
  $ BlueSkySight-Stream
  Streaming Bluesky firehose…
  ```




  [BlueSkySight](https://github.com/CIRCL/BlueSkySight) is licensed under
  [GNU General Public License version 3](https://www.gnu.org/licenses/gpl-3.0.html)

  ~~~
  Copyright (c) 2024 Computer Incident Response Center Luxembourg (CIRCL)
  Copyright (C) 2024 Cédric Bonhomme - https://github.com/cedricbonhomme
  ~~~


pkgId: 323eed2db6715d2665c44a49a4d502d0139f2eeb2f3ebe47d2ac4c6ee4d169e2
name: python-BorutaShapPlus-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for BorutaShapPlus
url: https://github.com/AbhishekKaps/Boruta-Shap
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-BorutaShapPlus-0.1.0-1.src.rpm
location_href: Packages/python-BorutaShapPlus-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/255354538.svg)](https://zenodo.org/badge/latestdoi/255354538)
  <a href="https://badge.fury.io/py/BorutaShap"><img src="https://badge.fury.io/py/BorutaShap.svg" alt="PyPI version" height="18"></a>


  This is a fork of [Boruta-Shap](https://github.com/Ekeany/Boruta-Shap) by Eoghan Keany. The original library was not maintained anymore, and this fork includes the following updates:
  * Updated to use the latest versions of numpy and scipy. The original library had some depreciated imports that threw errors when used with newer versions of those libraries.
  * Added the ability to do a time-aware train-test split.
  * Made test set size parameterizable.


  BorutaShap is a wrapper feature selection method which combines both the Boruta feature selection algorithm with shapley values. This combination has proven to out perform the original Permutation Importance method in both speed, and the quality of the feature subset produced. Not only does this algorithm provide a better subset of features, but it can also simultaneously provide the most accurate and consistent global feature rankings which can be used for model inference too. Unlike the orginal R package, which limits the user to a Random Forest model, BorutaShap allows the user to choose any Tree Based learner as the base model in the feature selection process.

  Despite BorutaShap's runtime improvements the SHAP TreeExplainer scales linearly with the number of observations making it's use cumbersome for large datasets. To combat this, BorutaShap includes a sampling procedure which uses the smallest possible subsample of the data availble at each iteration of the algorithm. It finds this sample by comparing the distributions produced by an isolation forest of the sample and the data using ks-test. From experiments, this procedure can reduce the run time up to 80% while still creating a valid approximation of the entire data set. Even with these improvments the user still might want a faster solution so BorutaShap has included an option to use the mean decrease in gini impurity. This importance measure is independent of the size dataset as it uses the tree's structure to compute a global feature ranking making it much faster than SHAP at larger datasets. Although this metric returns somewhat comparable feature subsets, it is not a reliable measure of global feature importance in spite of it's wide spread use. Thus, I would recommend to using the SHAP metric whenever possible.



  1. Start by creating new copies of all the features in the data set and name them shadow + feature_name, shuffle these newly added features to remove their correlations with the response variable.

  2. Run a classifier on the extended data with the random shadow features included. Then rank the features using a feature importance metric the original algorithm used permutation importance as it's metric of choice.

  3. Create a threshold using the maximum importance score from the shadow features. Then assign a hit to any feature that had exceeded this threshold.

  4. For every unassigned feature preform a two sided T-test of equality.

  5. Attributes which have an importance significantly lower than the threshold are deemed 'unimportant' and are removed them from process. Deem the attributes which have importance significantly higher than than the threshold as 'important'.

  6. Remove all shadow attributes and repeat the procedure until an importance has been assigned for each feature, or the algorithm has reached the previously set limit of runs.

  If the algorithm has reached its set limit of runs and an importance has not been assigned to each feature the user has two choices. Either increase the number of runs or use the tentative rough fix function which compares the median importance values between unassigned features and the maximum shadow feature to make the decision.





  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BorutaShap.

  ```bash
  pip install BorutaShap
  ```



  For more use cases such as alternative models, sampling or changing the importance metric please view the notebooks [here](https://github.com/Ekeany/Boruta-Shap/tree/master/Examples).


  ```python
  from BorutaShap import BorutaShap, load_data

  X, y = load_data(data_type='regression')
  X.head()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonHead.PNG?raw=true" height="203" width="722">

  ```python

  Feature_Selector = BorutaShap(importance_measure='shap',
                                classification=False)

  '''
  Sample: Boolean
  	if true then a rowise sample of the data will be used to calculate the feature importance values

  sample_fraction: float
  	The sample fraction of the original data used in calculating the feature importance values only
          used if Sample==True.

  train_or_test: string
  	Decides whether the feature improtance should be calculated on out of sample data see the dicussion here.
          https://slds-lmu.github.io/iml_methods_limitations/pfi-data.html

  normalize: boolean
              if true the importance values will be normalized using the z-score formula

  verbose: Boolean
  	a flag indicator to print out all the rejected or accepted features.
  '''
  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/BostonOutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/Bostonplot.PNG?raw=true" height="530" width="699">

  ```python

  subset = Feature_Selector.Subset()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/bostonsubset.PNG?raw=true" height="194" width="465">




  ```python
  from BorutaShap import BorutaShap, load_data
  from xgboost import XGBClassifier

  X, y = load_data(data_type='classification')
  X.head()
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryhead.PNG?raw=true">

  ```python
  model = XGBClassifier()


  Feature_Selector = BorutaShap(model=model,
                                importance_measure='shap',
                                classification=True)

  Feature_Selector.fit(X=X, y=y, n_trials=100, sample=False,
              	     train_or_test = 'test', normalize=True,
  		     verbose=True)
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryoutput.PNG?raw=true">

  ```python

  Feature_Selector.plot(which_features='all')
  ```

  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binaryplot.PNG?raw=true" height="565" width="671">

  ```python

  subset = Feature_Selector.Subset()
  ```
  <img src="https://github.com/Ekeany/Boruta-Shap/blob/master/images/binarysubset.PNG?raw=true">


  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.


  If you wish to cite this work please click on the zenodo badge at the top of this READme file
  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 37b925768e5ac160a4d8cf3bc23424e915de363a671b54fd540940eb0eb80e4f
name: python-CADET-Process-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for CADET-Process
url: https://pypi.org/project/CADET-Process/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CADET-Process-0.10.0-1.src.rpm
location_href: Packages/python-CADET-Process-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  The [**CADET**](https://cadet.github.io) core simulator is a very powerful numerical engine that can simulate a large variety of physico-chemical models used in chromatography and other biochemical processes.
  However, the configuration files of **CADET** can be complex and difficult to work with.
  This is especially relevant when multiple unit operations are involved which is often the case for complex integrated processes.
  Moreover, the structure of the configuration file may change during process optimization, for example when the order of dynamic events changes, making the direct use of **CADET** impossible without another layer of abstraction.

  In this context [**CADET-Process**](https://cadet-process.readthedocs.io/en/latest/) was developed.
  The package facilitates modeling processes using an object oriented model builder.
  This interface layer provides convenient access to all model parameters in the system.
  It automatically checks validity of the parameter values and sets reasonable default values where possible.
  This simplifies the setup of **CADET** simulations and reduces the risk of ill-defined configurations files.

  Importantly, **CADET-Process** enables the modelling of elaborate switching schemes and advanced chromatographic operating modes such as complex gradients, recycling systems, or multi-column systems by facilitating the definition of dynamic changes of flow sheet connectivity or any other time dependent parameters.

  The package also includes tools to evaluate cyclic stationarity of processes, and routines to determine optimal fractionation times required determine common performance indicators such as yield, purity, and productivity.
  Moreover, utility functions for calculating reaction equilibria and buffer capacities, as well as convenient functions for plotting simulation results are provided.

  Finally, these processes can be optimized by defining an objective function (with constraints) and using one of the integrated optimization algorithms such as NSGA-3.
  This can be used to determine any of the physico-chemical model parameters and to improve process performance.

  For more information and tutorials, please refer to the [documentation](https://cadet-process.readthedocs.io/en/latest/).
  The source code is freely available on [*GitHub*](https://github.com/fau-advanced-separations/CADET-Process), and a scientific paper was published in [*MDPI Processes*](https://doi.org/10.3390/pr8010065).
  If **CADET-Process** is useful to you, please cite the following publication:

  ```
  @Article{Schmoelder2020,
    author  = {Schmölder, Johannes and Kaspereit, Malte},
    title   = {A {{Modular Framework}} for the {{Modelling}} and {{Optimization}} of {{Advanced Chromatographic Processes}}},
    doi     = {10.3390/pr8010065},
    number  = {1},
    pages   = {65},
    volume  = {8},
    journal = {Processes},
    year    = {2020},
  }
  ```



  **CADET-Process** can be installed with the following command:

  ```
  pip install CADET-Process
  ```

  To use **CADET-Process**, make sure, that **CADET** is also installed.
  This can for example be done using [conda](https://github.com/conda-forge/miniforge):

  ```
  conda install -c conda-forge cadet
  ```

  For more information, see the [CADET Documentation](https://cadet.github.io/master/getting_started/installation.html).



  CADET-Process is free software: you can redistribute it and/or modify it under the terms of the [GNU General Public License version 3](https://github.com/fau-advanced-separations/CADET-Process/blob/master/LICENSE.md).



  This software is work in progress and being actively developed.
  Breaking changes and extensive restructuring may occur in any commit and release.
  If you encounter problems or if you have questions, feel free to ask for support in the [**CADET-Forum**](https://forum.cadet-web.de).
  Please report any bugs that you find [here](https://github.com/fau-advanced-separations/CADET-Process/issues).
  Pull requests on [GitHub](https://github.com/fau-advanced-separations/CADET-Process) are also welcome.



  Please refer to the [list of contributors](CONTRIBUTORS.md) who helped building and funding this project.


pkgId: 34dc2bcd790da7d78a5bf71d03677cd913ac99bea267f2322efd55b85e17a6a9
name: python-CADET-Python-help
arch: noarch
version: 1.0.4
epoch: 0
release: 1
summary: Development documents and examples for CADET-Python
url: https://pypi.org/project/CADET-Python/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CADET-Python-1.0.4-1.src.rpm
location_href: Packages/python-CADET-Python-help-1.0.4-1.noarch.rpm
checksum_type: sha256
description:
  **CADET-Python** provides a file-based Python interface for **CADET-Core**, which must be installed separately. For this, please refer to the [installation instructions](https://cadet.github.io/master/getting_started/installation.html) and the [CADET-Core repository](https://github.com/cadet/CADET-Core).

  The CADET-Python package simplifies access by mapping to the [CADET interface](https://cadet.github.io/master/interface/index.html#), **with all dataset names in lowercase**.



  To install CADET-Python, use:

  ```
  pip install cadet-python
  ```



  The package includes two primary classes:

  - **`CADET`**: The main class to configure and run simulations.
  - **`H5`**: A general-purpose HDF5 interface.



  To set a simulation parameter, such as the column porosity for column 1.

  Referring to this path in the CADET interface:
  ```
  /input/model/unit_001/COL_POROSITY
  ```
  In CADET-Python, this is now set as:
  ```
  from cadet import Cadet


  sim = Cadet()


  sim.root.input.model.unit_001.col_porosity = 0.33
  ```


  Before running, save the simulation configuration to a file:
  ```
  sim.filename = "/path/to/your/file.hdf5"
  sim.save()
  ```


  To execute the simulation, specify the path to **CADET-Core**. On Windows, set the path to `cadet-cli.exe`:
  ```
  sim.cadet_path = '/path/to/cadet-cli'
  ```


  Run the simulation and load the output data with:
  ```
  print(sim.run())
  sim.load()
  ```


  If you have a pre-simulated file, you can read it directly:
  ```

  sim = Cadet()


  sim.filename = "/path/to/your/file.hdf5"
  sim.load()
  ```
  At this point, any data in the file can be accessed.


pkgId: 2ff8ccd25b45e96ac7c9cfa15f7c00f7c080ab2301a091b9270750fba46809ee
name: python-CLASV-help
arch: noarch
version: 0.1.16
epoch: 0
release: 1
summary: Development documents and examples for CLASV
url: https://github.com/JoiRichi/CLASV/commits?author=JoiRichi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CLASV-0.1.16-1.src.rpm
location_href: Packages/python-CLASV-help-0.1.16-1.noarch.rpm
checksum_type: sha256
description:
  Lassa virus lineage prediction based on random forest.

  Information on the research can be found here:
  https://www.biorxiv.org/content/10.1101/2024.07.31.605963v2


  - **Data and Processing:** [LASV_ML_Manuscript_Data](https://github.com/JoiRichi/LASV_ML_manuscript_data)
  - **Lassa Virus Lineage Prediction:** [CLASV_GITHUB](https://github.com/JoiRichi/CLASV)


  - **General Preprocessing:** [Notebook Link](https://colab.research.google.com/drive/1JOgS2-dDoQ7OPHPcXm3AIBDnGQAFxIyR)
  - **Lassa Virus Lineage Prediction Training:** [Notebook Link](https://colab.research.google.com/drive/1G0lEjuvPR07bcb181Rfhm-S0WenMFSmR)


  ![CLASV](predflow.png)



  It is recommended that python 3.11 is used (or at least between 3.6 - 3.11). [Python3.11](https://www.python.org/downloads/release/python-3110/)


  Highly recommended to use a virtual environment:
  ```sh
  python3.11 -m venv myenv #where myenv can be any name of your chioce

  source myenv/bin/activate  # activates the virtual environment
  ```

  Install CLASV using pip
  ```sh
  pip install clasv
  ```
  This tool relies on Nextclade for gene extraction and alignment. This is automatically installed. More information about the nextstrain project here: [installation guide](https://docs.nextstrain.org/projects/cli/en/stable/installation/). This tool uses the Snakemake engine which is automatically installed.


  ```sh
  clasv find-lassa --input myinputfolderpath --output mychosenfolderpath --cores 4 --minlength 500 #default

  ```

  Find Fasta files in the input directory and subdirectories recursively:

  ```sh

  clasv find-lassa --input myinputfolderpath --output mychosenfolderpath  --cores 4 --recursive #Add the recursive flag
  ```


  Force rerun:

  ```sh

  clasv find-lassa --input myinputfolderpath --output mychosenfolderpath --cores 4 --force #add the force flag
  ```


  Upon completion, go to the pipeline 'visuals' folder and open the html files in a browser.




  This pipeline has the ability to process multiple FASTA files containing multiple sequences with proficiency and speed. It is recommended that multiple FASTA files are concatenated into one; however, this is not compulsory, especially if the projects are different. By default, the pipeline finds all files with the extension `.fasta` in your **input_folder** folder and tries to find LASV GPC sequences in the files.

  To ensure Snakemake has a memory of what files have been checked, intermediary files are created for all files checked, even if they contain no GPC sequences. However, those files would be empty.



  At the end of the run, you can check the **predictions** folder for the CSV files containing the predictions per sample. A visualization of the prediction can be found in the **visuals** folder. Open the HTML files in a browser. The images are high quality and reactive, allowing you to hover over them to see more information.

  For further details, please refer to the respective notebooks and repositories linked above. You can also leave a comment for help regarding the pipeline.





  Learn how the data was preprocessed here: [LASV_ML_Manuscript_Data](https://github.com/JoiRichi/LASV_ML_manuscript_data). Training process here [Notebook Link](https://colab.research.google.com/drive/1G0lEjuvPR07bcb181Rfhm-S0WenMFSmR).


pkgId: 84878d42d8e4a2616675c9c4a9efd4db30f0fe4b113f8dc3869c96b91e6e7075
name: python-CNSistent-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for CNSistent
url: https://pypi.org/project/CNSistent/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CNSistent-0.7.0-1.src.rpm
location_href: Packages/python-CNSistent-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  ![CNSistent Logo](https://cnsistent.readthedocs.io/en/latest/_images/Logo.png)

  [![PyPI version](https://badge.fury.io/py/CNSistent.svg)](https://badge.fury.io/py/CNSistent)
  [![Documentation Status](https://readthedocs.org/projects/cnsistent/badge/?version=latest)](https://cnsistent.readthedocs.io/en/latest/?badge=latest)

  CNSistent is a Python tool for processing and analyzing copy number data. It is designed to work with data from a variety of sources. The tool is designed to be easy to use, and to provide a comprehensive set of analyses and visualizations.



  CNSistent can be used as a Python package, or downloaded together with the respective data (PCAWG, TRACERx, TCGA, genomic locations):




   1. [Full Bitbucket repository with ~1GB of data.](https://bitbucket.org/schwarzlab/cnsistent/src/main/REPOSITORY.md)
   2. [PIP package only.](https://pypi.org/project/cnsistent/)


pkgId: 804cdf45da9a78faf2011a38bd5be7fd1d96f4932db2e5453b752269b2441303
name: python-CTkDateEntry-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for CTkDateEntry
url: https://github.com/ClaudioM1386/CTkDateEntry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CTkDateEntry-0.1.1-1.src.rpm
location_href: Packages/python-CTkDateEntry-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  **CTkDateEntry** is a Python library that extends the use of `customtkinter` to provide custom widgets such as a customtkinter DateEntry with a calendar `CTkCalendar` with selectable dates. It was designed to make it easier to create more modern and interactive graphical user interfaces (GUIs).




  Debug CTkDateEntry

  ![img_1](https://github.com/user-attachments/assets/d0be5cc6-7ab2-4135-b85a-64a1a386a097)



  Open Calendar CTkDateEntry

  ![Img_2](https://github.com/user-attachments/assets/e3799515-59d5-4347-a95a-d63f1ec7347a "CTkDateEntry open Calendar")



  - **CTkDateEntry**: A custom DateEntry based on Customtkinter to facilitate date selection in graphical interfaces.



  - **CTkDateEntry**: When customtkinter themes are applied to the graphical interface, they are automatically applied to CTkDateEntry, meaning there is no need to use a separate Theme Style



  Here's a simple example of how to use the `CTkDateEntr` widget:

  ```
  import customtkinter asctk
  from ctkdateentry import CTkDateEntry

  root = ctk.CTk()

  root.geometry('200x200')

  root.title('CTkDateEntry ')

  calendar = CTkDateEntry(root)

  calendar.pack(pady=50)

  root.mainloop()
  ```


pkgId: f7be684fa64813a30e1ffafdc2a497fe6bb5b28b1c29e983cdd23c34b8159e7e
name: python-CTkSimpleMessagebox-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for CTkSimpleMessagebox
url: https://github.com/NotScottt/CTkSimpleMessageboxes
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CTkSimpleMessagebox-1.0.0-1.src.rpm
location_href: Packages/python-CTkSimpleMessagebox-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Very simple Python "Messagebox" to display current Infos or Error. <br />
  Simply install it via pip.



  ```python
    pip install CTkSimpleMessageBox
   ```


pkgId: c6673f475e97804a9f720d18d7049d53e912052dd25d618f95771421b56c01c9
name: python-CellProfiler-nightly-help
arch: noarch
version: 5.0.0.dev192
epoch: 0
release: 1
summary: Development documents and examples for CellProfiler-nightly
url: https://cellprofiler.org/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CellProfiler-nightly-5.0.0.dev192-1.src.rpm
location_href: Packages/python-CellProfiler-nightly-help-5.0.0.dev192-1.noarch.rpm
checksum_type: sha256
description:
  This codebase contains the code to build the `cellprofiler` package. It contains modules that implement the GUI interface, the CLI interface, and others that are non-essential to the functioning of the [CellProfiler](https://cellprofiler.org) software. The [subpackages](https://github.com/CellProfiler/CellProfiler/tree/main/src/subpackages) are necessary dependencies for the functioning of `cellprofiler`.

rpm_license:
  The BSD 3-Clause License  Copyright © 2003 - 2021 Broad Institute, Inc. 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 Broad Institute, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED “AS IS.”  BROAD MAKES NO EXPRESS OR IMPLIED REPRESENTATIONS OR WARRANTIES OF ANY KIND REGARDING THE SOFTWARE AND COPYRIGHT, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, CONFORMITY WITH ANY DOCUMENTATION, NON-INFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, WHETHER OR NOT DISCOVERABLE. IN NO EVENT SHALL BROAD, THE COPYRIGHT HOLDERS, OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF, HAVE REASON TO KNOW, OR IN FACT SHALL KNOW OF THE POSSIBILITY OF SUCH DAMAGE.  If, by operation of law or otherwise, any of the aforementioned warranty disclaimers are determined inapplicable, your sole remedy, regardless of the form of action, including, but not limited to, negligence and strict liability, shall be replacement of the software with an updated version if one exists.  Development of CellProfiler has been funded in whole or in part with federal funds from the National Institutes of Health, the National Science Foundation, and the Human Frontier Science Program.


pkgId: 43bb90d5144f6fceca4f8bbcdf7bbc85a30d1088f94f6777353fb58a8bf528d7
name: python-CheckmarxPythonSDK-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for CheckmarxPythonSDK
url: https://github.com/checkmarx-ts/checkmarx-python-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CheckmarxPythonSDK-1.1.2-1.src.rpm
location_href: Packages/python-CheckmarxPythonSDK-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  This is wrapper using Python for CxSAST and CxOSA REST API, Portal SOAP API, CxSAST ODATA API, CxSCA REST API.

  By using this SDK, Checkmarx users will be able to do automatic scanning with CxSAST, CxOSA, and CxSCA.

  [![Downloads](https://static.pepy.tech/badge/CheckmarxPythonSDK/month)](https://static.pepy.tech/badge/CheckmarxPythonSDK/month)
  [![Supported Versions](https://img.shields.io/pypi/pyversions/CheckmarxPythonSDK.svg)](https://pypi.org/project/CheckmarxPythonSDK)
  [![Contributors](https://img.shields.io/github/contributors/checkmarx-ts/checkmarx-python-sdk.svg)](https://github.com/checkmarx-ts/checkmarx-python-sdk/graphs/contributors)



  For more information about Checkmarx API, please refer to Checkmarx knowledge Center：

  - [CxSAST API Document](https://checkmarx.com/resource/documents/en/34965-46552-sast-api-guide.html)
  - [CxOSA API Document](https://checkmarx.com/resource/documents/en/34965-46909-cxosa-api-guide.html)
  - [Access Control API Document](https://checkmarx.com/resource/documents/en/34965-46622-access-control--rest--api--v1-5-and-up-.html)
  - [CxSCA API Document](https://checkmarx.com/resource/documents/en/34965-19221-checkmarx-sca--rest--api-documentation.html)
  - [CxOne API Document](https://checkmarx.com/resource/documents/en/34965-68772-checkmarx-one-api-documentation.html)
  - [CxReporting API Document](https://checkmarx.com/resource/documents/en/34965-93162-apis.html)



  Please use Python3





  The easiest way to begin using the SDK is to install it using the **pip** command.

  ```
  $ pip install CheckmarxPythonSDK
  ```

  Alternatively, either download and unzip this repository, or clone it to your local drive, and install using the `setup.py` script.

  ```
  $ git clone https://github.com/checkmarx-ts/checkmarx-python-sdk.git
  $ python setup.py install
  ```

  Even if you install the SDK using **pip**, you might still want to download or clone this repository for the sample scripts.




  ```buildoutcfg
  [checkmarx]
  base_url = http://localhost:80
  username = ******
  password = ******
  grant_type = password
  scope = sast_rest_api
  client_id = resource_owner_client
  client_secret = 014DF517-39D1-4453-B7B3-9930C563627C
  url =  s/cxrestapi
  scan_preset = Checkmarx Default
  configuration = Default Configuration
  team_full_name = /CxServer
  max_try = 3

  [CxSCA]
  access_control_url = https://platform.checkmarx.net
  server = https://api-sca.checkmarx.net
  account = ***
  username = ***
  password = ***

  [CxOne]
  access_control_url = https://iam.checkmarx.net
  server = https://ast.checkmarx.net
  tenant_name  = ***
  grant_type = refresh_token
  client_id = ast-app
  client_secret = ***
  username = ***
  password = ***
  refresh_token = ***

  [CxReporting]
  base_url = http://localhost
  reporting_client_url = http://localhost:5001
  username = ***
  password = ***
  grant_type = password
  scope = reporting_api
  client_id = reporting_service_api
  client_secret = 014DF517-39D1-4453-B7B3-9930C563627C
  ```

  configuration file path:

  By default, Checkmarx Python SDK looks for `config.ini` or `config.json` file in a `.Checkmarx` folder in your home directory.
  - For windows, it should be like `C:\\Users\\<UserName>\\.Checkmarx\\config.ini`
  - For linux and MacOS, it should be like `/home/<UserName>/.Checkmarx/config.ini`

  You can also use `checkmarx_config_path` as environment variable  or command line argument to set up configuration file path.

  For CxOne configuration, if you are going to use refresh_token grant type, you must use client id "ast-app",
  refresh_token, ignore client_secret, username, password. If you are going to use client_credentials grant type,
  you must create a client with roles such as ast-scanner, manage-webhook, queries-editor, ast-viewer, manage-application,
  manage-project, then fill in your own client_id, client secret, username, password, ignore the refresh_token.



  For CxSAST:

      - cxsast_base_url
      - cxsast_username
      - cxsast_password
      - cxsast_grant_type
      - cxsast_scope
      - cxsast_client_id
      - cxsast_client_secret

  For CxSCA:

      - cxsca_access_control_url
      - cxsca_server
      - cxsca_account
      - cxsca_username
      - cxsca_password

  For CxOne:

      - cxone_access_control_url
      - cxone_server
      - cxone_tenant_name
      - cxone_grant_type
      - cxone_client_id
      - cxone_client_secret
      - cxone_username
      - cxone_password
      - cxone_refresh_token

   For CxReporting

      - cxreporting_base_url
      - cxreporting_reporting_client_url
      - cxreporting_username
      - cxreporting_password
      - cxreporting_grant_type
      - cxreporting_scope
      - cxreporting_client_id
      - cxreporting_client_secret


  You can use command line option `--cx_debug true` to enable debug mode. In debug mode, it will print out how to load the
  configuration file and print every http request send out.


   Please find example scripts from [examples folder](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/examples).




  - [CxOne_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxOne_REST_API_List.md)
  - [CxSAST_and_CxOSA_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSAST_and_CxOSA_REST_API_List.md)
  - [CxSAST_ODATA_API](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSAST_ODATA_API.md)
  - [CxSAST_Portal_SOAP_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSAST_Portal_SOAP_API_List.md)
  - [CxSCA_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/tree/master/docs/CxSCA_REST_API_List.md)
  - [CxReporting_REST_API_List](https://github.com/checkmarx-ts/checkmarx-python-sdk/blob/master/docs/CxReporting_REST_API_List.md)


pkgId: 5a21eceafc86421bdb967e378ca43e86365b176bbf133fd6f6545b36133c64a1
name: python-ChinnuAi-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for ChinnuAi
url: https://github.com/Kalasaikamesh944/ChinnuAi.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ChinnuAi-1.0.1-1.src.rpm
location_href: Packages/python-ChinnuAi-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Chinnu AI is an advanced quantum-inspired chatbot framework that combines traditional neural networks with quantum computing principles to provide intelligent and interactive user experiences.



  - **Quantum State Representation:** Represent and manipulate quantum states using `QuantumState`.
  - **Quantum Training:** Train quantum models using `QuantumTrainer`.
  - **Deep Learning Integration:** Incorporate PyTorch models with Chinnu AI for enhanced learning capabilities.
  - **JSON-based Interaction:** Live conversation with Chinnu AI using JSON input for flexibility and integration.



  1. Clone the repository:
     ```bash
     git clone https://github.com/Kalasaikamesh944/ChinnuAi.git
     cd ChinnuAi
     ```
   2. Using pip:
      ```bash
      pip install ChinnuAi
      ```





  The following example demonstrates training Chinnu AI with a simple dataset:

  ```python
  import torch
  from ChinnuAi import QuantumState, QuantumTrainer, initialize_chinnu_ai, train_chinnu_ai


  initial_state = [1, 0, 0, 0]
  target_state = [0.5, 0.5, 0.5, 0.5]
  quantum_model = QuantumState(initial_state)
  quantum_trainer = QuantumTrainer(quantum_model, training_data=None)


  input_size = 4
  hidden_size = 8
  output_size = 4
  model = initialize_chinnu_ai(input_size, hidden_size, output_size)


  dataset = [
      (torch.tensor([1, 0, 0, 0]), torch.tensor([0.5, 0.5, 0.5, 0.5])),
      (torch.tensor([0, 1, 0, 0]), torch.tensor([0.5, 0.5, 0.5, 0.5])),
  ]
  dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True)


  epochs = 10
  learning_rate = 0.01
  train_chinnu_ai(model, quantum_trainer, target_state, dataloader, epochs, learning_rate)
  ```



  Chinnu AI can interact with users through JSON input. Here is an example of a live conversation:

  ```python
  from ChinnuAi import chat_with_chinnu_ai


  json_input = '{"input": [1, 0, 0, 0], "responses": ["Welcome!", "How can I help you?", "Here is your data.", "Goodbye!"]}'
  response = chat_with_chinnu_ai(model, quantum_model, json_input)
  print("Chinnu AI response:", response)
  ```



  Manipulate quantum states directly with `QuantumState`:

  ```python
  from ChinnuAi import QuantumState


  qs = QuantumState([1, 0, 0, 0])


  qs.apply_gate(QuantumGates.H)
  print("State after Hadamard Gate:", qs)


  measurement = qs.measure()
  print("Measurement Outcome:", measurement)
  ```



  This project is licensed under the MIT License - see the LICENSE file for details.



  Contributions are welcome! Feel free to open an issue or submit a pull request.


pkgId: a4b6402a810c41346dd647623e70d347c6deafa59c15fcd5354468b9ad813647
name: python-CliDApp4Rhino-help
arch: noarch
version: 1.0.23
epoch: 0
release: 1
summary: Development documents and examples for CliDApp4Rhino
url: https://github.com/ec-intl/clidapp4rhino
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CliDApp4Rhino-1.0.23-1.src.rpm
location_href: Packages/python-CliDApp4Rhino-help-1.0.23-1.noarch.rpm
checksum_type: sha256
description:
  CliDApp4Rhino package is a Python package with the plugin for the [Rhinoceros](https://www.rhino3d.com/) program developed by [CliMA](https://clima.caltech.edu/) that enables users to download weather files into the Rhinoceros environment from the CliDApp API.



  Before installing the CliDApp4Rhino plugin, ensure that you have the following:

  - Rhinoceros 5 and above
  - Python 3 or later installed on your device
  - Internet connection: to download weather files



  To install the CliDApp4Rhino plugin, follow the steps below:

  1. Close Rhinoceros (Rhino) if opened
  2. Navigate to the terminal and enter the following to install the package

  ```shell
  pip install CliDApp4Rhino
  ```

  3. After running the following command to install the package to the correct directory.

  ```shell
  clidapp4rhino
  ```

  4. Open Rhino and enter the following in the command-line

  ```shell
  CliDApp4Rhino
  ```

  If Rhino suggests this command, then you have successfully installed the plugin.



  After installing the plugin and launching the CliDApp4Rhino command, you will now see the dialog box below:

  <div align="center">
  <img src="https://clidapp.s3.amazonaws.com/static/server/img/dialog.png" alt="CliDApp4Rhino Dialog Box" width="35%" height="35%">
  </div>

  Begin by selecting a city from the dropdown

  <div align="center">
  <img src="https://clidapp.s3.amazonaws.com/static/server/img/city_selection.png" alt="CliDApp4Rhino City Selection" width="35%" height="35%">
  </div>

  Then select a weather file from the following three options:

  - Typical Meteorological Year (TMY)
  - Future Meteorological Year (FTMY)
  - Actual Meteorological Year (AMY)

  Next, select a data type. Currently, only observational data is available.

  The start/end-year ranges will differ depending on the weather file selected. Currently, for AMY and TMY files, the start-year and end-year range starts from 1979 and ends in 2022. For FTMY files, the baseline years run from 1979 to 2023, and they are projected to 2050 to 2070.

  Afterwards, select your desired file type. Then, enter the path where you want to download the file. If the text box for Download Path is left empty, the default path will be Downloads/clidapp/epw. Lastly, click on **OK** to begin downloading the weather file.



  Here we use the CliDApp4Rhino plugin to download an EPW weather file. Then, we use the ImportEPW and WindRose Ladybug module to visualise the data as a wind rose chart.

  As shown in the form inputs below, the following file was downloaded.

  <div align="center">
      <img src="https://clidapp.s3.amazonaws.com/static/server/img/form_inputs.png" alt="CliDApp4Rhino Form Input" width="35%" height="35%" style="display: inline-block; margin-right: 10px;">
      <img src="https://clidapp.s3.amazonaws.com/static/server/img/file.png" alt="CliDApp4Rhino File" width="35%" height="35%" style="display: inline-block;">
  </div>

  We get the following chart using a Panel, the ImportEPW Ladybug module, and the WindRose Ladybug module.

  <div align="center">
  <img src="https://clidapp.s3.amazonaws.com/static/server/img/ladybug_inputs.png" alt="CliDApp4Rhino Ladybug Input" width="35%" height="35%">
  </div>
  <br>
  <div align="center">
  <img src="https://clidapp.s3.amazonaws.com/static/server/img/wind_rose.png" alt="CliDApp4Rhino Wind Rose" width="35%" height="35%">
  </div>


pkgId: ef3b4c91c4f7b0b3ce5e634541511e678dc1d99b3fd64b117e32f21aae319dad
name: python-CollabConnector-help
arch: noarch
version: 0.1.1734368030
epoch: 0
release: 1
summary: Development documents and examples for CollabConnector
url: https://github.com/mycollablab/CollabConnector
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CollabConnector-0.1.1734368030-1.src.rpm
location_href: Packages/python-CollabConnector-help-0.1.1734368030-1.noarch.rpm
checksum_type: sha256
description:
   Cisco Collab Connector Library

  This library is made to try and be a single source for all Cisco Collab APIs (which can be lots). The goal is to unify requests and responses across different REST and SOAP APIs availble to make connecting to and scripting Collab tasks easier.  Hopefully.  Maybe.

  Install:
  ```
  pip3 install CollabConnector
  ```

  Usage:
  ```commandline
  >>> from CollabConnector import CUCM
  >>> from CollabConnector import CUCX
  >>> from CollabConnector import UCCX
  >>> from CollabConnector.Webex import Webex

  >>> cucm = CUCM.Connect("10.10.10.10", "admin", "P@ssw0rd")
  >>> cucm.query("select count(*) from enduser")
  [{'count': '5'}]
  >>> cucm.get.Phone(name="SEP3C08F67A9618")
  [{'name': 'SEP3C08F67A9618', 'description': 'Auto 1000', 'product': 'Cisco 7841', 'mod... }]
  >>> cucm.uds.get("version")
  {'@uri': 'https://10.10.10.10:8443/cucm-uds/version', '@version': '12.5.1', 'version': '12.5.1', 'capabil... }]
  >>> cucm.ast.cluster
  {'cluster_name': 'StandAloneCluster', 'nodes': ['cucm-01.lab-01.mycollablab.org', 'cucm-02.lab-01.mycollablab.org'], 'service...}]
  >>> cucm.serviceability.status("Cisco Tftp")
  {'cucm-01.lab-01.mycollablab.org': {'Cisco Tftp': {'ServiceName': 'Cisco Tftp', 'ServiceStatus': 'Started', 'ReasonCode': -1, 'Rea...}]
  >>> cucm.registration_status("SEP3C08F67A9618")
  {'SEP3C08F67A9618': {'name': 'SEP3C08F67A9618', 'node': ..., 'firmware': 'sip78xx.12-7-1-0001-393', 'IPAddress': ..., 'dirn': '1000', 'status': 'Registered'}}

  >>> unity = CUCX.Connect("10.10.10.20", "admin", "P@ssw0rd")
  >>> unity.get("users")
  [{'URI': '/vmrest/users/a151...123', 'ObjectId': 'a151...123', 'Alias': 'undeliverablemess... }]
  >>> unity.get("/vmrest/users", DtmfAccessId="10*", sort="DtmfAccessId")
  [{'URI': ..., 'ObjectId': ..., 'FirstName': '', 'LastName': '', 'Alias': '1000', 'DisplayName': '1000', 'EmailAddress': '', ... }]

  >>> ccx = UCCX.Connect("10.10.10.40", "admin", "P@ssw0rd")
  >>> ccx.get("application")
  [{'@type': 'applicationXMLList', 'application': []}]

  >>> wbx = Webex.Connect(token)
  >>> wbx.get("/v1/people/me")
  {'id': 'Y2l...mYTg', 'emails': ['jsn....com'], 'phoneNumbers': [{'type': 'work', 'value': '2001'}, ...}]
  ```

  Notes:
  The AXL SOAP API was generated based on the version 14 WSDL files and may not be complete or function depending on version. A version specific SOAP client is built at CollabConnector.CUCM.axl and can be leveraged as a backup as needed, however no post call treatment is made so soap responses will need to be sterilized etc if used.
  ```commandline
  >>> from CollabConnector import CUCM

  >>> cucm = CUCM.Connect("10.10.10.10", "admin", "P@ssw0rd")
  >>> cucm.axl.getPhone(name="SEPAAAABBBBCCCC")
  [{'name': 'SEP3C08F67A9618', 'description': 'Auto 1000', 'product': 'Cisco 7841', 'mod... }]
  ```


pkgId: 05f8344f892324fbc8b9bfc1029bc55a9a6ce5e4a00e3bc300b49e4f5a29c66d
name: python-Commify-help
arch: noarch
version: 1.4.5.2
epoch: 0
release: 1
summary: Development documents and examples for Commify
url: https://matuco19.com/Commify
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Commify-1.4.5.2-1.src.rpm
location_href: Packages/python-Commify-help-1.4.5.2-1.noarch.rpm
checksum_type: sha256
description:
  - **AI-Powered Commit Messages:** Generate concise and structured commit messages using the `ollama` local AI provider or `G4F` AI provider.
  - **Emoji Support:** Optionally include relevant emojis in commit messages.
  - **Language Support:** Generate commit messages in the language of your choice.
  - **Customizable Providers:** Specify the AI provider to use (g4f or ollama).
  - **Interactive Review System:** Review and approve generated messages or request new ones.


pkgId: 0e36acdfd7a233e5a7169308d6dab79a6db0bd48d2f1e4198178aadb768337e1
name: python-Commify-help
arch: noarch
version: 1.5
epoch: 0
release: 1
summary: Development documents and examples for Commify
url: https://matuco19.com/Commify
rpm_license: MATCO-Open-Source
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Commify-1.5-1.src.rpm
location_href: Packages/python-Commify-help-1.5-1.noarch.rpm
checksum_type: sha256
description:
  - **AI-Powered Commit Messages:** Generate concise and structured commit messages using the `ollama` local AI provider, `G4F` AI provider or `Openai` AI provider (Openai provider requires an apikey).
  - **Emoji Support:** Optionally include relevant emojis in commit messages.
  - **Language Support:** Generate commit messages in the language of your choice.
  - **Customizable Providers:** Specify the AI provider to use (g4f, ollama or openai).
  - **Interactive Review System:** Review and approve generated messages or request new ones.


pkgId: 4c32e51e93562cadeb0e55c14b94ab15c5b9e25b927b742ca95fcfb8039db111
name: python-Cp2kData-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for Cp2kData
url: https://pypi.org/project/Cp2kData/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Cp2kData-0.7.2-1.src.rpm
location_href: Packages/python-Cp2kData-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/robinzyb/cp2kdata/actions/workflows/ci.yml/badge.svg)
  ![Coverage Status](https://img.shields.io/codecov/c/github/robinzyb/cp2kdata)
  ![pythonv](https://img.shields.io/pypi/pyversions/cp2kdata)
  ![pypiv](https://img.shields.io/pypi/v/cp2kdata)
  ![PyPI - pip install](https://img.shields.io/pypi/dm/cp2kdata?logo=pypi&label=pip%20install)
  ![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/cp2kdata?label=conda-forge)

  A Python Package to postprocess cp2k data, including cube, pdos, output files




  ```bash
  pip install cp2kdata
  ```


  One can download the source code of cp2kdata by
  ```bash
  git clone https://github.com/robinzyb/cp2kdata.git cp2kdata
  ```
  then use `pip` to install the module from source

  ```bash
  cd cp2kdata
  pip install .
  ```


  - [Manipulate CP2K Output/Log Files](./docs/output.md)
  - [Manipulate CP2K Cube Files](./docs/cube/README.md)
  - [Manipulate CP2K Pdos Files](./docs/pdos/README.md)


  - [The plugin for dpdata](./docs/dpdata_plugin.md)


  Any advice is welcome. If you would like to request a new feature, please open an issue in github and upload example input and output files.


  set environment variable CP2KDATA_LOG_LEVEL to DEBUG to get the complete information.

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


pkgId: c699d41e4b21d8e110a2443b1dcc78ea0e425ab26bc1348a93056afe48b094c2
name: python-Crane-FMU-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for Crane-FMU
url: https://github.com/dnv-opensource/crane-fmu
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Crane-FMU-0.1.1-1.src.rpm
location_href: Packages/python-Crane-FMU-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  The package extends the `component_model` package to provide the means to construct cranes.
  The package can be used to define concrete cranes and simulate their usage, see `tests/resources/mobile-crane.py` as example.

rpm_license:
  MIT License  Copyright (c) 2024 [DNV](https://www.dnv.com) [open source](https://github.com/dnv-opensource)  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: 816994e88fd1dabe9aabb2a3ebbc3acc34a8ebdeb453b95f917b702dd6cf3b59
name: python-Crawl4AI-help
arch: noarch
version: 0.4.21
epoch: 0
release: 1
summary: Development documents and examples for Crawl4AI
url: https://github.com/unclecode/crawl4ai
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Crawl4AI-0.4.21-1.src.rpm
location_href: Packages/python-Crawl4AI-help-0.4.21-1.noarch.rpm
checksum_type: sha256
description:
  The sync version is deprecated and will be removed in future versions. If you need the synchronous version using Selenium:
  ```bash
  pip install crawl4ai[sync]


pkgId: c9fedc93421e2da9bb2f1bf40cd39fe8882b7d0a7d2c583d3c4111c9e79c063c
name: python-CytoDataFrame-help
arch: noarch
version: 0.0.15
epoch: 0
release: 1
summary: Development documents and examples for CytoDataFrame
url: https://pypi.org/project/CytoDataFrame/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CytoDataFrame-0.0.15-1.src.rpm
location_href: Packages/python-CytoDataFrame-help-0.0.15-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/cytodataframe)](https://pypi.org/project/CytoDataFrame/)
  [![Build Status](https://github.com/WayScience/CytoDataFrame/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/WayScience/CytoDataFrame/actions/workflows/run-tests.yml?query=branch%3Amain)
  ![Coverage Status](https://raw.githubusercontent.com/WayScience/CytoDataFrame/main/media/coverage-badge.svg)
  [![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)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)

  ![](https://raw.githubusercontent.com/WayScience/coSMicQC/refs/heads/main/docs/presentations/2024-09-18-SBI2-Conference/images/cosmicqc-example-cytodataframe.png)
  _CytoDataFrame extends Pandas functionality to help display single-cell profile data alongside related images._

  CytoDataFrame is an advanced in-memory data analysis format designed for single-cell profiling, integrating not only the data profiles but also their corresponding microscopy images and segmentation masks.
  Traditional single-cell profiling often excludes the associated images from analysis, limiting the scope of research.
  CytoDataFrame bridges this gap, offering a purpose-built solution for comprehensive analysis that incorporates both the data and images, empowering more detailed and visual insights in single-cell research.

  CytoDataFrame development began within [coSMicQC](https://github.com/WayScience/coSMicQC) - a single-cell profile quality control package.



  Install CytoDataFrame from source using the following:

  ```shell

  pip install cytodataframe


  pip install git+https://github.com/WayScience/CytoDataFrame.git
  ```



  Please see our [contributing](https://WayScience.github.io/CytoDataFrame/main/contributing) documentation for more details on contributions, development, and testing.



  - [coSMicQC](https://github.com/WayScience/coSMicQC)
  - [pycytominer](https://github.com/cytomining/pycytominer)
  - [CellProfiler](https://github.com/CellProfiler/CellProfiler)
  - [CytoTable](https://github.com/cytomining/CytoTable)


pkgId: dede629b3a8a2f1e53117760edcedaaf9292a7154459a89ab9baf43b16c687d9
name: python-D2AF
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Distortion Distribution Analysis enabled by Fragmentation
url: https://github.com/yanjordan/D2AF
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-D2AF-1.0.2-1.src.rpm
location_href: Packages/python-D2AF-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align=center><img src=Docs/toc.png  width="400" /></div>


  D2AF is an efficient, general and flexible fragmentation-based approach for local distortion analysis on various chemical and biological-related molecules. D2AF bases on fragmentation and ONIOM-type boundary strategies to evaluate/estimate (relative) local distortion energies of one (or multiple) structure(s)/conformer(s) (**Tar**; more distortion) relative to the reference structure (**Ref**; less distortion) at the given computational chemistry level (the user adopts).

  **Any type of structures (stationary-point structures: e.g., local minimum, transition state(s); non-stationary-point structures: e.g., MD- or IRC-derived structures) can be adopted as **Tar** and **Ref** and compared in D2AF.**  (Relative) Local distortion energies of all subsystems/fragments for the **Tar** structure(s) relative to the **Ref** structure can be used for visualization (so-called **distortion map** or distortion distribution).


  Fragmentation of subsystems can be defined using three approachs:
  * 1. Atomic/fragment resolution (**M1**)
  * 2. Individual bond and angle resolution based on internal coordinates (bond, angle, optionlly dihedral) (**M2**)
  * 3. Combination of **M1 & M2**  (**M3**), esp. complex systems containing aromatic and/or metal-coordination



  <div align=center><img src=Docs/Fig1.png  width="640" /></div>

  <div align=center><big><b>Workflow</b></big></div>
  <!--
  <div align=center><img src=Docs/SchemeS1.png  width="640" /></div>
  <div align=center><big><b>Technique details</b></big></div>
  -->



  **conda env**

      conda env create -f environment.yml


  **using pypi**

      pip install D2AF
  or

      pip install D2AF-x.x.x-py3-none-any.whl


  D2AF:
  - python=3.9
  - numpy
  - pandas
  - openbabel
  - openpyxl

  [Gaussian](https://gaussian.com/):
  - Gaussian03/09/16

  [xTB](https://xtb-python.readthedocs.io/en/latest/#):
  - xtb-python

  [ANI](https://aiqm.github.io/torchani/index.html):
  - torchvision
  - torch
  - torchani

  [MLatom](http://mlatom.com/):
  - matplotlib
  - tensorboard
  - torchvision
  - torch
  - torchani
  - MLatom (3.0.0)
  - scipy
  - pyh5md
  - statsmodels

  [ORCA](https://orcaforum.kofo.mpg.de/):
  - ORCA 5 (method info of orca should be written in the method line of gjf file)
  see example in \Applications\reverse Cope elimination\CCSD\4F-reactant.gjf
      *\#* + **orca method** + *geom=connectivity*
  ```
      
  ```
  You need to define **$ORCA_BIN** in the environment variable (where executable **orca** file installed) e.g.
   ```
      export $ORCA_BIN=/home/username/orca_5.0.0_linux_x86-64/bin
   ```

  Quantum Chemical (QC) calculation packages:
  - Gaussian: Gaussian03,09,16
  - xTB: xTB-python (not support "calculator=nocalc")
  - ANI: torchani  (not support "calculator=nocalc")
  - Mlatom: AIQM1 (not support "calculator=nocalc")
  - *Any codes are possible through generating their corresponding QC input files from our generated XYZ files for each fragment, running them and extracting energy (in a.u.) by users' script(s) (using "calculator=nocalc" in the D2AF input; see below)*



  *Optional: to check any large diheral difference bewteen the reference and target forms. If detecting any large diheral difference(s), modify **fraglist** for **M1** or add **#include** for **M1 or M2*** e.g.

      check_dihedral ABC-ref.gjf ABC-conf.gjf
      check_dihedral ABC-ref.gjf ABC-conf.gjf thershold(optional)

  where ABC-ref.gjf & ABC-conf.gjf are any xyz or Gaussian gjf files for the reference and target forms. A value is the thershold (optional) for the large diheral(s) to be printed.

  *Optional: to generate suggestive fragmentation list for **M1 or M3*** e.g.

      autofragment coord

  where coord is any xyz file or Gaussian gjf file with/without connectivity. It will generate a new gjf file with connectivity, fraglist for **M1 or M3** as well as a new D2AF template input file (users can modify). No need for **M2**


  **To run all proccess: fragmentation, calculations via our calls, and analysis. D2AF input (e.g., ABC.inp) and output (e.g., ABC.dat) E.g.,**

      D2AF -inp ABC.inp > ABC.dat


  *To run fragmentation only; subsequently run/call quantum chemistry calculations (**setting "calculator=nocalc" in the D2AF input file**) by users*

  1. Generate fragments, which are then written in **\tmpdir** folder (xyz files with charge and multiplicity in the second line). E.g.,
  ```
      D2AF -inp ABC.inp  > ABC.dat
  ```

  2. Run QC calculations and extract the energies by users (e.g. running jobs in different machine or a way to use specific QC codes users want).

  - (a) *run the calculations by users (fragments in **xxx_i.xyz** files generated in the **\tmpdir** folder)*

  - (b) *extract the energies to **xxx_i.log** (in a.u. unit; 1st line) for each structure in the **\tmpdir** folder* **Make sure your QC output file names does not have *.log*, (or add the energy to the 1st line of the log files, if you use different QC packages and prefer to use .log as your QC output file names.** Possibly a new keyword would be added to read an external file with a list of energies.

  3. Run D2AF again to do analysis only, after the QC results are extracted in the above step 2 by users (**setting "calculator=nocalc" in the D2AF input file**). E.g.,
  ```
      D2AF -inp ABC.inp  > ABC_anal.dat
  ```


  *To list commands*

      D2AF -h



  calculator available:
      ['g03', 'g09', 'g16','gfn1-xtb', 'gfn2-xtb','ani-1x', 'ani-2x', 'ani-1ccx', 'aiqm1', 'nocalc']

  D2AF input file example:

      ref = ABC-ref.gjf
      conf = ABC-conf.gjf
      method = 1
      cpu = int
      pal = int
      calculator = g16
      scale = log

      
      1-2,4-6
      3

      
      3-5

      
      1 2
      1 2 3

      
      4 7
      4 7 9

      
      5 1

      
      3 1


  **ref**: e.g., ABC-ref.gjf, a reference structure (**Ref** form) in a Gaussian file format, containing **method lines**, **cartesian coordinates** and **connectivity**
  * the connectivity (bond order) values should be **1.0, 2.0, 3.0** only!
  * **1.5 is forbidden**, it should be modified before running D2AF!

  **conf**: e.g., ABC-conf.gjf or ABC-conf.xyz, a target structure (gjf or xyz), or multiple target structures in one xyz file (**Tar** form)

  **method**: 1 for atomic/framentation-based (**M1**), 2 for bond/angle/diheral based (**M2**; users need to give the diheral list in #include), 3 for 1+2 method (**M3**)

  **cpu**: number of cpu for subsystem computation (int)

  **pal**: number of paralle subsystem computations (available for Gaussian, xTB; int)

  **calculator**: Gaussian (g16, g09), "xTB", "ANI", "AIQM1" for subsystem computations via our call. Alternatively, "nocalc" for calling QC calculations or do analysis by users (seperating fragmentation, calculations and analysis processes)

  **scale**: log/e scale factor for pymol visualization

  **fraglist**: **for M1/M3**, define the fragmentation list

  **coordination**: **for M3**, define the metal coordination center/region (same listing format as fraglist). Some molecular editors (e.g., Gauview, pymol, VMD) may easily set th coordination sphere and get the list of these atoms involved

  **include**: **for M2/M3**, add additional bond(s)/angle(s)/diheral(s) users want. *By default, all diherals are not considered. Users should add the diheral list they want.*

  **exclude**: **for M2/M3**, exclude the bond(s)/angle(s) users want

  **charge**: define the formal atomic charge (second value) of the pariticular atom(s) (first value) if not 0

  **spin**: define the formal atomic spin (second value) of the pariticular atom(s) (first value) if not 0 (using integer: spin * 2)


  *Currently, if users want to use different link atoms for some specific boundary(ies) they like, users need to manually modify their corresponding QC input files* Possibly, new keywords will be added to modify a few link atoms.





   - An excel file (*M1/M2/M3.xlsx) stores all detailed (relative) distortion energy as well as changes (delta) of the coordinates.
   - A few Python scripts display (relative) distortion map (e.g., *M1_frag.pml, *M2_total.pml, *M2_bond.pml, *M2_angle.pml)
   -  A few Python scripts display the difference (delta) of the coordinates (e.g., *bond_delta.pml, *anglep_delta.pml, *anglen_delta.pml). *anglep_delta.pml and *anglen_delta.pml represent the positive and negative changes in the bond angles, respectively.
   -  *frag_show.pml shows fragmentation (e.g. M1).
   - *Pymol possibly display slim bonds with hydrogen atoms. Users can type "set stick_h_scale, 0.9" and/or "set stick_radius, 0.2" in the Pymol command bar* to modify the H stick thickness and/or the stick radius users like. If users prefer to use their preferred Pymol setting(s), users can add setting commands in their pymol file (.pymolrc.py) Please see Pymol Wiki website (https://pymolwiki.org/)
   - D2AF output (e.g., ABC.dat; cf., the above **(D) Usage section**) lists the key info. Also, a large change/difference in diheral(s) are given/listed in the output file for **the M2/M3 case. By default, (relative) distortion energy for diherals are not considered. If large change/difference in some diherals are found, users should add these diheral list in the "#include" keyword and restart analysis for M2 (running calculations of new diheral fragment(s) only if all old files kept intact) again at the same directory.** Meanwhile, users can **modify the fraglist of the D2AF input to expand the size of the related fragments (including diheral contribution) for the M1/M3 cases and perform new D2AF calculations.** In this case, *restart D2AF* is **NOT recommended for the M1/M3 cases**, as the fraglist (as well as fragments) is changed.




  **autofragment.py**  `autofragment`

  Auto fragmentation. A pymol script (**_auto_frag_show.pml) is generated. Users can check fragments and judge whether fragments are chemically reasonable. Users can manually modify the D2AF input to change fragments, if some are not reasonable.

  input: xyz file or Gaussian gjf file with/without connectivity

  ouput: gjf file with connectivity, suggestive fraglist for **M1**, pymol script for visualization


  **atompair.py**  `atompair`

  Pairing atom order between two gjfs with the same connectivity info but different label order

  input: gjf1 gjf2 Gaussian files with connectivity

  ouput: new gjf2 with same atom label to gjf1

  the symmetric atoms cannot be applid (warning information)


  **pml_str.py**  `pml_str`

  Add addtional commands to Pymol script (pml) files for `bond id x, id x` and `unbond id x, id x` (using `;` to separate lines) in a `""` **not** `''`


  **write_run_pml.py**  `write_run_pml`

  Write Pymol pml *Run Script* to generate distortion map (png) files for multi-structures case (e.g., IRC/MD).

  inputs: `method number` eg.: `M2 125`


  **multi_mov.py**  `multi_mov`

  After Run Pymol pml to generate distortion map (png) files for multi-structure case (e.g., IRC/MD). Generate electronic energy (MEP) and distortion energy distortion figure for each conformer, then combine them with the distortion map visualization (png) to generate a movie

  inputs: `energy_xlsx type(IRC/MD)` where xlsx file including ` pos, Energy, Strain M1/M2/M3 columns`


  **Combine_multi_conf.py**  `Combine_multi`

  Similar to Combine_fig_MS.py, but for multiple structures/conformers.

  inputs: `conf_id1 conf_id2 ... conf_idn` combine selected confs


  **Combine_fig_MS.py/Combine_fig_ppt.py**  `Combine_fig_MS/Combine_fig_ppt`

  Combine multiple distortion maps/pngs (M1, M2, M3) into one png for publication (label a/b/c/d) or ppt (file names)





  Efficient and Flexible Approach for Local Distortion: Distortion Distribution Analysis enabled by Fragmentation. Z. Yan, Y. S. Liao, X. Li, and L. W. Chung, **2024** *(submitted)* & *ChemRxiv.* DOI: 10.26434/chemrxiv-2024-07rmf (https://doi.org/10.26434/chemrxiv-2024-07rmf) This content is a preprint and has not been peer-reviewed.

  The ONIOM Method and its Applications. Chung, L. W.; Sameera, W. M. C.; Ramozzi, R.; Page, A. J.; Hatanaka, M.; Petrova, G. P.; Harris, T. V.; Li, X.; Ke, Z.; Liu, F.; Li, H.-B.; Ding, L. Morokuma, K. *Chem. Rev.* **2015**, 115, 5678.[DOI: https://doi.org/10.1021/cr5004419](https://doi.org/10.1021/cr5004419)


pkgId: 758176f5b496361f14803990e6ce3f0b28947b737d8799e2bd7c62ba31071ab7
name: python-DDDHtml-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for DDDHtml
url: https://github.com/DonnieDarkDev/DDDHtml
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-DDDHtml-0.1.0-1.src.rpm
location_href: Packages/python-DDDHtml-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ![alt text](C:\Users\Gina\Pictures\My Icon\Final\512.png)

   Helper to build html files


  ```
  * Add basic element support
  * Add pip install support
  ```


pkgId: d5d686b03ce2c5f332e4beb5c657f79d42c3b2c03e25a155a20fe2dd1564b52b
name: python-DIRAC-help
arch: noarch
version: 8.0.61
epoch: 0
release: 1
summary: Development documents and examples for DIRAC
url: https://github.com/DIRACGrid/DIRAC/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-DIRAC-8.0.61-1.src.rpm
location_href: Packages/python-DIRAC-help-8.0.61-1.noarch.rpm
checksum_type: sha256
description:
  DIRAC is an interware, meaning a software framework for distributed computing.
  DIRAC provides a complete solution to one or more user community requiring access to distributed resources. DIRAC builds a layer between the users and the resources offering a common interface to a number of heterogeneous providers, integrating them in a seamless manner, providing interoperability, at the same time as an optimized, transparent and reliable usage of the resources.
  DIRAC has been started by the `LHCb collaboration <https://lhcb.web.cern.ch/lhcb/>`_ who still maintains it. It is now used by several communities (AKA VO=Virtual Organizations) for their distributed computing workflows.
  DIRAC is written in python 3.9.
  Status rel-v8r0 series (stable, recommended):
  Status integration branch (devel):


pkgId: 9d74fb30ab6f396c9b169f954df8f74eeec38f10fda816ef781c878430bd8b73
name: python-DPTool-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for DPTool
url: https://pypi.org/project/DPTool/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-DPTool-1.0.3-1.src.rpm
location_href: Packages/python-DPTool-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  * Ver 1.0.3
  1. 改bug

  * Ver 1.0.2
  1. 改bug

  * Ver 1.0.1
  1. 改bug

  * Ver 1.0.0
  本脚本基于DrissionPage提供API运行。喜欢本功能请给DrissionPage作者g1879买杯咖啡，支持原作者。DrissionPage Github: https://github.com/g1879/DrissionPage


pkgId: 07bcea1cfae28ffc2747c6f0ebc60c4b19adc39a436d98187ce1a09eaca268ac
name: python-DebugInfo-help
arch: noarch
version: 65.2.0
epoch: 0
release: 1
summary: Development documents and examples for DebugInfo
url: https://gitee.com/DyyYq/DebugInfo.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-DebugInfo-65.2.0-1.src.rpm
location_href: Packages/python-DebugInfo-help-65.2.0-1.noarch.rpm
checksum_type: sha256
description:
  一个用于消息整理和打印输出的模块，主要功能包括 文本对齐，表格对齐，文本修饰，生成分隔线，文本颜色修饰等，另外，还提供了一个秒表装饰器 和一个语义日期模板。



  调试模块.py # 主功能代码


  本程序依赖以下库:
  - colorama
  - wcwidth
  - pyperclip
  - argparse
  - 其它标准库



  ```bash
  pip install DebugInfo
  ```




  ```python



  from DebugInfo.DebugInfo import *




  print(红字('这是串红色的文字'))
  ```
  以上代码，将要打印的文本通过方法 红字 修饰后做为 print 的参数，则可以打印出红色的字体，如下：
  ![输入图片说明](demo%20%E7%BA%A2%E5%AD%97.jpg)

  **DebugInfo**模型还提供了以下的颜色修饰支持，以下代码分别进行的方法名和效果的打印展示：
  ```python



  from DebugInfo.DebugInfo import *



  画板 = 打印模板()

  画板.添加一行('红字', 红字('红字'))
  画板.添加一行('红底', 红底('红底'))

  画板.添加一行('红底白字', 红底白字('红底白字'))
  画板.添加一行('红底黑字', 红底黑字('红底黑字'))
  画板.添加一行('红底黄字', 红底黄字('红底黄字'))
  画板.添加一行('绿字', 绿字('绿字'))
  画板.添加一行('绿底', 绿底('绿底'))
  画板.添加一行('黄字', 黄字('黄字'))

  画板.添加一行('黄底', 黄底('黄底'))
  画板.添加一行('蓝字', 蓝字('蓝字'))
  画板.添加一行('蓝底', 蓝底('蓝底'))

  画板.添加一行('洋红字', 洋红字('洋红字'))
  画板.添加一行('洋红底', 洋红底('洋红底'))
  画板.添加一行('青字', 青字('青字'))
  画板.添加一行('青底', 青底('青底'))
  画板.添加一行('白字', 白字('白字'))
  画板.添加一行('白底黑字', 白底黑字('白底黑字'))

  画板.添加一行('黑字', 黑字('黑字'))
  画板.添加一行('黑底', 黑底('黑底'))
  画板.添加一行('绿底白字', 绿底白字('绿底白字'))

  画板.展示表格()
  ```
  代码运行如下：
  ![输入图片说明](demo%20%E6%96%87%E5%AD%97%E4%B8%8A%E8%89%B2%E6%89%93%E5%8D%B0%E6%95%88%E6%9E%9C.jpg)

  事实上，不同的颜色修饰是可以嵌套的，例如下面的代码将红字进行三重修饰。
  ```python



  from DebugInfo.DebugInfo import *



  文本 = 红字('红字')
  文本 = 黄字(f'黄字{文本}')
  文本 = 蓝字(f'蓝字{文本}')

  print(文本)
  ```

  上面的代码运行效果如下，最内层是红字，中间是黄字，外层是蓝字：
  ![输入图片说明](demo%20%E6%96%87%E5%AD%97%E9%A2%9C%E8%89%B2%E7%9A%84%E5%B5%8C%E5%A5%97%E4%BF%AE%E9%A5%B0.jpg)

  ***

  **DebugInfo**模块提供了一个**分隔线模板**类，可以方便的生成分隔线。分隔线模板支持：
  - 指定符号
  - 指定提示内容
  -- 指定对齐方式
  - 修饰颜色
  - 指定长度
  -- 提示内容不影响分隔线长度,除非提示内容长于指定的总长度

  🎯 以下代码中,使用分隔线模板生成了4条分隔线实例,使用 print 函数进行打印
  ```python



  from DebugInfo.DebugInfo import *



  print(分隔线模板(), ': 这是默认的分隔线, 符号是 -, 长度是 50, 默认文本颜色')
  print()
  print(分隔线模板().符号('~ '), ': 这是一个定制的分隔线, 符号是 ~')
  print()
  print(分隔线模板().符号('-').提示内容('我是分隔线'), ': 这是一个定制的分隔线, 符号是 -, 有提示内容, 但提示内容不影响分隔线的长度')
  print()
  print(分隔线模板().符号('-').提示内容('我是分隔线').修饰(红字), ': 这是一个定制的分隔线, 符号是 -, 有提示内容, 文本颜色被修饰为红色了')
  ```
  ![输入图片说明](demo%20%E5%88%86%E9%9A%94%E7%BA%BF%E7%94%9F%E6%88%90.jpg)

  🎯 下面的代码展示了分隔提示文本的对齐操作,和使用效果; 代码生成并打印了三条分隔线,其提示文本分别使用了不同的对齐方式
  ```python



  from DebugInfo.DebugInfo import *



  print(分隔线模板().提示内容('提示内容在这里').文本对齐('l'), f": 分隔线提示文本是 {黄字('左对齐')} 的")
  print()
  print(分隔线模板().提示内容('提示内容在这里').文本对齐('c'), f": 分隔线提示文本是 {黄字('居中对齐')} 的")
  print()
  print(分隔线模板().提示内容('提示内容在这里').文本对齐('r'), f": 分隔线提示文本是 {黄字('右对齐')} 的")
  ```
  ![输入图片说明](demo%20%E5%88%86%E9%9A%94%E7%BA%BF%20%E6%8F%90%E7%A4%BA%E6%96%87%E6%9C%AC%E5%AF%B9%E9%BD%90.jpg)

  🎯 下面的代码展示了如何控制分隔线的长度; 代码中分别生成了三条分隔线,使用了不同的长度(**等效英文空格宽度的数量**)
  ```python



  from DebugInfo.DebugInfo import *



  print()
  print(分隔线模板().提示内容('提示内容在这里'), '这是默认的长度, 50 英文空格宽度')
  print()
  print(分隔线模板().提示内容('提示内容在这里').总长度(60), '指定分隔线长度为 60 英文空格宽度')
  print()
  print(分隔线模板().提示内容('提示内容在这里').总长度(80), '指定分隔线长度为 80 英文空格宽度')
  ```
  ![输入图片说明](demo%20%E5%88%86%E9%9A%94%E7%BA%BF%20%E4%B8%8D%E5%90%8C%E9%95%BF%E5%BA%A6%E7%9A%84%E5%88%86%E9%9A%94%E7%BA%BF.jpg)

  ***

  **DebugInfo**模块提供了文本对齐功能, 基础思想是通过英文空格来进行间隙填充,以使文本内容达到对齐的效果,这可以理解为一个表格。表格提供以下功能：
  - 添加单行
  -- 支持修饰
  -- 支持字符串内换行符的换行对齐
  - 添加多行
  - 支持分隔行
  - 修饰指定的列
  - 控制对齐的列间距
  - 控制对齐表列宽度
  - 支持左右颠倒表格
  - 支持上下颠倒表格

  🎯 下面的代码演示了文本对齐的效果,支持中文,英文,数字,符号等各种混合字符串的对齐打印; 代码中构造了一个示例数据,数据是个二维list对象,第一列的同容中包含了**中文,英文,日文,数字**等内容,成分比较复杂.
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526'],
              ['刘Sire', '技术宅,大牛'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg'],
              ['Kelly Jackson', "I don't know who is it"],
              ['123456', '一串数字']]

  画板 = 打印模板()

  画板.添加一行('项目', '内容', '->这一行是青色的,是标题哦').修饰行(青字)
  for 项目 in 示例数据:
      画板.添加一行(项目[0], 项目[1])

  画板.展示表格()
  ```
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E5%AF%B9%E9%BD%90%E6%89%93%E5%8D%B0%E6%95%88%E6%9E%9C.jpg)
  上图我们可以观察到,打印输出的第二列很整齐的对齐到了一起,不受第一列中内容的影响.
  上面的代码和输出中,我们观察到我们对第一行的内容进行了修饰操作,这将使得第一行的内容高亮显示,这个效果可以做为标题的效果使用.

  🎯 事实上,对齐二维list对象,是可以更灵活的添加到表格行中,如下演示了两种方法
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526'],
              ['刘Sire', '技术宅,大牛'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg'],
              ['Kelly Jackson', "I don't know who is it"],
              ['123456', '一串数字']]

  画板 = 打印模板()


  for 数据行 in 示例数据:
      
      画板.添加一行(数据行)


  画板.添加多行(示例数据)
  ```

  🎯 表格数据支持左右颠倒操作,例如下面的代码, 以及打印效果
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526'],
              ['刘Sire', '技术宅,大牛'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg'],
              ['Kelly Jackson', "I don't know who is it"],
              ['123456', '一串数字']]

  画板 = 打印模板()

  画板.添加一行('项目', '内容').修饰行(青字)
  画板.添加多行(示例数据)

  画板.左右颠倒表格().展示表格()
  ```
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E5%B7%A6%E5%8F%B3%E9%A2%A0%E5%80%92%E6%93%8D%E4%BD%9C.jpg)


  🎯 表格支持指定列宽操作,如下的代码里在准备表格时,指定了第2列的宽度为50,观察其效果:
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526', '|'],
              ['刘Sire', '技术宅,大牛', '|'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文', '|'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg', '|'],
              ['Kelly Jackson', "I don't know who is it", '|'],
              ['123456', '一串数字', '|']]

  画板 = 打印模板()

  画板.准备表格(列宽控制表=[0, 50])
  画板.添加一行('项目', '内容', '参考列').修饰行(青字)
  画板.添加多行(示例数据)

  画板.展示表格()
  ```
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E6%8C%87%E5%AE%9A%E5%88%97%E5%AE%BD.jpg)
  上图, 我们观察第三列的参考列,可以明显发现第2列的宽度是变宽了(实际上是指定数量的英文空格宽度)

  🎯 表格支持指定列对齐方式,下面的代码中,我们在准备表格时指定列第2列的对齐方式为 'c': 居中对齐:
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526', '|'],
              ['刘Sire', '技术宅,大牛', '|'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文', '|'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg', '|'],
              ['Kelly Jackson', "I don't know who is it", '|'],
              ['123456', '一串数字', '|']]

  画板 = 打印模板()

  画板.准备表格(对齐控制串='lc', 列宽控制表=[0, 50])
  画板.添加一行('项目', '内容', '参考列').修饰行(青字)
  画板.添加多行(示例数据)

  画板.展示表格()
  ```
  观察下图, 第2列的内容相对于其指定的列宽,进行了居中对齐:
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E5%88%97%E5%B1%85%E4%B8%AD%E5%AF%B9%E9%BD%90.jpg)

  🎯 事实上,表格还支持指定列间距,如下代码指定了第一个列间距为15, 第一个列间距为第2列与第1列之间的间距:
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526', '|'],
              ['刘Sire', '技术宅,大牛', '|'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文', '|'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg', '|'],
              ['Kelly Jackson', "I don't know who is it", '|'],
              ['123456', '一串数字', '|']]

  画板 = 打印模板()

  画板.准备表格()
  画板.添加一行('项目', '内容', '参考列').修饰行(青字)
  画板.添加多行(示例数据)

  画板.表格列间距 = [15]
  画板.展示表格()
  ```
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E6%8C%87%E5%AE%9A%E5%88%97%E9%97%B4%E8%B7%9D.jpg)

  🎯 表格数据支持上下颠倒操作,例如下面的代码, 以及打印效果
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526'],
              ['刘Sire', '技术宅,大牛'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg'],
              ['Kelly Jackson', "I don't know who is it"],
              ['123456', '一串数字']]

  画板 = 打印模板()

  画板.添加一行('项目', '内容').修饰行(青字)
  画板.添加多行(示例数据)

  画板.上下颠倒表格().展示表格()
  ```
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E4%B8%8A%E4%B8%8B%E9%A2%A0%E5%80%92%E6%93%8D%E4%BD%9C.jpg)
  我们观察到,第一行的**标题**行也被调整到了最后一行,这是因为模板中的表格并没有严格的标题概念,所有内容都是普通行,这是需要注意的一点.
  这情况下,我们把**标题**行的内容放到其它内容之后添加,再上下颠倒操作,就可以解决.

  🎯 表格支持修饰列操作,如下的代码将第2列(列索引号自0开始,所以第2列的列索引号是1,程序猿都懂)修饰为黄色的文字:
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526', '第3列'],
              ['刘Sire', '技术宅,大牛', '第3列'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文', '第3列'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg', '第3列'],
              ['Kelly Jackson', "I don't know who is it", '第3列'],
              ['123456', '一串数字', '第3列']]

  画板 = 打印模板()

  画板.添加一行('项目', '内容').修饰行(青字)
  画板.添加多行(示例数据)

  画板.修饰列(1, 黄字).展示表格()
  ```
  上面的代码在**展示表格**前进行了**修饰列**操作,将指定的列使用方法 黄字 进行修饰,效果如下:
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E4%BF%AE%E9%A5%B0%E5%88%97%E6%93%8D%E4%BD%9C.jpg)

  🎯 表格支持添加分隔行操作,以下代码演示了如何为表格添加一个分隔行;
  代码先添加了部分数据,然后添加了一个分隔行,然后断续添加剩下的数据,最后展示表格内容
  ```python



  from DebugInfo.DebugInfo import *



  示例数据 = [['小张', '18745986526'],
              ['刘Sire', '技术宅,大牛'],
              ['中村 くみ子', '一个来自日本的同学, 喜欢学习中文'],
              ['zifang.zhang56', '重名太多,已经排到56号了, gg'],
              ['Kelly Jackson', "I don't know who is it"],
              ['123456', '一串数字']]

  画板 = 打印模板()
  画板.添加一行('项目', '内容').修饰行(青字)


  for 序号 in range(3):
      画板.添加一行(示例数据[序号])


  画板.添加分隔行('-', 绿字)


  for 序号 in range(3, len(示例数据)):
      画板.添加一行(示例数据[序号])

  画板.展示表格()
  ```
  ![输入图片说明](demo%20%E8%A1%A8%E6%A0%BC%20%E6%B7%BB%E5%8A%A0%E5%88%86%E9%9A%94%E8%A1%8C.jpg)

  表格还有一些其它的小功能支持,这里就不列举了,欢迎大家探索.

  ***

  **DebugInfo**模块封装 一个秒表计时器,这是一个装饰器,为快速函数性能测试提示了便利,下面是一个演示代码:

  ```python



  from DebugInfo.DebugInfo import *




  @秒表
  def 待测试的方法():
      
      for _ in range(10):
          print('hello world')


  待测试的方法()
  ```
  秒表装饰器提供的计算信息如下:
  ![输入图片说明](demo%20%E7%A7%92%E8%A1%A8.jpg)

  ***

  **DebugInfo**模块封装了一个语义日期模板,可以为指定的时间提供相对于今天的语义日期翻译.演示代码如下:

  ```python



  from DebugInfo.DebugInfo import *
  from datetime import datetime, timedelta



  画板 = 打印模板()

  画板.添加一行('日期', '', '日期语义').修饰行(青字)
  画板.添加一行(datetime.now().date() + timedelta(days=-365 * 5), '->', 语义日期模板(datetime.now() + timedelta(days=-365 * 5)))
  画板.添加一行(datetime.now().date() + timedelta(days=-365), '->', 语义日期模板(datetime.now() + timedelta(days=-365)))
  画板.添加一行(datetime.now().date() + timedelta(days=-180), '->', 语义日期模板(datetime.now() + timedelta(days=-180)))
  画板.添加一行(datetime.now().date() + timedelta(days=-40), '->', 语义日期模板(datetime.now() + timedelta(days=-40)))
  画板.添加一行(datetime.now().date() + timedelta(days=-20), '->', 语义日期模板(datetime.now() + timedelta(days=-20)))
  画板.添加一行(datetime.now().date() + timedelta(days=-8), '->', 语义日期模板(datetime.now() + timedelta(days=-8)))
  画板.添加一行(datetime.now().date() + timedelta(days=-2), '->', 语义日期模板(datetime.now() + timedelta(days=-2)))
  画板.添加一行(datetime.now().date() + timedelta(days=-1), '->', 语义日期模板(datetime.now() + timedelta(days=-1)))
  画板.添加一行(datetime.now().date() + timedelta(days=-0), '->', 语义日期模板(datetime.now() + timedelta(days=-0)))
  画板.添加一行(datetime.now().date() + timedelta(days=1), '->', 语义日期模板(datetime.now() + timedelta(days=1)))
  画板.添加一行(datetime.now().date() + timedelta(days=2), '->', 语义日期模板(datetime.now() + timedelta(days=2)))
  画板.添加一行(datetime.now().date() + timedelta(days=3), '->', 语义日期模板(datetime.now() + timedelta(days=3)))
  画板.添加一行(datetime.now().date() + timedelta(days=9), '->', 语义日期模板(datetime.now() + timedelta(days=9)))
  画板.添加一行(datetime.now().date() + timedelta(days=18), '->', 语义日期模板(datetime.now() + timedelta(days=18)))
  画板.添加一行(datetime.now().date() + timedelta(days=40), '->', 语义日期模板(datetime.now() + timedelta(days=40)))
  画板.添加一行(datetime.now().date() + timedelta(days=180), '->', 语义日期模板(datetime.now() + timedelta(days=180)))
  画板.添加一行(datetime.now().date() + timedelta(days=365), '->', 语义日期模板(datetime.now() + timedelta(days=365)))
  画板.添加一行(datetime.now().date() + timedelta(days=365 * 4), '->', 语义日期模板(datetime.now() + timedelta(days=365 * 4)))

  画板.分隔线.提示内容('语义日期演示').总长度(画板.表格宽度()).修饰(红字).展示()

  画板.修饰列(1, 绿字).展示表格()

  ```
  上述代码构造了18个日期,分别显示了其对应的语义日期,效果如下:
  ![输入图片说明](demo%20%E8%AF%AD%E4%B9%89%E6%97%A5%E6%9C%9F.jpg)

  ***




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



  1. 使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
  2. Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
  3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
  4. [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
  5. Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
  6. Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)


pkgId: a459c20d5a28438a7582006480778adba6f2fab7474861fdb939d834537f4e12
name: python-DeepAssimilate-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for DeepAssimilate
url: https://github.com/your-username/DeepAssimilate
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-DeepAssimilate-0.1.0-1.src.rpm
location_href: Packages/python-DeepAssimilate-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This package integrates station data into gridded data using deep learning techniques.


  ```bash
  pip install .
  ```

  ```
  from deepassimilate import DataAssimilation

  assimilator = DataAssimilation()
  result = assimilator.assimilate(gridded_data, station_data)
  ```


  FUXI-DA (https://arxiv.org/pdf/2404.08522) is a fully DL-native DA framework targeting a simplified, end-to-end pipeline for assimilating satellite data into ML forecasting models.

  FENGWU-4DVAR (https://arxiv.org/pdf/2312.12455) merges ML models with a classical 4D-Var setup, preserving the variational optimization approach and its theoretical foundations.

  Manshausen et al. (https://arxiv.org/pdf/2406.16947) demonstrate “score-based data assimilation” using a diffusion generative model trained purely from analysis states and then integrating sparse station observations at inference time to produce km-scale analyses, showcasing a zero-shot, generative approach distinct from both purely ML-native end-to-end frameworks and classical variational methods.


pkgId: 8707de43f56f8c1e749ab4fab8044796cafb3ad65aba0cffb8b1bffb12e62e6d
name: python-DelayedArray-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for DelayedArray
url: https://github.com/biocpy/DelayedArray
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-DelayedArray-0.6.0-1.src.rpm
location_href: Packages/python-DelayedArray-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- These are examples of badges you might want to add to your README:
       please update the URLs accordingly

  [![Built Status](https://api.cirrus-ci.com/github/<USER>/DelayedArray.svg?branch=main)](https://cirrus-ci.com/github/<USER>/DelayedArray)
  [![ReadTheDocs](https://readthedocs.org/projects/DelayedArray/badge/?version=latest)](https://DelayedArray.readthedocs.io/en/stable/)
  [![Coveralls](https://img.shields.io/coveralls/github/<USER>/DelayedArray/main.svg)](https://coveralls.io/r/<USER>/DelayedArray)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/DelayedArray.svg)](https://anaconda.org/conda-forge/DelayedArray)
  [![Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Twitter)](https://twitter.com/DelayedArray)
  -->

  [![Project generated with PyScaffold](https://img.shields.io/badge/-PyScaffold-005CA0?logo=pyscaffold)](https://pyscaffold.org/)
  [![PyPI-Server](https://img.shields.io/pypi/v/DelayedArray.svg)](https://pypi.org/project/DelayedArray/)
  [![Monthly Downloads](https://pepy.tech/badge/DelayedArray/month)](https://pepy.tech/project/DelayedArray)
  ![Unit tests](https://github.com/BiocPy/DelayedArray/actions/workflows/pypi-test.yml/badge.svg)





  This package implements classes for delayed array operations, mirroring the [Bioconductor package](https://bioconductor.org/packages/DelayedArray) of the same name.
  It allows BiocPy-based packages to easily inteoperate with delayed arrays from the Bioconductor ecosystem,
  with focus on serialization to/from file with [**chihaya**](https://github.com/ArtifactDB/chihaya)/[**rds2py**](https://github.com/BiocPy/rds2py)
  and entry into [**tatami**](https://github.com/tatami-inc/tatami)-compatible C++ libraries via [**mattress**](https://github.com/BiocPy/mattress).



  This package is published to [PyPI](https://pypi.org/project/delayedarray/) and can be installed via the usual methods:

  ```shell
  pip install delayedarray
  ```

  We can create a `DelayedArray` from any object that respects the seed contract,
  i.e., has the `shape`/`dtype` properties and supports NumPy slicing.
  For example, a typical NumPy array qualifies:

  ```python
  import numpy
  x = numpy.random.rand(100, 20)
  ```

  We can wrap this in a `DelayedArray` class:

  ```python
  import delayedarray
  d = delayedarray.wrap(x)














  ```

  And then we can use it in a variety of operations.
  For example, in genomics, a typical quality control task is to slice the matrix to remove uninteresting features (rows) or samples (columns):

  ```python
  filtered = d[1:100:2,1:8]
  filtered.shape

  ```

  We then divide by the total sum of each column to compute normalized values between samples.

  ```python
  total = filtered.sum(axis=0)
  normalized = filtered / total
  normalized.dtype

  ```

  And finally we compute a log-transformation to get some log-normalized values for visualization.

  ```python
  transformed = numpy.log1p(normalized)
  transformed[1:5,:]









  ```

  Each operation just returns a `DelayedArray` with an increasing stack of delayed operations, without evaluating anything or making any copies.
  Check out the [documentation](https://biocpy.github.io/DelayedArray/) for more information.





  A `DelayedArray` is typically used by iteratively extracting blocks into memory for further calculations.
  This "block processing" strategy improves memory efficiency by only realizing the delayed operations for a subset of the data.
  For example, to iterate over the rows with 100 MB blocks:

  ```python
  block_size = delayedarray.choose_block_size_for_1d_iteration(d, dimension=0, memory=1e8)
  block_coords = [ None, range(d.shape[1]) ]

  for start in range(0, d.shape[0], block_size):
      end = min(d.shape[0], start + block_size)
      block_coords[0] = range(start, end)
      current = delayedarray.extract_dense_array(d, (*block_coords,))
  ```

  Each call to `extract_dense_array()` yields a NumPy array containing the the specified rows and columns.
  If the `DelayedArray` might contain masked values, a NumPy `MaskedArray` is returned instead;
  this can be determined by checking whether `is_masked(d)` returns `True`.

  The above iteration can be simplified with the `apply_over_dimension()` function, which handles the block coordinate calculations for us.
  We could also use the `apply_over_blocks()` function to iterate over arbitrary block shapes, which may be more efficient if the best dimension for iteration is not known.

  ```python

  delayedarray.apply_over_dimension(
      d,
      dimension=0,
      fun=some_user_supplied_function,
      block_size=block_size,
  )


  delayedarray.apply_over_blocks(
      d,
      fun=another_user_supplied_function,
      block_shape=(20, 100),
  )
  ```



  If the `DelayedArray` contains sparse data, `is_sparse(d)` will return `True`.
  This allows callers to instead use the `extract_sparse_array()` function for block processing:

  ```python
  if delayedarray.is_sparse(d):
      current = delayedarray.extract_sparse_array(d, (*block_coords,))
  ```

  This returns a `SparseNdarray` consisting of a tree of sparse vectors for the specified block.
  Users can retrieve the sparse vectors by inspecting the `contents` property of the `SparseNdarray`:

  - In the one-dimensional case, this is a tuple of two 1-dimensional NumPy arrays storing data about the non-zero elements.
    The first array contains sorted indices while the secon array contains the associated values.
    If `is_masked(d)` returns `True`, the values will be represented as NumPy `MaskedArray` objects.
  - For the two-dimensional case, this is a list of such tuples, with one tuple per column.
    This is roughly analogous to a compressed sparse column matrix.
    An entry of the list may also be `None`, indicating that no non-zero elements are present in that column.
  - For higher-dimensionals, the tree is a nested list of lists of tuples.
    Each nesting level corresponds to a dimension; the outermost level contains elements of the last dimension,
    the next nesting level contains elements of the second-last dimension, and so on,
    with the indices in the tuple referring to the first dimension.
    Any list element may be `None` indicating that the corresponding element of the dimension has no non-zero elements.
  - In all cases, it is possible for `contents` to be `None`, indicating that there are no non-zero elements in the entire array.

  The `apply_over_*` functions can also be instructed to iteratively extract blocks as `SparseNdarray` objects.
  This only occurs if the input array is sparse (as specified by `is_sparse`).

  ```python

  delayedarray.apply_over_dimension(
      d,
      dimension=0,
      fun=some_user_supplied_function,
      block_size=block_size,
      allow_sparse=True,
  )
  ```



  A `DelayedArray` can be converted to a (possibly masked) NumPy array with the `to_dense_array()` function.
  Similarly, sparse `DelayedArray`s can be converted to `SparseNdarray`s with the `to_sparse_array()` function.

  ```python
  delayedarray.to_dense_array(d)
  delayedarray.to_sparse_array(d)
  ```

  Users can easily convert a 2-dimensional `SparseNdarray` to some of the common SciPy sparse matrix classes downstream calculations.

  ```python
  delayedarray.to_scipy_sparse_matrix(current, "csc")
  ```

  More simply, users can just call `numpy.array()` to realize the delayed operations into a standard NumPy array for consumption.
  Note that this discards any masking information so should not be called if `is_masked()` returns `True`.

  ```python
  simple = numpy.array(n)
  type(simple)

  ```

  Users can also call `delayedarray.create_dask_array()`, to obtain a **dask** array that contains the delayed operations:

  ```python

  dasky = delayedarray.create_dask_array(n)
  type(dasky)

  ```



  The general idea is that `DelayedArray`s should be a drop-in replacement for NumPy arrays, at least for [BiocPy](https://github.com/BiocPy) applications.
  So, for example, we can stuff the `DelayedArray` inside a `SummarizedExperiment`:

  ```python
  import summarizedexperiment as SE
  se = SE.SummarizedExperiment({ "counts": filtered, "lognorm": transformed })
  print(se)




  ```

  One of the main goals of the **DelayedArray** package is to make it easier for Bioconductor developers to inspect the delayed operations.
  (See the [developer notes](https://biocpy.github.io/DelayedArray/developers.html) for some comments on **dask**.)
  For example, we can pull out the "seed" object underlying our `DelayedArray` instance:

  ```python
  n.seed

  ```

  Each layer has its own specific attributes that define the operation, e.g.,

  ```python
  n.seed.subset

  ```

  Recursively drilling through the object will eventually reach the underlying array(s):

  ```python
  n.seed.seed.seed.seed.seed













  ```

  All attributes required to reconstruct a delayed operation are public and considered part of the stable `DelayedArray` interface.



  Any array-like object can be used as a "seed" in a `DelayedArray` provided it has the following:

  - `dtype` and `shape` properties, like those in NumPy arrays.
  - a method for the `extract_dense_array()` generic.
  - a method for the `is_masked()` generic.
  - a method for the `chunk_grid()` generic.

  If the object may contain sparse data, it should also implement:

  - a method for the `is_sparse()` generic.
  - a method for the `extract_sparse_generic()` generic.

  It may also be desirable to implement:

  - a method for the `create_dask_array()` generic.
  - a method for the `wrap()` generic.

  Developers are referred to the [documentation for each generic](https://biocpy.github.io/DelayedArray/api/delayedarray.html) for more details.


pkgId: b2a6a817a4722f65fad916553dd99316c1afd270c9986e7e0ac1329ecde6cb34
name: python-EasyMongoManager-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for EasyMongoManager
url: https://github.com/CREATIVE181/easy_mongodb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-EasyMongoManager-0.1-1.src.rpm
location_href: Packages/python-EasyMongoManager-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  `EasyMongoManager` — это простой интерфейс для взаимодействия с MongoDB с использованием Python.



  ```bash
  pip install EasyMongoManager



  from EasyMongoManager import MongoManager


  db = MongoManager('my_database')


  db.insert('my_collection', {'name': 'John', 'age': 30})


  docs = db.find('my_collection', {'name': 'John'})
  print(docs)


pkgId: cfb33482ec58fd72b870299e1df230ce442a99002fd47d873bc3eb42ae7b9597
name: python-EclipsingBinaries-help
arch: noarch
version: 4.1.4
epoch: 0
release: 1
summary: Development documents and examples for EclipsingBinaries
url: https://eclipsingbinaries.readthedocs.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-EclipsingBinaries-4.1.4-1.src.rpm
location_href: Packages/python-EclipsingBinaries-help-4.1.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Python OS 3.8, 3.9, 3.10](https://github.com/kjkoeller/Binary_Star_Research_Package/actions/workflows/ci_tests.yml/badge.svg)](https://github.com/kjkoeller/Binary_Star_Research_Package/actions/workflows/ci_tests.yml)
  [![Documentation Status](https://readthedocs.org/projects/eclipsingbinaries/badge/?version=latest)](https://eclipsingbinaries.readthedocs.io/en/latest/?badge=latest)
  [![PyPI version](https://badge.fury.io/py/EclipsingBinaries.svg)](https://badge.fury.io/py/EclipsingBinaries)
  [![GitHub release](https://img.shields.io/github/v/release/kjkoeller/Variable_Star_Research_Package)](https://github.com/kjkoeller/Variable_Star_Research_Package/releases/)
  ![GitHub](https://img.shields.io/github/license/kjkoeller/Variable_Star_Research_Package)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/9cd9a15e47ab4ed7b78071d096ea099d)](https://www.codacy.com/gh/kjkoeller/EclipsingBinaries/dashboard?utm_source=github.com\&utm_medium=referral\&utm_content=kjkoeller/EclipsingBinaries\&utm_campaign=Badge_Grade)
  [![astropy](http://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat)](http://www.astropy.org/)



  EclipsingBinaries is a Python project for faster analysis of eclipsing binary star systems. The package can currently reduce data, find comparison stars from the APASS catalog, calculate and plot O-C values, find the color index and effective temperature, O'Connell effect parameters, and download TESS data and calculate TESS magnitudes from Gaia data.

  ***



  You can find the documentation at this [site](https://eclipsingbinaries.readthedocs.io/en/latest/?badge=latest#) and any questions can be talked about in the discussions page or in an issue.

  ***



  The list of OS's and Python versions listed below have been tested to be able to build the package on.

  *  Macos- 3.8, 3.9, 3.10
  *  Ubuntu- 3.8, 3.9, 3.10
  *  Windows- 3.8, 3.9, 3.10

  ***



  To install type the following,

      pip install EclipsingBinaires

  Once installed, in the command line type the following:

      EclipsingBinaries

  This will run the `menu.py` file and will initiate all other programs for usage.
  Once installed using pip, you can just go to a command line and type `EclipsingBinaries` to start the program each time.

  To check the version you have,

      pip show EclipsingBinaries

  this will show numerous things, but you want to look at the version and make sure it is up to date.

  If your version is not the most recent version then in order to update type the following,

      pip install --upgrade EclipsingBinaries



  To use the pipeline functionality type the following:

      EB_pipeline -h

  This will print out all the options that are available to edit and change. The `-i` and the `-o` are required for the script to run. Otherwise, the script will crash.

  ***



  *   python >=3.7
  *   astropy>=5.1.1
  *   astroquery>=0.4.6
  *   ccdproc>=2.4.0
  *   matplotlib>=3.3.1
  *   numpy>=1.19.1
  *   pandas>=1.1.0
  *   PyAstronomy>=0.18.0
  *   scipy>=1.5.2
  *   statsmodels>=0.13.5
  *   tqdm>=4.64.1
  *   numba>=0.56.3
  *   seaborn>=0.12.2
  *   pyia>=1.41

  ***


pkgId: db0080b80e0113ef1d61c8ae0109520209d94fe9d50232ce3ac96dae676a9d7f
name: python-EliveltonAlgoritmosII-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for EliveltonAlgoritmosII
url: https://github.com/xxvelho/EliveltonAlgoritmosII
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-EliveltonAlgoritmosII-0.1-1.src.rpm
location_href: Packages/python-EliveltonAlgoritmosII-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  Este pacote fornece implementações de algoritmos clássicos para solucionar o problema do subarray máximo e para a multiplicação de matrizes, como descrito no livro "Introduction to Algorithms" por Cormen et al., especificamente no Capítulo 4.



  1. **Algoritmo de Força Bruta para o Subarray Máximo**
     - Explora todas as combinações possíveis de subarrays para encontrar aquele com a maior soma.

  2. **Algoritmo Recursivo para o Subarray Máximo**
     - Utiliza a técnica de dividir e conquistar para resolver o problema de forma mais eficiente do que a abordagem de força bruta.

  3. **Algoritmo de Strassen para Multiplicação de Matrizes**
     - Um método eficiente que reduz a complexidade computacional da multiplicação de matrizes grande usando uma abordagem de dividir e conquistar.

  4. **Algoritmos Alternativos para Multiplicação de Matrizes**
     - Inclui a multiplicação básica de matrizes e o método recursivo direto, precedendo a discussão do algoritmo de Strassen.



  Para instalar este pacote, execute o seguinte comando:

  ```bash
  pip install EliveltonAlgoritmosII


pkgId: f9984bc58aef10ca11be55ccf066bc65104c0d9a420668fba0dfc91cd6f7aada
name: python-ErrorFieldConcordance-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for ErrorFieldConcordance
url: https://pypi.org/project/ErrorFieldConcordance/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ErrorFieldConcordance-1.0.1-1.src.rpm
location_href: Packages/python-ErrorFieldConcordance-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Thie package provides calculation (and optionally graphing) of concordance (trending agreement) between two measures using an error field method.


  After importing the package, the method can be called as follows:

  ```
  Concordance = ErrorFieldConcordance(X,Y,IDS=[], plot_TF=False,graph_label='',X_name='ΔX',Y_name='ΔY',min_plot_range=3,decolor_threshold=2)
  ```

  Function Parameters:
  + The X and Y parameters are lists or arrays of equal size corresponding to paired measures to be compared. These should be the observations themselves (not the changes observed between observations).
  + IDS is a list of the same length as X & Y containing subject identifiers for individual subjects in the lists. If all of the observations are from the same subject this parameter can be empty.
  + plot_TF is a boolean that controls whether or not a figure is created.
  + graph_label is an optional string parameter to be placed in the graph title.
  + XMeasName and YMeasName are used to customize the X and Y graph labels if desired
  + MinPlotRange can be used to extend the plot range if desired. Normally the plot will include ± the largest absolute change observed, but if this range is too small the MinPlotRange parameter can be used to fix a minimum axis range.
  + decolor_threshold sets the radius for the desaturation circle at the center of the graph.  This is a graphical/appearance modifier only, it has no effect on the calculation of the Error Field Concordance value, but is useful to visually represent the central region where points are weighted the least in the final calculation.


  The observations passed in X & Y (and the corresponding subject identifiers in IDs) should be grouped by subject and ordered temporally. The function will then calculate the changes in successive observations within subjects.  If X, Y, and IDS are not grouped by subject and ordered by time results will be invalid.

  Time differences in the observations should be based on the aims of the project; the function itself is agnostic to the specifics. Ideally the time differences are all the same, otherwise interpretation of the graph and results may be biased.



  The returned value is a tuple of (error field concordance %, standard deviation %).

  The error field concordance value is a number in the range of \[-100,100\]:
  + Values > 60% indicate strong concordance.
  + Values between +20% and +60% indicate concordance.
  + Values between -20% and +20% indicate relative independence, or low overall change in the sample.
  + Values between -60% and -20% indicate discordance.
  + Values less than -60% indicate strong discordance.



  ![Example Error Field Concordance graph showing plotting of random data](https://www.wtfstatistics.com/assets/ExampleFigure1.png)

  The figure above shows an Error Field Concordance plot for two 1,000 sample arrays of noise (i.e. independent samples).  The data demonstrates the fields in the plot, with blue zones indicating concordance (the measures move in the same direction and magnitude), red zones indicating discordance (the measures move in opposite directions), and yellow zones indicating relative independence of movement.


  Please cite this package using the following:  *PubMed Reference & Citation TBD*


  Thanks go out to Bernd Saugel, Sean Coeckelenbergh, Ishita Srivastava, and Brandon Woo for their collective contributions to this project.


pkgId: 71737da52271288134a4fe716f4e46f97a60c308e8efb38cb5620e5aeb567bd1
name: python-Eve-Elastic-help
arch: noarch
version: 7.4.2
epoch: 0
release: 1
summary: Development documents and examples for Eve-Elastic
url: https://pypi.org/project/Eve-Elastic/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Eve-Elastic-7.4.2-1.src.rpm
location_href: Packages/python-Eve-Elastic-help-7.4.2-1.noarch.rpm
checksum_type: sha256
description:
  Eve-Elastic is `elastic <http://www.elasticsearch.org>`_ data layer for `eve REST framework <http://python-eve.org>`_.

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <http://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) {year}  {name of author}  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 <http://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:  {project}  Copyright (C) {year}  {fullname} 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 <http://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 <http://www.gnu.org/philosophy/why-not-lgpl.html>.


pkgId: ad93428bbee524d875809706990ac4e5cb0bc3cd630e39361fffc8d85e5f0c4f
name: python-EwanSonicConnector-help
arch: noarch
version: 0.1.17
epoch: 0
release: 1
summary: Development documents and examples for EwanSonicConnector
url: https://pypi.org/project/EwanSonicConnector/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-EwanSonicConnector-0.1.17-1.src.rpm
location_href: Packages/python-EwanSonicConnector-help-0.1.17-1.noarch.rpm
checksum_type: sha256
description:
  仅供ewan内部使用来连接云真机的一个小工具而已



  - 特性 1 提供连接入口查询在线机器
  - 特性 2 会自己启动和释放机器
  - 特性 3 还在开发其他功能中



  使用 pip 进行安装：

  ```bash
  pip install EwanSonicConnector


pkgId: 1647d3e870aacb60bee9e13f3ce6bc3725bef43ae672e844956c863222905302
name: python-FACILE-RS-help
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Development documents and examples for FACILE-RS
url: https://pypi.org/project/FACILE-RS/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FACILE-RS-3.1.0-1.src.rpm
location_href: Packages/python-FACILE-RS-help-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This package (previously known as openCARP-CI) contains a set of Python scripts which can be used to perform tasks around the archival and long term preservation of software repositories. In particular, it can be used to:

  * create a release in GitLab using the GitLab API,
  * create a DataCite record based on CodeMeta files present in repositories,
  * create a CFF (Citation File Format) file from CodeMeta files,
  * create archive packages in the [BagIt](https://tools.ietf.org/html/rfc8493) or [BagPack](https://www.rd-alliance.org/system/files/Research%20Data%20Repository%20Interoperability%20WG%20-%20Final%20Recommendations_reviewed_0.pdf) formats.
  * archive the software using the [RADAR service](https://www.radar-service.eu),
  * archive the software on [Zenodo](https://zenodo.org),
  * use content from markdown files, bibtex files, or python docstrings to create web pages in a [Grav CMS](https://getgrav.org/).

  The scripts were created for the [openCARP](https://opencarp.org) simulation software, but can be adopted for arbitrary projects. While they can be used on the command line, the scripts are mainly used within the GitLab CI/CD or GitHub Actions to run automatically on each push to a repository, or when a tag is created.

  An example of integration in a CI environment is provided in the [tutorials](https://facile-rs.readthedocs.io/en/latest/tutorials/). An example of a more complex setup are the [openCARP CI file](https://git.opencarp.org/openCARP/openCARP/-/blob/master/.gitlab-ci.yml) and the [included subscripts](https://git.opencarp.org/openCARP/openCARP/-/tree/master/.gitlab/ci).






  In order to generate metadata or publish software releases using FACILE-RS, it is necessary to create a CodeMeta metadata file for the software (for example using the [CodeMeta generator](https://codemeta.github.io/codemeta-generator/)).

  In addition, if you want to use our preconfigured automated pipelines, your software repository needs to be hosted on GitHub, or on a GitLab instance with [Docker runners](https://docs.gitlab.com/runner/) available.



  FACILE-RS can be installed using pip:
  ```
  pip install FACILE-RS
  ```

  In order to use FACILE-RS from the command-line, we recommend to install the package in a [virtual environment](https://docs.python.org/3/library/venv.html):

  ```bash
  python -m venv env
  source env/bin/activate
  pip install FACILE-RS
  ```



  You can integrate automated FACILE-RS workflows in your GitLab or GitHub repository using our templates.
  Each template provides a sample configuration for generating metadata and creating software releases with FACILE-RS.


  - [source](https://git.opencarp.org/openCARP/facile-rs-template)
  - [documentation](https://facile-rs.readthedocs.io/en/latest/templates/facile-rs_template_gitlab.html)


  - [source](https://github.com/openCARP-org/FACILE-RS-template)
  - [documentation](https://facile-rs.readthedocs.io/en/latest/templates/facile-rs_template_github.html)



  [![Documentation Status](https://readthedocs.org/projects/facile-rs/badge/?version=latest)](https://facile-rs.readthedocs.io/en/latest/?badge=latest)

  FACILE-RS documentation is available at [https://facile-rs.readthedocs.io/](https://facile-rs.readthedocs.io/).

  It can also be generated using Sphinx from [docs/sphinxdocs](https://git.opencarp.org/openCARP/FACILE-RS/-/tree/master/docs/sphinxdocs?ref_type=heads) by running:
  ```
  pip install -r requirements.txt
  make html
  ```
  The Python packages in [docs/sphinxdocs/requirements.txt](https://git.opencarp.org/openCARP/FACILE-RS/-/blob/master/docs/sphinxdocs/requirements.txt?ref_type=heads) as well as FACILE-RS itself must be installed in order to generate the documentation.



  The FACILE-RS tools are available via the command `facile-rs`.
  More details about its usage are available in the [documentation](https://facile-rs.readthedocs.io/en/latest/apidocs/facile_rs/facile_rs.facile_rs.html) or by running `facile-rs --help`.

  `facile-rs` expects a number of command line arguments. Default values can be set using environment variables (using upper case and underscores), i.e. the following lines do the same:

  ```bash
  facile-rs bag create --bag-path=/path/to/bag
  BAG_PATH=/path/to/bag facile-rs bag create
  ```

  Environments variables can be set in the usual way, e.g. the `.gitlab-ci.yml` file, but also in a `.env` file in the directory where the script is invoked.

  FACILE-RS comprises the following tools:



  Creates a [Citation File Format](https://citation-file-format.github.io) (CFF) file from a CodeMeta file.
  An example output can be found [here](https://git.opencarp.org/openCARP/openCARP/-/blob/master/CITATION.cff).

  Deprecated alias: `create_cff`



  Creates a DataCite XML file following the [DataCite Metadata Schema 4.3](https://schema.datacite.org/meta/kernel-4.3/). The information needed for this can be taken from (a list) of locations given as URL or local file path. `CODEMETA_LOCATION` must point to a [codemeta.json](https://codemeta.github.io) file. `CREATORS_LOCATIONS` and `CONTRIBUTORS_LOCATIONS` point to similar files which contain a list of `creators` or `contributors`, respectively.

  For an example, see [here](https://git.opencarp.org/openCARP/openCARP/blob/master/codemeta.json).

  Deprecated alias: `create_datacite`



  Creates a bag [BagIt](https://tools.ietf.org/html/rfc8493) using the [bagit-python](https://github.com/LibraryOfCongress/bagit-python) package. The assets to be included in the bag are given as positional arguments.

  Deprecated alias: `create_bag`



  Creates a bag [BagIt](https://tools.ietf.org/html/rfc8493) similar to `create_bag.py`, but also includes a DataCite XML file as recommended by the [RDA Research Data Repository Interoperability WG](https://www.rd-alliance.org/system/files/Research%20Data%20Repository%20Interoperability%20WG%20-%20Final%20Recommendations_reviewed_0.pdf).

  Deprecated alias: `create_bagpack`



  Updates the CodeMeta file for the given `VERSION` and `DATE` (as `dateModified`, current date if omitted). Useful to automatically get the version from a git tag and inject it into the repo's metadata file.

  Deprecated alias: `prepare_release`



  Creates a release in GitLab using the GitLab API. A tag for the release needs to be created before and provided to the script.
  An example output can be found [here](https://git.opencarp.org/openCARP/openCARP/-/releases).

  Deprecated alias: `create_release`



  Creates an empty archive in the [RADAR service](https://www.radar-service.eu) in order to "reserve" a DOI and an ID in RADAR. Both are stored in the CodeMeta file and can be used by the `create_radar` command below to include the DOI for this release in the deposited CodeMeta file. A detailed HowTo for releasing datasets on RADAR is provided in the file [`HOWTO_release_radar.md`](https://git.opencarp.org/openCARP/FACILE-RS/-/blob/master/HOWTO_release_radar.md) in this directory.

  Deprecated alias: `prepare_radar`



  Creates an archive in the [RADAR service](https://www.radar-service.eu) and uploads the assets provided as positional arguments. The metadata is created similar to `create_datacite`. If the RADAR ID is already in the CodeMeta file, the existing archive is updated instead. A detailed HowTo for releasing datasets on RADAR is provided in the file `HOWTO_release_radar.md` in this directory.

  Deprecated alias: `create_radar`



  Creates an empty archive on [Zenodo](https://zenodo.org) in order to "reserve" a DOI and an ID in Zenodo. Both are stored in the CodeMeta file and can be used by the `create_zenodo` command below to include the DOI for this release in the deposited CodeMeta file. A detailed HowTo for releasing datasets on Zenodo is provided in the tutorial [`04_release_zenodo.md`](./docs/tutorials/04_release_zenodo.md).

  Deprecated alias: `prepare_zenodo`



  Creates an archive on [Zenodo](https://zenodo.org) and uploads the assets provided as positional arguments. The metadata is created similar to `create_datacite`. If the Zenodo ID is already in the CodeMeta file, the existing archive is updated instead. A detailed HowTo for releasing datasets on Zenodo is provided in the tutorial [`04_release_zenodo.md`](./docs/tutorials/04_release_zenodo.md).

  Deprecated alias: `create_zenodo`



  Compiles and copies the content of bibtex files in a similar way to `run_markdown_pipeline`. A [CSL](https://citationstyles.org/) can be provided.

  Please refer to https://git.opencarp.org/openCARP/publications for an example setup.

  Deprecated alias: `run_bibtex_pipeline`



  Extracts and copies the content of [reStructuredText](https://docutils.sourceforge.io/) docstrings of Python scripts. Contrary to the other pipelines, this script does not copy one file to one page in GRAV, but creates a tree of pages below one page (given by the `pipeline` header). it processes all `run.py` and `__init__.py` files.

  The `PIPELINE` and `PIPELINE_SOURCE` options are used in the same way as in `rum_markdown_pipeline`. In addition, `PIPELINE_IMAGES` specifies a directory where the images from the docstrings are located and `PIPELINE_HEADER` and `PIPELINE_FOOTER` options point to templates which are prepended and appended to each page. With the `PIPELINE_REFS` YML file, you can specifie replacements for the references in the rst code.

  Please refer to https://git.opencarp.org/openCARP/experiments for an example setup.

  Deprecated alias: `run_docstring_pipeline`



  Copies the content of markdown files in the `PIPELINE_SOURCE` to a Grav CMS repository given by `GRAV_PATH`. The Grav repository is created by the [Git-Sync Plugin](https://getgrav.org/blog/git-sync-plugin).

  The pages need to be already existing in Grav and contain a `pipeline` and a `source` field in their frontmatter. The script will find all pages which match the provided `PIPELINE` and will overwrite content part of the page with the markdown file given by `source`. If source is `codemeta.json`, the content will be added to the frontmatter entry `codemeta` rather than overwriting the page content. Twig templates digesting the metadata can be found in the file `Twig_templates.md` in this directory.

  After running the script, the changes to the Grav CMS repository can be committed and pushed and the Git-Sync Plugin will update the public pages.

  See [openCARP citation info](https://opencarp.org/download/citation) or [code of conduct](https://opencarp.org/community/code-of-conduct) for examples.

  Deprecated alias: `run_markdown_pipeline`

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright [yyyy] [name of copyright owner]  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.


pkgId: d0620f80573edf22177eaf72e13ebcc68e57822ea249ae14bddc948f0305f007
name: python-FLAML-help
arch: noarch
version: 2.3.3
epoch: 0
release: 1
summary: Development documents and examples for FLAML
url: https://github.com/microsoft/FLAML
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FLAML-2.3.3-1.src.rpm
location_href: Packages/python-FLAML-help-2.3.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/FLAML.svg)](https://badge.fury.io/py/FLAML)
  ![Conda version](https://img.shields.io/conda/vn/conda-forge/flaml)
  [![Build](https://github.com/microsoft/FLAML/actions/workflows/python-package.yml/badge.svg)](https://github.com/microsoft/FLAML/actions/workflows/python-package.yml)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/FLAML)](https://pypi.org/project/FLAML/)
  [![Downloads](https://pepy.tech/badge/flaml)](https://pepy.tech/project/flaml)
  [![](https://img.shields.io/discord/1025786666260111483?logo=discord&style=flat)](https://discord.gg/Cppx2vSPVP)

  <!-- [![Join the chat at https://gitter.im/FLAMLer/community](https://badges.gitter.im/FLAMLer/community.svg)](https://gitter.im/FLAMLer/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) -->



  <p align="center">
      <img src="https://github.com/microsoft/FLAML/blob/main/website/static/img/flaml.svg"  width=200>
      <br>
  </p>

  :fire: FLAML supports AutoML and Hyperparameter Tuning in [Microsoft Fabric Data Science](https://learn.microsoft.com/en-us/fabric/data-science/automated-machine-learning-fabric). In addition, we've introduced Python 3.11 support, along with a range of new estimators, and comprehensive integration with MLflow—thanks to contributions from the Microsoft Fabric product team.

  :fire: Heads-up: We have migrated [AutoGen](https://microsoft.github.io/autogen/) into a dedicated [github repository](https://github.com/microsoft/autogen). Alongside this move, we have also launched a dedicated [Discord](https://discord.gg/pAbnFJrkgZ) server and a [website](https://microsoft.github.io/autogen/) for comprehensive documentation.

  :fire: The automated multi-agent chat framework in [AutoGen](https://microsoft.github.io/autogen/) is in preview from v2.0.0.

  :fire: FLAML is highlighted in OpenAI's [cookbook](https://github.com/openai/openai-cookbook#related-resources-from-around-the-web).

  :fire: [autogen](https://microsoft.github.io/autogen/) is released with support for ChatGPT and GPT-4, based on [Cost-Effective Hyperparameter Optimization for Large Language Model Generation Inference](https://arxiv.org/abs/2303.04673).



  FLAML is a lightweight Python library for efficient automation of machine
  learning and AI operations. It automates workflow based on large language models, machine learning models, etc.
  and optimizes their performance.

  - FLAML enables building next-gen GPT-X applications based on multi-agent conversations with minimal effort. It simplifies the orchestration, automation and optimization of a complex GPT-X workflow. It maximizes the performance of GPT-X models and augments their weakness.
  - For common machine learning tasks like classification and regression, it quickly finds quality models for user-provided data with low computational resources. It is easy to customize or extend. Users can find their desired customizability from a smooth range.
  - It supports fast and economical automatic tuning (e.g., inference hyperparameters for foundation models, configurations in MLOps/LMOps workflows, pipelines, mathematical/statistical models, algorithms, computing experiments, software configurations), capable of handling large search space with heterogeneous evaluation cost and complex constraints/guidance/early stopping.

  FLAML is powered by a series of [research studies](https://microsoft.github.io/FLAML/docs/Research/) from Microsoft Research and collaborators such as Penn State University, Stevens Institute of Technology, University of Washington, and University of Waterloo.

  FLAML has a .NET implementation in [ML.NET](http://dot.net/ml), an open-source, cross-platform machine learning framework for .NET.



  FLAML requires **Python version >= 3.8**. It can be installed from pip:

  ```bash
  pip install flaml
  ```

  Minimal dependencies are installed without extra options. You can install extra options based on the feature you need. For example, use the following to install the dependencies needed by the [`autogen`](https://microsoft.github.io/autogen/) package.

  ```bash
  pip install "flaml[autogen]"
  ```

  Find more options in [Installation](https://microsoft.github.io/FLAML/docs/Installation).
  Each of the [`notebook examples`](https://github.com/microsoft/FLAML/tree/main/notebook) may require a specific option to be installed.



  - (New) The [autogen](https://microsoft.github.io/autogen/) package enables the next-gen GPT-X applications with a generic multi-agent conversation framework.
    It offers customizable and conversable agents which integrate LLMs, tools and human.
    By automating chat among multiple capable agents, one can easily make them collectively perform tasks autonomously or with human feedback, including tasks that require using tools via code. For example,

  ```python
  from flaml import autogen

  assistant = autogen.AssistantAgent("assistant")
  user_proxy = autogen.UserProxyAgent("user_proxy")
  user_proxy.initiate_chat(
      assistant,
      message="Show me the YTD gain of 10 largest technology companies as of today.",
  )

  ```

  Autogen also helps maximize the utility out of the expensive LLMs such as ChatGPT and GPT-4. It offers a drop-in replacement of `openai.Completion` or `openai.ChatCompletion` with powerful functionalites like tuning, caching, templating, filtering. For example, you can optimize generations by LLM with your own tuning data, success metrics and budgets.

  ```python

  config, analysis = autogen.Completion.tune(
      data=tune_data,
      metric="success",
      mode="max",
      eval_func=eval_func,
      inference_budget=0.05,
      optimization_budget=3,
      num_samples=-1,
  )

  response = autogen.Completion.create(context=test_instance, **config)
  ```

  - With three lines of code, you can start using this economical and fast
    AutoML engine as a [scikit-learn style estimator](https://microsoft.github.io/FLAML/docs/Use-Cases/Task-Oriented-AutoML).

  ```python
  from flaml import AutoML

  automl = AutoML()
  automl.fit(X_train, y_train, task="classification")
  ```

  - You can restrict the learners and use FLAML as a fast hyperparameter tuning
    tool for XGBoost, LightGBM, Random Forest etc. or a [customized learner](https://microsoft.github.io/FLAML/docs/Use-Cases/Task-Oriented-AutoML#estimator-and-search-space).

  ```python
  automl.fit(X_train, y_train, task="classification", estimator_list=["lgbm"])
  ```

  - You can also run generic hyperparameter tuning for a [custom function](https://microsoft.github.io/FLAML/docs/Use-Cases/Tune-User-Defined-Function).

  ```python
  from flaml import tune
  tune.run(evaluation_function, config={…}, low_cost_partial_config={…}, time_budget_s=3600)
  ```

  - [Zero-shot AutoML](https://microsoft.github.io/FLAML/docs/Use-Cases/Zero-Shot-AutoML) allows using the existing training API from lightgbm, xgboost etc. while getting the benefit of AutoML in choosing high-performance hyperparameter configurations per task.

  ```python
  from flaml.default import LGBMRegressor


  estimator = LGBMRegressor()

  estimator.fit(X_train, y_train)
  ```



  You can find a detailed documentation about FLAML [here](https://microsoft.github.io/FLAML/).

  In addition, you can find:

  - [Research](https://microsoft.github.io/FLAML/docs/Research) and [blogposts](https://microsoft.github.io/FLAML/blog) around FLAML.

  - [Discord](https://discord.gg/Cppx2vSPVP).

  - [Contributing guide](https://microsoft.github.io/FLAML/docs/Contribute).

  - ML.NET documentation and tutorials for [Model Builder](https://learn.microsoft.com/dotnet/machine-learning/tutorials/predict-prices-with-model-builder), [ML.NET CLI](https://learn.microsoft.com/dotnet/machine-learning/tutorials/sentiment-analysis-cli), and [AutoML API](https://learn.microsoft.com/dotnet/machine-learning/how-to-guides/how-to-use-the-automl-api).



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

  If you are new to GitHub [here](https://help.github.com/categories/collaborating-with-issues-and-pull-requests/) is a detailed help source on getting involved with development on GitHub.

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

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



  <a href="https://github.com/microsoft/flaml/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=microsoft/flaml&max=204" />
  </a>


pkgId: 5b7d43f1fb2fa7f4d9653a683325c6eb008715100554cd95d8ea647e2e42eb7b
name: python-FSRS-Optimizer-help
arch: noarch
version: 5.5.0
epoch: 0
release: 1
summary: Development documents and examples for FSRS-Optimizer
url: https://github.com/open-spaced-repetition/fsrs-optimizer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FSRS-Optimizer-5.5.0-1.src.rpm
location_href: Packages/python-FSRS-Optimizer-help-5.5.0-1.noarch.rpm
checksum_type: sha256
description:
  Are you getting tired of installing torch? Try [fsrs-rs-python](https://github.com/open-spaced-repetition/fsrs-rs-python)!


pkgId: fa2a49b927902b180e4b5ada282566c71bc1ddfad784b35a5f270b215d9cd199
name: python-FairFRU-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for FairFRU
url: https://pypi.org/project/FairFRU/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FairFRU-0.3.3-1.src.rpm
location_href: Packages/python-FairFRU-help-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  This python package contains a bias metric based on the paper *"A fuzzy-rough uncertainty measure to discover bias encoded explicitly or implicitly in features of structured pattern classification datasets"* ([Link to publication](https://doi.org/10.1016/j.patrec.2022.01.005)).

  This bias metric measures the extent to which a feature in a dataset influences the outcome variable.


pkgId: ccbe4b6cef87db021c5bff8051c278534446820011f2ffb19fba3b952f8f96ca
name: python-FastSQLModel-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for FastSQLModel
url: https://github.com/ndendic/FastSQLModel
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FastSQLModel-0.1.0-1.src.rpm
location_href: Packages/python-FastSQLModel-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->



  FastSQLModel is a utility for simplifying the process of using
  SQLModel/SQLAlchemy and Alembic. It provides a CLI for initializing and
  managing Alembic migrations, and a set of tools for working with
  SQLModel and SQLAlchemy models.



  - **CLI for Alembic**: FastSQLModel provides a CLI for initializing and
    managing Alembic migrations.
  - **SQLModel and SQLAlchemy Models**: FastSQLModel provides a set of
    tools for working with SQLModel and SQLAlchemy models.
  - **Database Management**: FastSQLModel provides a set of tools for
    managing the database, including creating, dropping, and querying the
    database.





  If you want to make changes to the package, you can install it in
  development mode. This project uses nbdev for development, so you can
  make changes to the code and documentation in the notebooks under the
  nbs/ directory. To find out more about amazing nbdev, visit the [nbdev
  documentation](https://nbdev.fast.ai/index.html).

  To make changes to the package, you can install it in development mode.

  ``` sh

  $ pip install -e .





  $ nbdev_prepare
  ```





  Install latest from the GitHub
  [repository](https://github.com/ndendic/FastSQLModel):

  ``` sh
  $ pip install git+https://github.com/ndendic/FastSQLModel.git
  ```

  or from [conda](https://anaconda.org/ndendic/FastSQLModel)

  ``` sh
  $ conda install -c ndendic FastSQLModel
  ```

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

  ``` sh
  $ pip install FastSQLModel
  ```

  To establish a connection to the database, please specify the
  `DATABASE_URL` in the `.env` file.



  Documentation can be found hosted on this GitHub
  [repository](https://github.com/ndendic/FastSQLModel)’s
  [pages](https://ndendic.github.io/FastSQLModel/). Additionally you can
  find package manager specific guidelines on
  [conda](https://anaconda.org/ndendic/FastSQLModel) and
  [pypi](https://pypi.org/project/FastSQLModel/) respectively.





  To create your first model, you can can import the BaseTable class from
  the FastSQLModel.db module and create a new model by subclassing it.
  BaseTable is a subclass of SQLModel, so it has all the same features,
  but it also has a few extra features to help with some standard db
  operations and 3 extra fields: - id: primary key, default to a uuid4 -
  created_at: datetime, default to now - updated_at: datetime, default to
  now, and updated on every save

  ``` python
  class BaseTable(SQLModel):
      model_config = ConfigDict(json_encoders={datetime: lambda dt: dt.isoformat()})
      id: UUID = Field(default_factory=uuid4, primary_key=True)
      created_at: datetime = Field(
          default_factory=utc_now,
          sa_type= sa.DateTime(timezone=True),
          sa_column_kwargs={"server_default": sa.func.now()},
          nullable=False,
          title="Created At",
          schema_extra={"icon": "clock", "input_type": "datetime"},
      )
      updated_at: datetime = Field(
          default_factory=utc_now,
          sa_type=sa.DateTime(timezone=True),
          sa_column_kwargs={
              "server_default": sa.func.now(),
              "server_onupdate": sa.func.now(),
          },
          
          nullable=False,
          title="Updated At",
          schema_extra={"icon": "clock", "input_type": "datetime"},
      )
  ```

  Here is an example of how to create a new model using BaseTable

  ``` python

  from typing import Optional
  from sqlmodel import Field
  from datetime import datetime
  from FastSQLModel.db import BaseTable

  class User(BaseTable, table=True):
      name: Optional[str] = Field(nullable=True)
      email: str = Field(nullable=False)
      password: str = Field(nullable=False)
      joined_at: datetime = Field(nullable=False)
  ```

  Now that you have created your first model, you can use the CLI to
  initialize and manage Alembic project.

  ``` sh
  $ fastmodel init
  ```

  This will create a new Alembic project in the current directory, and
  create a new .alembic.ini file.

  2.  Then make sure to add your models to the migrations/env.py file
      before running migrations.

  ``` python

  from users import User

  ```

  3.  Now you can run migrations to prepare the database for your models.

  ``` sh
  $ fastmodel migrations
  ```

  4.  And now you can migrate your models to the database.

  ``` sh
  $ fastmodel migrate
  ```

  Let’s see how this works

  Initialization:

  ``` python
  !fastmodel init
  ```

      Successfully initialized Alembic in migrations directory!
      Please make sure to add your models to migrations/env.py file before running
      migrations!

  Making migrations

  ``` python
  !fastmodel migrations
  ```

      Generating Alembic migration with message: Pushing changes
      DATABASE_URL sqlite:///test.db
      INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
      INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
      ERROR [alembic.util.messaging] Can't locate revision identified by '5289002d24df'
        FAILED: Can't locate revision identified by '5289002d24df'
      Error running Alembic: Command '['alembic', 'revision', '--autogenerate', '-m',
      'Pushing changes']' returned non-zero exit status 255.

  Migrating changes

  ``` python
  !fastmodel migrate
  ```

      Applying database migrations...
      DATABASE_URL sqlite:///test.db
      INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
      INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
      ERROR [alembic.util.messaging] Can't locate revision identified by '5289002d24df'
        FAILED: Can't locate revision identified by '5289002d24df'
      Error applying migrations: Command '['alembic', 'upgrade', 'head']' returned
      non-zero exit status 255.

  Once our table is migrated, we can start adding some data like this.

  ``` python
  user = User(name="Homer Simpson", email="homer@simpson.com", password="password", joined_at=datetime.now())
  user.save()
  user.model_dump()
  ```

      {'name': 'Homer Simpson',
       'email': 'homer@simpson.com',
       'password': 'password',
       'joined_at': datetime.datetime(2024, 12, 19, 13, 37, 22, 340771),
       'id': UUID('8ae7ed20-8579-47ee-830f-121a0dac4762'),
       'created_at': datetime.datetime(2024, 12, 19, 12, 37, 22, 343167, tzinfo=datetime.timezone.utc),
       'updated_at': datetime.datetime(2024, 12, 19, 12, 37, 22, 343208, tzinfo=datetime.timezone.utc)}

  Let’s get our user by id

  ``` python
  homer = User.get(user.id)
  if homer:
      print(f"Name: {homer.name}, Email: {homer.email}")
  else:
      print("User not found")
  ```

      Name: Homer Simpson, Email: homer@simpson.com

  Or by alternative key value

  ``` python
  homer = User.get("homer@simpson.com",alt_key="email")
  if homer:
      print(f"Name: {homer.name}, Email: {homer.email}")
  else:
      print("User not found")
  ```

      Name: Homer Simpson, Email: homer@simpson.com

  Now let’s modify our record and save it back to our database and
  retreive back

  ``` python
  homer.email = "homer.simpson@simpson.com"
  homer.save()
  homer = User.get("homer.simpson@simpson.com",alt_key="email")
  homer.email
  ```

      'homer.simpson@simpson.com'

  Let’s define a bit more Simprons, this time like this

  ``` python
  bart = User()
  bart.name = "Bart Simpson"
  bart.email = "bart@simpson.com"
  bart.password = "password"
  bart.joined_at = datetime.now()
  bart.save()

  bart.name, bart.email
  ```

      ('Bart Simpson', 'bart@simpson.com')

  Let’s retrive records in our table. We can simply do that by calling
  `all` function

  ``` python
  User.all()
  ```

      [User(created_at=datetime.datetime(2024, 12, 18, 13, 46, 56, 424225), updated_at=datetime.datetime(2024, 12, 18, 13, 46, 56, 424237), id=UUID('420cc98d-9932-459d-b0e6-4a2f78ae8446'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 18, 14, 46, 56, 412409)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 34, 34, 910466), updated_at=datetime.datetime(2024, 12, 19, 12, 34, 34, 910474), id=UUID('a1537834-22b9-4c1b-94a0-4d68f82ae3ed'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 34, 34, 909023)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 35, 10, 261956), updated_at=datetime.datetime(2024, 12, 19, 12, 35, 10, 261966), id=UUID('8699c000-4bc7-47a8-b68a-982aaad8e380'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 35, 10, 260092)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 35, 42, 792670), updated_at=datetime.datetime(2024, 12, 19, 12, 35, 42, 792700), id=UUID('3f686d36-65d5-48fa-b4ef-efa20c552d99'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 35, 42, 790064)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 36, 2, 538502), updated_at=datetime.datetime(2024, 12, 19, 12, 36, 2, 538548), id=UUID('a4ac7f2e-8f9e-4882-b0fd-796419f9862a'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 36, 2, 535652)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 346125), updated_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 417729), id=UUID('8ae7ed20-8579-47ee-830f-121a0dac4762'), name='Homer Simpson', password='password', email='homer.simpson@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 37, 22, 340771)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 453142), updated_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 453152), id=UUID('2f30794b-12bf-4c15-acb8-f673c329db40'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 37, 22, 450919))]

  Here we can see that we have forgot to set some `unique` values to our
  fields and prevent duplicates. So let’s remove our duplicates manualy
  now

  First, we can use search to get all the records that contain some
  character in some of their string fields. This is usefull for filtering
  records where you’re not sure where the value shuld match.

  ``` python
  users = User.search(search_value="Homer")
  for user in users:
      print(f"Name: {user.name} , Email: {user.email}, ID: {user.id}")
  ```

      Name: Homer Simpson , Email: homer.simpson@simpson.com, ID: 8ae7ed20-8579-47ee-830f-121a0dac4762

  You can also set the fields you want to retreive from specific fields
  using `fields` argument. This will now not return the instance of the
  User rable but a list of tuples.

  ``` python
  users = User.search(search_value="Simpson", fields=['name','email'])
  users
  ```

      [('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Homer Simpson', 'homer.simpson@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com')]

  Now let’s retreive our records again

  ``` python
  users = User.search(search_value="bart")
  users
  ```

      [User(created_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 453142), updated_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 453152), id=UUID('2f30794b-12bf-4c15-acb8-f673c329db40'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 37, 22, 450919)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 35, 42, 792670), updated_at=datetime.datetime(2024, 12, 19, 12, 35, 42, 792700), id=UUID('3f686d36-65d5-48fa-b4ef-efa20c552d99'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 35, 42, 790064)),
       User(created_at=datetime.datetime(2024, 12, 18, 13, 46, 56, 424225), updated_at=datetime.datetime(2024, 12, 18, 13, 46, 56, 424237), id=UUID('420cc98d-9932-459d-b0e6-4a2f78ae8446'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 18, 14, 46, 56, 412409)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 35, 10, 261956), updated_at=datetime.datetime(2024, 12, 19, 12, 35, 10, 261966), id=UUID('8699c000-4bc7-47a8-b68a-982aaad8e380'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 35, 10, 260092)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 34, 34, 910466), updated_at=datetime.datetime(2024, 12, 19, 12, 34, 34, 910474), id=UUID('a1537834-22b9-4c1b-94a0-4d68f82ae3ed'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 34, 34, 909023)),
       User(created_at=datetime.datetime(2024, 12, 19, 12, 36, 2, 538502), updated_at=datetime.datetime(2024, 12, 19, 12, 36, 2, 538548), id=UUID('a4ac7f2e-8f9e-4882-b0fd-796419f9862a'), name='Bart Simpson', password='password', email='bart@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 36, 2, 535652))]

  ..and remove the first two results using the `delete` function

  ``` python
  for user in users[:len(users)-1]:
      user.delete()

  for user in User.all():
      print(user.name)
  ```

      Bart Simpson
      Homer Simpson

  we also have the option to filter the records using `filter` function
  for a specific model field.

  ``` python
  results = User.filter(name="Homer Simpson")
  results
  ```

      [User(created_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 346125), updated_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 417729), id=UUID('8ae7ed20-8579-47ee-830f-121a0dac4762'), name='Homer Simpson', password='password', email='homer.simpson@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 37, 22, 340771))]

  ``` python
  results = User.filter(email="homer.simpson@simpson.com")
  results
  ```

      [User(created_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 346125), updated_at=datetime.datetime(2024, 12, 19, 12, 37, 22, 417729), id=UUID('8ae7ed20-8579-47ee-830f-121a0dac4762'), name='Homer Simpson', password='password', email='homer.simpson@simpson.com', joined_at=datetime.datetime(2024, 12, 19, 13, 37, 22, 340771))]

  Similar to `search`, `filter` can take the same argumants, like
  `fields`, `sorting_field` and other (for full list navigate to the db
  section).

  ``` python
  results = User.filter(name="simp",exact_match=False,fields=["name","email"])
  results
  ```

      [('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Homer Simpson', 'homer.simpson@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com')]

  We can also combine field filters.

  ``` python
  results = User.filter(name="simp",email="hom",exact_match=False,fields=["name","email"])
  results
  ```

      [('Homer Simpson', 'homer.simpson@simpson.com')]

  For more deatails visit related docs for
  [SQLModel](https://sqlmodel.tiangolo.com/) and
  [Alembic](https://alembic.sqlalchemy.org/en/latest/)


pkgId: b1641122832e46d92d5407c3552ad11cce4e20c629ad751bf9276d0e55473f24
name: python-FastSQLModel-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for FastSQLModel
url: https://github.com/ndendic/FastSQLModel
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FastSQLModel-0.1.2-1.src.rpm
location_href: Packages/python-FastSQLModel-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  <!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->



  FastSQLModel is a utility for simplifying the process of using
  SQLModel/SQLAlchemy and Alembic. It provides a CLI for initializing and
  managing Alembic migrations, and a set of tools for working with
  SQLModel and SQLAlchemy models.



  - **CLI for Alembic**: FastSQLModel provides a CLI for initializing and
    managing Alembic migrations.
  - **SQLModel and SQLAlchemy Models**: FastSQLModel provides a set of
    tools for working with SQLModel and SQLAlchemy models.
  - **Database Management**: FastSQLModel provides a set of tools for
    managing the database, including creating, dropping, and querying the
    database.





  If you want to make changes to the package, you can install it in
  development mode. This project uses nbdev for development, so you can
  make changes to the code and documentation in the notebooks under the
  nbs/ directory. To find out more about amazing nbdev, visit the [nbdev
  documentation](https://nbdev.fast.ai/index.html).

  To make changes to the package, you can install it in development mode.

  ``` sh

  $ pip install -e .





  $ nbdev_prepare
  ```





  Install latest from the GitHub
  [repository](https://github.com/ndendic/FastSQLModel):

  ``` sh
  $ pip install git+https://github.com/ndendic/FastSQLModel.git
  ```

  or from [conda](https://anaconda.org/ndendic/FastSQLModel)

  ``` sh
  $ conda install -c ndendic FastSQLModel
  ```

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

  ``` sh
  $ pip install FastSQLModel
  ```

  To establish a connection to the database, please specify the
  `DATABASE_URL` in the `.env` file.



  Documentation can be found hosted on this GitHub
  [repository](https://github.com/ndendic/FastSQLModel)’s
  [pages](https://ndendic.github.io/FastSQLModel/). Additionally you can
  find package manager specific guidelines on
  [conda](https://anaconda.org/ndendic/FastSQLModel) and
  [pypi](https://pypi.org/project/FastSQLModel/) respectively.





  To create your first model, you can can import the BaseTable class from
  the FastSQLModel.db module and create a new model by subclassing it.
  BaseTable is a subclass of SQLModel, so it has all the same features,
  but it also has a few extra features to help with some standard db
  operations and 3 extra fields: - id: primary key, default to a uuid4 -
  created_at: datetime, default to now - updated_at: datetime, default to
  now, and updated on every save

  ``` python
  class BaseTable(SQLModel):
      model_config = ConfigDict(json_encoders={datetime: lambda dt: dt.isoformat()})
      id: UUID = Field(default_factory=uuid4, primary_key=True)
      created_at: datetime = Field(
          default_factory=utc_now,
          sa_type= sa.DateTime(timezone=True),
          sa_column_kwargs={"server_default": sa.func.now()},
          nullable=False,
          title="Created At",
          schema_extra={"icon": "clock", "input_type": "datetime"},
      )
      updated_at: datetime = Field(
          default_factory=utc_now,
          sa_type=sa.DateTime(timezone=True),
          sa_column_kwargs={
              "server_default": sa.func.now(),
              "server_onupdate": sa.func.now(),
          },
          
          nullable=False,
          title="Updated At",
          schema_extra={"icon": "clock", "input_type": "datetime"},
      )
  ```

  Here is an example of how to create a new model using BaseTable

  ``` python

  from typing import Optional
  from sqlmodel import Field
  from datetime import datetime
  from FastSQLModel.db import BaseTable

  class User(BaseTable, table=True):
      name: Optional[str] = Field(nullable=True)
      email: str = Field(nullable=False)
      password: str = Field(nullable=False)
      joined_at: datetime = Field(nullable=False)
  ```

  Now that you have created your first model, you can use the CLI to
  initialize and manage Alembic project.

  ``` sh
  $ fastmodel init
  ```

  This will create a new Alembic project in the current directory, and
  create a new .alembic.ini file.

  2.  Then make sure to add your models to the migrations/env.py file
      before running migrations.

  ``` python

  from users import User

  ```

  3.  Now you can run migrations to prepare the database for your models.

  ``` sh
  $ fastmodel migrations
  ```

  4.  And now you can migrate your models to the database.

  ``` sh
  $ fastmodel migrate
  ```

  Let’s see how this works

  Initialization:

  ``` python

  ```

  Making migrations

  ``` python
  !fastmodel migrations
  ```

      Generating Alembic migration with message: Pushing changes
      DATABASE_URL sqlite:///test.db
      INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
      INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
        Generating /home/ndendic/WebDev/FastSQLModel/nbs/migrations/versions/4d4567890
        1bc_pushing_changes.py ...  done
      Migration created successfully!

  Migrating changes

  ``` python
  !fastmodel migrate
  ```

      Applying database migrations...
      DATABASE_URL sqlite:///test.db
      INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
      INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
      INFO  [alembic.runtime.migration] Running upgrade 5441880ad0e3 -> 4d45678901bc, Pushing changes
      Migrations applied successfully!

  Once our table is migrated, we can start adding some data like this.

  ``` python
  user = User(name="Homer Simpson", email="homer@simpson.com", password="password", joined_at=datetime.now())
  user.save()
  user.model_dump()
  ```

      {'name': 'Homer Simpson',
       'email': 'homer@simpson.com',
       'password': 'password',
       'joined_at': datetime.datetime(2024, 12, 19, 16, 2, 4, 408489),
       'id': UUID('f4ff6c91-8fcf-44a8-9874-cf2535a8d10c'),
       'created_at': datetime.datetime(2024, 12, 19, 15, 2, 4, 413702, tzinfo=datetime.timezone.utc),
       'updated_at': datetime.datetime(2024, 12, 19, 15, 2, 4, 413744, tzinfo=datetime.timezone.utc)}

  Let’s get our user by id

  ``` python
  homer = User.get(user.id)
  if homer:
      print(f"Name: {homer.name}, Email: {homer.email}")
  else:
      print("User not found")
  ```

      Name: Homer Simpson, Email: homer@simpson.com

  Or by alternative key value

  ``` python
  homer = User.get("homer@simpson.com",alt_key="email")
  if homer:
      print(f"Name: {homer.name}, Email: {homer.email}")
  else:
      print("User not found")
  ```

      Name: Homer Simpson, Email: homer@simpson.com

  Now let’s modify our record and save it back to our database and
  retreive back

  ``` python
  homer.email = "homer.simpson@simpson.com"
  homer.save()
  homer = User.get("homer.simpson@simpson.com",alt_key="email")
  homer.email
  ```

      'homer.simpson@simpson.com'

  Let’s define a bit more Simprons, this time like this

  ``` python
  bart = User()
  bart.name = "Bart Simpson"
  bart.email = "bart@simpson.com"
  bart.password = "password"
  bart.joined_at = datetime.now()
  bart.save()

  bart.name, bart.email
  ```

      ('Bart Simpson', 'bart@simpson.com')

  Let’s retrive records in our table. We can simply do that by calling
  `all` function

  ``` python
  User.all()
  ```

      [User(email='homer.simpson@simpson.com', name='Homer Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 1, 27, 746940), id=UUID('e1d719e2-21a4-40c1-ab9b-062e0808f101'), updated_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 870936), created_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 783496), password='password'),
       User(email='bart@simpson.com', name='Bart Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 1, 27, 909419), id=UUID('7aa9cd07-59c4-4f34-8bdd-df9b05453efb'), updated_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 914354), created_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 914332), password='password'),
       User(email='homer.simpson@simpson.com', name='Homer Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 2, 4, 408489), id=UUID('f4ff6c91-8fcf-44a8-9874-cf2535a8d10c'), updated_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 552857), created_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 434347), password='password'),
       User(email='bart@simpson.com', name='Bart Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 2, 4, 602805), id=UUID('455cbf7d-b8f6-407a-8ae6-f80f814d9735'), updated_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 606104), created_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 606086), password='password')]

  Here we can see that we have forgot to set some `unique` values to our
  fields and prevent duplicates. So let’s remove our duplicates manualy
  now

  First, we can use search to get all the records that contain some
  character in some of their string fields. This is usefull for filtering
  records where you’re not sure where the value shuld match.

  ``` python
  users = User.search(search_value="Homer")
  for user in users:
      print(f"Name: {user.name} , Email: {user.email}, ID: {user.id}")
  ```

      Name: Homer Simpson , Email: homer.simpson@simpson.com, ID: e1d719e2-21a4-40c1-ab9b-062e0808f101
      Name: Homer Simpson , Email: homer.simpson@simpson.com, ID: f4ff6c91-8fcf-44a8-9874-cf2535a8d10c

  You can also set the fields you want to retreive from specific fields
  using `fields` argument. This will now not return the instance of the
  User rable but a list of tuples.

  ``` python
  users = User.search(search_value="Simpson", fields=['name','email'])
  users
  ```

      [('Bart Simpson', 'bart@simpson.com'),
       ('Bart Simpson', 'bart@simpson.com'),
       ('Homer Simpson', 'homer.simpson@simpson.com'),
       ('Homer Simpson', 'homer.simpson@simpson.com')]

  Now let’s retreive our records again

  ``` python
  users = User.search(search_value="bart")
  users
  ```

      [User(email='bart@simpson.com', name='Bart Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 2, 4, 602805), id=UUID('455cbf7d-b8f6-407a-8ae6-f80f814d9735'), updated_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 606104), created_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 606086), password='password'),
       User(email='bart@simpson.com', name='Bart Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 1, 27, 909419), id=UUID('7aa9cd07-59c4-4f34-8bdd-df9b05453efb'), updated_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 914354), created_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 914332), password='password')]

  ..and remove the first two results using the `delete` function

  ``` python
  for user in users[:len(users)-1]:
      user.delete()

  for user in User.all():
      print(user.name)
  ```

      Homer Simpson
      Bart Simpson
      Homer Simpson

  we also have the option to filter the records using `filter` function
  for a specific model field.

  ``` python
  results = User.filter(name="Homer Simpson")
  results
  ```

      [User(email='homer.simpson@simpson.com', name='Homer Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 1, 27, 746940), id=UUID('e1d719e2-21a4-40c1-ab9b-062e0808f101'), updated_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 870936), created_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 783496), password='password'),
       User(email='homer.simpson@simpson.com', name='Homer Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 2, 4, 408489), id=UUID('f4ff6c91-8fcf-44a8-9874-cf2535a8d10c'), updated_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 552857), created_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 434347), password='password')]

  ``` python
  results = User.filter(email="homer.simpson@simpson.com")
  results
  ```

      [User(email='homer.simpson@simpson.com', name='Homer Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 1, 27, 746940), id=UUID('e1d719e2-21a4-40c1-ab9b-062e0808f101'), updated_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 870936), created_at=datetime.datetime(2024, 12, 19, 15, 1, 27, 783496), password='password'),
       User(email='homer.simpson@simpson.com', name='Homer Simpson', joined_at=datetime.datetime(2024, 12, 19, 16, 2, 4, 408489), id=UUID('f4ff6c91-8fcf-44a8-9874-cf2535a8d10c'), updated_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 552857), created_at=datetime.datetime(2024, 12, 19, 15, 2, 4, 434347), password='password')]

  Similar to `search`, `filter` can take the same argumants, like
  `fields`, `sorting_field` and other (for full list navigate to the db
  section).

  ``` python
  results = User.filter(name="Simp",exact_match=False,fields=["name","email"])
  results
  ```

      []

  We can also combine field filters.

  ``` python
  results = User.filter(name="simp",email="hom",exact_match=False,fields=["name","email"])
  results
  ```

      []

  For more deatails visit related docs for
  [SQLModel](https://sqlmodel.tiangolo.com/) and
  [Alembic](https://alembic.sqlalchemy.org/en/latest/)


pkgId: 0a885596caa01e64959f36fb6005fb399245159a279f85ffc073834125ec44d4
name: python-FediVuln-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for FediVuln
url: https://github.com/CIRCL/FediVuln
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FediVuln-0.6.0-1.src.rpm
location_href: Packages/python-FediVuln-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  A client to gather vulnerability-related information from the Fediverse.
  The gathered data is subsequently transmitted to the
  [Vulnerability-Lookup](https://github.com/cve-search/vulnerability-lookup) API.




  [pipx](https://github.com/pypa/pipx) is an easy way to install and run Python applications in isolated environments.
  It's easy to [install](https://github.com/pypa/pipx?tab=readme-ov-file#on-linux).

  ```bash
  $ pipx install FediVuln
  $ export FEDIVULN_CONFIG=~/.FediVuln/conf.py
  ```

  The configuration for FediVuln should be defined in a Python file (e.g., ``~/.FediVuln/conf.py``).
  You must then set an environment variable (``FEDIVULN_CONFIG``) with the full path to this file.

  You can have a look at [this example](https://github.com/CIRCL/FediVuln/blob/main/fedivuln/conf_sample.py) of configuration.






  ```bash
  $ FediVuln-Register
  ```

  This script uses OAuth in order to retrieve the access token. This is achieved in several steps.

  - Register the application with Mastodon instance, a including all necessary scopes
  - Instantiate Mastodon client with client credentials
  - Log in - Generate authorization URL with the exact same scopes
  - Once the user authorizes, prompt for the authorization code
  - Use the authorization code to retrieve the access token, with the same scopes

  You only have to execute it once.




  ``FediVuln-Stream`` streams data from the Fediverse and uses PyVulnerabilityLookup to create sightings in Vulnerability-Lookup.

  ```bash
  usage: FediVuln-Stream [-h] [--user] [--public] [--push-sighting] [--push-status]

  Allows access to the streaming API.

  options:
    -h, --help       show this help message and exit
    --user           Streams events that are relevant to the authorized user, i.e. home timeline and notifications.
    --public         Streams public events.
    --push-sighting  Push the sightings to Vulnerability Lookup.
    --push-status    Push the status to Vulnerability Lookup.
  ```



  Streams events that are relevant to the authorized user, i.e. home timeline and notifications:

  ```bash
  $ FediVuln-Stream --user --push-sighting
  ```

  If you want to get the stream of public events (local server + connected servers):

  ```bash
  $ FediVuln-Stream --public --push-sighting
  ```

  Using the ``--push-sighting`` argument, detected vulnerability IDs will be recorded in
  [Vulnerability Lookup](https://github.com/cve-search/vulnerability-lookup) as
  [sightings](https://vulnerability-lookup.readthedocs.io/en/latest/sightings.html).




  ``FediVuln-Publish`` subscribes to an HTTP or Redis event stream and publishes the incoming data to the Fediverse.

  ```bash
  $ FediVuln-Publish --help
  usage: FediVuln-Publish [-h] [-t {vulnerability,comment,bundle,sighting}]

  options:
    -h, --help            show this help message and exit
    -t, --topic {vulnerability,comment,bundle,sighting}
                          The topic to subscribe to.
  ```

  The authentication to the HTTP event stream is automatically handled by PyVulnerabilityLookup.

  For each incoming event, a status will be posted using the configured Mastodon account.
  The format of the status is dynamically tailored to the specific event topic.
  For instance, executing the command ``FediVuln-Publish -t comment`` will capture all
  new comments and share a human-readable summary on the Fediverse, including a link to the
  original comment on the Vulnerability-Lookup instance.





  ```bash
  usage: FediVuln-Search [-h] --query QUERY

  Allows you to search for users, tags and, when enabled, full text, by default within your own posts and those you have interacted with.

  options:
    -h, --help     show this help message and exit
    --query QUERY  Query of the search.
  ```





  [FediVuln](https://github.com/CIRCL/FediVuln) is licensed under
  [GNU General Public License version 3](https://www.gnu.org/licenses/gpl-3.0.html)

  ~~~
  Copyright (c) 2024 Computer Incident Response Center Luxembourg (CIRCL)
  Copyright (C) 2024 Cédric Bonhomme - https://github.com/cedricbonhomme
  ~~~


pkgId: 4c171fc7ad9363da2cd922519d4c9027e575f8b8a319795f759a198552ed857c
name: python-FiinQuant-help
arch: noarch
version: 0.8.11
epoch: 0
release: 1
summary: Development documents and examples for FiinQuant
url: https://pypi.org/project/FiinQuant/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FiinQuant-0.8.11-1.src.rpm
location_href: Packages/python-FiinQuant-help-0.8.11-1.noarch.rpm
checksum_type: sha256
description:
  Python package for financial technical indicators.



  You can install the package via pip:
  ```
  pip install --upgrade FiinQuant
  ```


pkgId: 09e689aa93a70dcf0eb1182b8a6d1df6abdb339f10f31e73795889b2a8a86443
name: python-FinaleToolkit-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for FinaleToolkit
url: https://epifluidlab.github.io/FinaleToolkit/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FinaleToolkit-0.10.1-1.src.rpm
location_href: Packages/python-FinaleToolkit-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
  <summary><h3>Table of Contents</h2></summary>
  <ol>
    <li><a href="#about-the-project">About The Project</a></li>
    <li><a href="#installation">Installation</a></li>
    <li>
      <a href="#usage">Usage</a>
      <ul>
        <li><a href="#functionality">Functionality</a></li>
        <li><a href="#documentation">Documentation</a></li>
        <li><a href="#wiki">Wiki/Tutorials</a></li>
        <li><a href="#compatible-file-formats">Compatible File Formats</a></li>
        <li><a href="#using-fragment-files">Using Fragment Files</a></li>
      </ul>
    </li>
    <li><a href="#contact">Contact</a></li>
    <li><a href="#license">License</a></li>
  </ol>





  FinaleToolkit (**F**ragmentat**I**o**N** **A**na**L**ysis of c**E**ll-free DNA
  **Toolkit**) is a package and standalone program to extract fragmentation
  features of cell-free DNA from paired-end sequencing data.


  If you use FinaleToolkit in your research, please consider citing our paper:

  [![Static Badge](https://img.shields.io/badge/DOI-10.1101%2F2024.05.29.596414-blue?style=flat-square)](https://doi.org/10.1101/2024.05.29.596414)



  You can install the package using `pip`.
  ```
  $ pip install finaletoolkit
  ```





  FinaleToolkit has support for the following cell-free DNA fragmentation features:

  - Fragment Length
  - Coverage
  - End Motifs [![DOI](https://img.shields.io/badge/DOI-10.1158%2F2159--8290.CD--19--0622-blue?style=flat-square&label=DOI)](https://doi.org/10.1158/2159-8290.cd-19-0622)
  - Motif Diversity Score [![DOI](https://img.shields.io/badge/DOI-10.1158%2F2159--8290.CD--19--0622-blue?style=flat-square)](https://doi.org/10.1158/2159-8290.CD-19-0622)
  - Windowed Protection Score [![DOI](https://img.shields.io/badge/DOI-110.1016%2Fj.cell.2015.11.050-blue?style=flat-square)](https://doi.org/10.1016/j.cell.2015.11.050)
  - DELFI [![DOI](https://img.shields.io/badge/DOI-10.1038%2Fs41586--019--1272--6-blue?style=flat-square&link=https%3A%2F%2Fdoi.org%2F10.1038%252Fs41586-019-1272-6)](https://doi.org/10.1038%2Fs41586-019-1272-6)
  - Cleavage Profile [![DOI](https://img.shields.io/badge/DOI-10.1073%2Fpnas.2209852119-blue?style=flat-square)](https://doi.org/10.1073/pnas.2209852119)


  Documentation for FinaleToolkit can be found [here](https://epifluidlab.github.io/finaletoolkit-docs/).


  The wiki and tutorial page for FinaleToolkit can be found [here](https://github.com/epifluidlab/FinaleToolkit/wiki).



  FinaleToolkit is compatible with almost any paired-end sequence data:

  - Binary Alignment Map (`.bam`) files with an associated index file (`.bam.bai`).
  - Compressed Reference-oriented Alignment Map (`.cram`) files.
  - Fragment (`.frag.gz`) files with an associated tabix index file (`.frag.gz.tbi`).



  Fragment (`.frag.gz`) files are block-gzipped BED3+2 files with the following columns: `chrom` , `start` , `stop` , `mapq` , `strand`.

  We encourage you to use our comprehensive database, FinaleDB, to access relevant fragment files. Learn more about FinaleDB [here](http://finaledb.research.cchmc.org).


  - James Li: lijw21@wfu.edu
  - Ravi Bandaru: ravi.bandaru@northwestern.edu
  - Yaping Liu: yaping@northwestern.edu


  This project falls under an MIT license. See the included `LICENSE` file for details.

rpm_license:
  MIT License  Copyright (c) 2024 EpiFluidLab  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: 29acc4a85a5aa6e4d857bbf5b62d993901c82575125724d1dc9395b44bc9a6f3
name: python-FinaleToolkit-help
arch: noarch
version: 0.9.0
epoch: 0
release: 1
summary: Development documents and examples for FinaleToolkit
url: https://epifluidlab.github.io/FinaleToolkit/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FinaleToolkit-0.9.0-1.src.rpm
location_href: Packages/python-FinaleToolkit-help-0.9.0-1.noarch.rpm
checksum_type: sha256
description:
  <summary><h3>Table of Contents</h2></summary>
  <ol>
    <li><a href="#about-the-project">About The Project</a></li>
    <li><a href="#installation">Installation</a></li>
    <li>
      <a href="#usage">Usage</a>
      <ul>
        <li><a href="#functionality">Functionality</a></li>
        <li><a href="#documentation">Documentation</a></li>
        <li><a href="#compatible-file-formats">Compatible File Formats</a></li>
        <li><a href="#using-fragment-files">Using Fragment Files</a></li>
      </ul>
    </li>
    <li><a href="#contact">Contact</a></li>
    <li><a href="#license">License</a></li>
  </ol>





  FinaleToolkit (**F**ragmentat**I**o**N** **A**na**L**ysis of c**E**ll-free DNA
  **Toolkit**) is a package and standalone program to extract fragmentation
  features of cell-free DNA from paired-end sequencing data.


  If you use FinaleToolkit in your research, please consider citing our paper:

  [![Static Badge](https://img.shields.io/badge/DOI-10.1101%2F2024.05.29.596414-blue?style=flat-square)](https://doi.org/10.1101/2024.05.29.596414)



  You can install the package using `pip`.
  ```
  $ pip install finaletoolkit
  ```





  FinaleToolkit has support for the following cell-free DNA fragmentation features:

  - Fragment Length
  - Coverage
  - End Motifs [![DOI](https://img.shields.io/badge/DOI-10.1158%2F2159--8290.CD--19--0622-blue?style=flat-square&label=DOI)](https://doi.org/10.1158/2159-8290.cd-19-0622)
  - Motif Diversity Score [![DOI](https://img.shields.io/badge/DOI-10.1158%2F2159--8290.CD--19--0622-blue?style=flat-square)](https://doi.org/10.1158/2159-8290.CD-19-0622)
  - Windowed Protection Score [![DOI](https://img.shields.io/badge/DOI-110.1016%2Fj.cell.2015.11.050-blue?style=flat-square)](https://doi.org/10.1016/j.cell.2015.11.050)
  - DELFI [![DOI](https://img.shields.io/badge/DOI-10.1038%2Fs41586--019--1272--6-blue?style=flat-square&link=https%3A%2F%2Fdoi.org%2F10.1038%252Fs41586-019-1272-6)](https://doi.org/10.1038%2Fs41586-019-1272-6)
  - Cleavage Profile [![DOI](https://img.shields.io/badge/DOI-10.1073%2Fpnas.2209852119-blue?style=flat-square)](https://doi.org/10.1073/pnas.2209852119)


  Documentation for FinaleToolkit can be found [here](https://epifluidlab.github.io/finaletoolkit-docs/).



  FinaleToolkit is compatible with almost any paired-end sequence data:

  - Binary Alignment Map (`.bam`) files with an associated index file (`.bam.bai`).
  - Compressed Reference-oriented Alignment Map (`.cram`) files.
  - Fragment (`.frag.gz`) files with an associated tabix index file (`.frag.gz.tbi`).



  Fragment (`.frag.gz`) files are block-gzipped BED3+2 files with the following columns: `chrom` , `start` , `stop` , `mapq` , `strand`.

  We encourage you to use our comprehensive database, FinaleDB, to access relevant fragment files. Learn more about FinaleDB [here](http://finaledb.research.cchmc.org).


  - James Li: lijw21@wfu.edu
  - Ravi Bandaru: ravi.bandaru@northwestern.edu
  - Yaping Liu: yaping@northwestern.edu


  This project falls under an MIT license. See the included `LICENSE` file for details.

rpm_license:
  MIT License  Copyright (c) 2024 EpiFluidLab  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: 8ada1907299ddd62ea13a57ca55fff7549ace73005f040309a03dc75eb350c24
name: python-Flask-Multipass-CERN-help
arch: noarch
version: 2.2.13
epoch: 0
release: 1
summary: Development documents and examples for Flask-Multipass-CERN
url: https://pypi.org/project/Flask-Multipass-CERN/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Flask-Multipass-CERN-2.2.13-1.src.rpm
location_href: Packages/python-Flask-Multipass-CERN-help-2.2.13-1.noarch.rpm
checksum_type: sha256
description:
  This package provides the `cern` auth and identity providers for [Flask-Multipass][multipass].

  These providers are only useful if you are at CERN and intend to use Flask-Multipass
  with the new Keycloak-based CERN authentication infrastructure.

  In its current state it also overkill if all you want to do is logging in via OIDC. If that's your
  goal use the `authlib` multipass provider since Keycloak works perfectly fine with it.

  In case you need access to arbitrary group membership information (e.g. for user-managed ACLs) and
  the ability to search for CERN users, then this is a good choice for you.



  The following permissions (requested through the application portal) are needed:

  - Token exchange with `authorization-service-api` for basic login functionality
  - Group membership in `authorization-service-groups-readers` for group functionality
  - Group membership in `authorization-service-identity-readers` for user search functionality
  - Tokens with group membership information (optional) - this needs to be requested directly from
    the authorization service team

  Requesting them will most likely require you to have a professional justification.



  When using group membership or user search, the library need to get an "API access" token from
  keycloak which typically takes 200-300ms. Set the `cache` key of the multipass identity
  provider configuration to the import path of a Flask-Caching instance or a function returning such
  an instance, or the instance itself to enable caching of tokens (until they expire) and group
  data (30 minutes).

  If group membership information is included in tokens, it will be cached during login so the extra
  API call when checking whether a user is in a group won't be needed unless the cached data already
  expired.



  In applying the MIT license, CERN does not waive the privileges and immunities granted to it
  by virtue of its status as an Intergovernmental Organization or submit itself to any jurisdiction.


  [multipass]: https://github.com/indico/flask-multipass


pkgId: 95ef4d05384b6271332eb46815ff8760f0f4f2be1c806c44eefdd7b46a946afb
name: python-Flask-SQLAlchemy-compat-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for Flask-SQLAlchemy-compat
url: https://github.com/cainmagi/flask-sqlalchemy-compat
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Flask-SQLAlchemy-compat-0.2.0-1.src.rpm
location_href: Packages/python-Flask-SQLAlchemy-compat-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <p><img alt="Banner" src="https://repository-images.githubusercontent.com/900959960/5fa49b35-0f23-4e6d-9c00-b57ff6e513fd"></p>

  <p align="center">
    <a href="https://github.com/cainmagi/flask-sqlalchemy-compat/releases/latest"><img alt="GitHub release (latest SemVer)" src="https://img.shields.io/github/v/release/cainmagi/flask-sqlalchemy-compat?logo=github&sort=semver&style=flat-square"></a>
    <a href="https://github.com/cainmagi/flask-sqlalchemy-compat/releases"><img alt="GitHub all releases" src="https://img.shields.io/github/downloads/cainmagi/flask-sqlalchemy-compat/total?logo=github&style=flat-square"></a>
    <a href="https://github.com/cainmagi/flask-sqlalchemy-compat/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/cainmagi/flask-sqlalchemy-compat?style=flat-square&logo=opensourceinitiative&logoColor=white"></a>
    <a href="https://pypi.org/project/flask-sqlalchemy-compat"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/flask-sqlalchemy-compat?style=flat-square&logo=pypi&logoColor=white&label=pypi"/></a>
  </p>
  <p align="center">
    <a href="https://github.com/cainmagi/flask-sqlalchemy-compat/actions/workflows/python-package.yml"><img alt="GitHub Actions (Build)" src="https://img.shields.io/github/actions/workflow/status/cainmagi/flask-sqlalchemy-compat/python-package.yml?style=flat-square&logo=githubactions&logoColor=white&label=build"></a>
    <a href="https://github.com/cainmagi/flask-sqlalchemy-compat/actions/workflows/python-publish.yml"><img alt="GitHub Actions (Release)" src="https://img.shields.io/github/actions/workflow/status/cainmagi/flask-sqlalchemy-compat/python-publish.yml?style=flat-square&logo=githubactions&logoColor=white&label=release"></a>
  </p>

  Support the compatibility between `flask_sqlalchemy` and `flask_sqlalchemy_lite`. It allows users to make minimal changes when they need to migrate from either one of these two packages to each other.

  The main motivation of this package is because `flask_sqlalchemy_lite` does not support `python<=3.8`. This package is designed for providing the similar usages when users have to make the `flask_sqlalchemy_lite` working with `python<=3.8` by using `flask_sqlalchemy`. In this case, users can get rid of the difficulty of maintaining two sets of codes.

  > [!WARNING]
  > This package is designed for `sqlalchemy>=2.0.0` only. If you are using an older version. You cannot use this package.

  > [!WARNING]
  > To make this package work with `python=3.7`, users should install an unofficial `flask-sqlalchemy` version.



  Intall the **latest released version** of this package by using the PyPI source:

  ``` sh
  python -m pip install flask-sqlalchemy-compat
  ```

  or use the following commands to install **the developing version** from the GitHub Source when you have already installed [Git :hammer:][tool-git]:

  ```sh
  python -m pip install "flask-sqlalchemy-compat[dev] @ git+https://github.com/cainmagi/flask-sqlalchemy-compat.git"
  ```

  > [!WARNING]
  > To make this package work with `python=3.7`, users should install an unofficial `flask-sqlalchemy` version. See
  >
  > https://github.com/pallets-eco/flask-sqlalchemy/issues/1140#issuecomment-1577921154
  >
  > This unofficial version can be installed by:
  > ```sh
  > python -m pip install flask-sqlalchemy-compat[backends]
  > ```



  When you are using `flask-sqlalchemy-lite`, using the following codes will let your codes fall back to the compatible mode if `flask-sqlalchemy-lite` is not installed but `flask-sqlalchemy` is installed.

  ```python
  import sqlalchemy as sa
  import sqlalchemy.orm as sa_orm
  import flask_sqlalchemy_compat as fsc


  class _Base(sa_orm.DeclarativeBase): ...


  db, Base = fsc.get_flask_sqlalchemy_lite(_Base)


  class NewModel(Base):
      __tablename__ = "new_model"

      id: sa_orm.Mapped[int] = sa_orm.mapped_column(primary_key=True)
      name: sa_orm.Mapped[str] = sa_orm.mapped_column()


  if __name__ == "__main__":
      import os
      import flask

      app = flask.Flask(__name__, instance_path=os.path.abspath("./instance"))
      app.config.update({"SQLALCHEMY_ENGINES": {"default": "sqlite:///main.db"}})
      db.init_app(app)

      with app.app_context():
          Base.metadata.create_all(db.engine)

          db.session.add(NewModel(name="new"))
          db.session.commit()

          model = db.session.scalar(sa.select(NewModel))
          print(model.id, model.name) if model is not None else print("NOT FOUND.")
  ```

  The above codes will works no matter `flask_sqlalchemy_lite` or `flask_sqlalchemy` is installed.

  Similarly, the following example is designed for the codes written with `flask_sqlalchemy`. The codes fall back to the compatible mode if `flask-sqlalchemy` is not installed but `flask-sqlalchemy-lite` is installed.

  ```python
  import sqlalchemy as sa
  import sqlalchemy.orm as sa_orm
  import flask_sqlalchemy_compat as fsc


  class _Base(sa_orm.DeclarativeBase): ...


  db = fsc.get_flask_sqlalchemy(_Base)


  class NewModel(db.Model):
      id: sa_orm.Mapped[int] = sa_orm.mapped_column(primary_key=True)
      name: sa_orm.Mapped[str] = sa_orm.mapped_column()


  if __name__ == "__main__":
      import os
      import flask

      app = flask.Flask(__name__, instance_path=os.path.abspath("./instance"))
      app.config.update({"SQLALCHEMY_DATABASE_URI": "sqlite:///main.db"})
      db.init_app(app)

      with app.app_context():
          db.create_all()

          
          
          
          db.session.add(NewModel(name="new"))
          db.session.commit()

          model = db.session.scalar(sa.select(NewModel))
          print(model.id, model.name) if model is not None else print("NOT FOUND.")
  ```

  The magic happens if you run the first example with only `flask-sqlalchemy` installed and the second example with only `flask-sqlalchemy-lite` installed.

  Compared to the above minimal examples, we also provided a `usage.py` file and example applications in the `examples/` folder. Check them to view more details.

  > [!TIP]
  > To run the demos in `examples`, you need to install the optional dependencies by
  > ```sh
  > python -m pip install flask-sqlalchemy-compat[example,backends]
  > ```



  > [!CAUTION]
  > The documentation is not accessible now because it is still to be done.

  Check the documentation to find more details about the examples and APIs.

  https://cainmagi.github.io/flask-sqlalchemy-compat/



  See [CONTRIBUTING.md :book:][link-contributing]



  See [Changelog.md :book:][link-changelog]

  [tool-git]:https://git-scm.com/downloads

  [link-contributing]:https://github.com/cainmagi/flask-sqlalchemy-compat/blob/main/CONTRIBUTING.md
  [link-changelog]:https://github.com/cainmagi/flask-sqlalchemy-compat/blob/main/Changelog.md


pkgId: 980e88c738339f06a2cbb60c771cba265364541f51fdd4820dfb0a5eea1ae48b
name: python-Flask-SocketIO-help
arch: noarch
version: 5.5.0
epoch: 0
release: 1
summary: Development documents and examples for Flask-SocketIO
url: https://github.com/miguelgrinberg/flask-socketio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Flask-SocketIO-5.5.0-1.src.rpm
location_href: Packages/python-Flask-SocketIO-help-5.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build status](https://github.com/miguelgrinberg/flask-socketio/workflows/build/badge.svg)](https://github.com/miguelgrinberg/Flask-SocketIO/actions) [![codecov](https://codecov.io/gh/miguelgrinberg/flask-socketio/branch/main/graph/badge.svg)](https://codecov.io/gh/miguelgrinberg/flask-socketio)
  Socket.IO integration for Flask applications.


pkgId: 850c4ca0780557ee0d1c4c50da2f4c12b7587030f8cabc39aa0703d31e409140
name: python-FlaskSimpleAuth-help
arch: noarch
version: 34.0
epoch: 0
release: 1
summary: Development documents and examples for FlaskSimpleAuth
url: https://pypi.org/project/FlaskSimpleAuth/
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FlaskSimpleAuth-34.0-1.src.rpm
location_href: Packages/python-FlaskSimpleAuth-help-34.0-1.noarch.rpm
checksum_type: sha256
description:
  FlaskSimpleAuth is a [Flask](https://flask.palletsprojects.com/) wrapper to add
  a declarative security layer to routes with authentification, authorization and
  parameter management.

  ![Status](https://github.com/zx80/flask-simple-auth/actions/workflows/fsa.yml/badge.svg?branch=main&style=flat)
  ![Tests](https://img.shields.io/badge/tests-101%20✓-success)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-success)
  ![Issues](https://img.shields.io/github/issues/zx80/flask-simple-auth?style=flat)
  ![Python](https://img.shields.io/badge/python-3-informational)
  ![Version](https://img.shields.io/pypi/v/FlaskSimpleAuth)
  ![Badges](https://img.shields.io/badge/badges-8-informational)
  ![License](https://img.shields.io/pypi/l/flasksimpleauth?style=flat)

  With FlaskSimpleAuth, application and security concerns are separated:

  - the **application** focusses on *what* to do, and *declares* its security
    requirements.
  - the **configuration** declares *how* the authentification and authorization
    constraints are checked by providing settings and hook functions.
  - the **framework** *implements* and *enforces* the security on the application
    routes, with safe defaults so that security cannot be overlooked.

  The following Flask application provides two routes:

  - `GET /store` allows any authenticated *user* in group *employee* to
    access the store list.
  - `POST /store/<sid>` allows an authenticated *user* who is a *manager* of
    *store* number *sid* to add a quantity of product to the store inventory.

  ```python

  from FlaskSimpleAuth import Flask

  app = Flask("acme")
  app.config.from_envvar("ACME_CONFIG")

  @app.get("/store", authorize="employee")
  def get_store(pattern: str = "%"):
      
      return ..., 200

  @app.post("/store/<sid>/product", authorize=("store", "sid", "manager"))
  def post_store_sid_product(sid: int, product: str, quantity: int):
      
      return ..., 201
  ```

  In this code, there is *no* clue about how users are authenticated, as this is
  set from the configuration.
  Only authorizations are declared on the route with the mandatory ``authorize``
  parameter.
  How these are checked is also set from the configuration.
  HTTP or JSON parameters are automatically converted to the expected type,
  with features on par with [FastAPI](https://fastapi.tiangolo.com/).

  Authentication and authorizations are provided to the framework with callback functions.
  For our example, we will need to retrieve the salted hashed password for a user,
  to check whether a user belongs to a group, and
  to tell whether a user can access a given store in a particular role:

  ```python

  def get_user_pass(user: str) -> str|None:
      return ...  # hashed password retrieved from somewhere

  def user_is_employee(user: str) -> bool:
      return ...  # whether user belongs to group employee

  def store_perms(user: str, sid: int, role: str) -> bool|None:
      return ...  # whether user can access store sid in role
  ```

  Here is an example of configuration for the above application:
  Users are identified either with a JWT token or with a basic authentification.

  ```python

  import os
  import auth

  FSA_MODE = "dev"
  FSA_AUTH = ["token", "basic"]
  FSA_TOKEN_TYPE = "jwt"
  FSA_TOKEN_SECRET = os.environ["ACME_SECRET"]
  FSA_GET_USER_PASS = auth.get_user_pass
  FSA_GROUP_CHECK = { "employee": auth.user_is_employee }
  FSA_OBJECT_PERMS = { "store": auth.store_perms }
  ```

  The framework will ensure that routes are only called by authenticated users
  who have the right authorizations.
  Secure and reasonable defaults are provided.
  Most features can be adjusted or extended to particular needs through numerous
  directives and hooks.
  Authentication and authorization callback invocations are cached for efficiency.
  Also, [pydantic](https://docs.pydantic.dev/), dataclass and generic type
  parameters are supported out of the box.



  - [documentation](https://zx80.github.io/flask-simple-auth/)
    including a [tutorial](https://zx80.github.io/flask-simple-auth/TUTORIAL)
    and convenient [recipes](https://zx80.github.io/flask-simple-auth/RECIPES),
    [sources](https://github.com/zx80/flask-simple-auth) and
    [issues](https://github.com/zx80/flask-simple-auth/issues) are hosted on
    [GitHub](https://github.com/).
  - install [package](https://pypi.org/project/FlaskSimpleAuth/) from
    [PyPI](https://pypi.org/).



  This code is [Public Domain](https://creativecommons.org/publicdomain/zero/1.0/).

  All software has bug, this is software, hence…
  Beware that you may lose your hairs or your friends because of it.
  If you like it, feel free to send a postcard to the author.


pkgId: 5d522c1a9141b5a7f4a2dbce0a6bd7e4b656400459be4ff62a407d28e94788c5
name: python-FlexGet-help
arch: noarch
version: 3.13.1
epoch: 0
release: 1
summary: Development documents and examples for FlexGet
url: https://flexget.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FlexGet-3.13.1-1.src.rpm
location_href: Packages/python-FlexGet-help-3.13.1-1.noarch.rpm
checksum_type: sha256
description:
      Commenting these out for now, as they seem to be broken.
  `FlexGet`_ is a multipurpose automation tool for content like torrents, nzbs,
  podcasts, comics, series, movies, etc. It can use different kinds of sources
  like RSS-feeds, html pages, csv files, search engines and there are even
  plugins for sites that do not provide any kind of useful feeds.

rpm_license:
  The MIT License  Copyright (C) 2006, Riku 'Shrike' Lindblad Copyright (C) 2007, Marko Koivusalo  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: 579dfe658280caddd68f5a18850291adda6f27e856591e6a973a75095c62dac6
name: python-FlipCache-help
arch: noarch
version: 1.1
epoch: 0
release: 1
summary: Development documents and examples for FlipCache
url: https://github.com/goodeejay/FlipCache
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FlipCache-1.1-1.src.rpm
location_href: Packages/python-FlipCache-help-1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads total](https://pepy.tech/badge/flipcache)](https://pepy.tech/project/flipcache)
  [![Downloads monthly](https://img.shields.io/pypi/dm/flipcache.svg)](https://pypi.python.org/pypi/flipcache)
  [![PyPi Package Version](https://img.shields.io/pypi/v/flipcache.svg)](https://pypi.python.org/pypi/flipcache)
  [![PyPi status](https://img.shields.io/pypi/status/flipcache.svg)](https://pypi.python.org/pypi/flipcache)
  [![Supported python versions](https://img.shields.io/pypi/pyversions/flipcache.svg)](https://pypi.python.org/pypi/flipcache)
  [![Github issues](https://img.shields.io/github/issues/goodeejay/flipcache.svg)](https://github.com/goodeejay/flipcache/issues)
  [![MIT License](https://img.shields.io/pypi/l/flipcache.svg)](https://opensource.org/licenses/MIT)
  ![Views](https://komarev.com/ghpvc/?username=flipcache&label=views)

  <img align="right" src="assets/logo.jpg" alt="PyCache Logo" height="250px" width="auto">

  Redis-backed hybrid caching for lightning-fast Python data access



  - Seamlessly integrate Redis for accelerated data retrieval in your Python projects.
  - Optimize performance with an in-memory cache layer backed by Redis persistence.
  - Enjoy ease-of-use and flexible configuration

  <br/>


  ```bash
  pip install flipcache
  ```


  - **Hybrid Caching**: Transparent in-memory caching combined with Redis for scalable persistence.
  - **Expire Times**: Set custom expiration times for cached data.
  - **Configurable**: Tailor cache size, data types, and more.




  ```python
  from flipcache import FlipCache

  cache = FlipCache("my_cache")

  cache["my_key"] = "my_value"
  print(cache["my_key"])  # Outputs: "my_value"
  print(cache["unknown"])  # Outputs: None
  print("my_key" in cache)  # Outputs: True

  ```
  Pros compared to using simple dictionary:
  - Data persistence backed by Redis
  - Seamless data conversion from Redis to Python
  - Fast data access, compared to pure redis
  - Returns None instead of raising an error on key indexing



  ```python
  import time
  from flipcache import FlipCache

  expiring_cache = FlipCache("expiring", local_max=0, expire_time=5)

  expiring_cache["data"] = "This will expire"
  time.sleep(6)
  print(expiring_cache["data"])  # Outputs: None
  ```
  In order to expiring-feature work with its full potential, we need to set `local_max` to `0`, removing the caching layer.
  You lose out on faster data retrieval, in order to get precise expiration results.
  We can combine `expire_time` and `local_max`, in that case we can access data from cache memory that could have been expired.



  ```python
  from flipcache import FlipCache, et

  user_data = FlipCache(
      "user_data",
      local_max=100,
      expire_time=et.THREE_DAYS,
      value_type="json"
  )

  data = {
      "state": 1,
      "orders": [1, 2, 3, 4],
      "items": {
          "foo": 1,
          "bar": True,
          "baz": []
      }
  }


  user_data["some-uuid"] = data
  print(user_data["some-uuid"])  # {'state': 1, 'orders': [1, 2, 3, 4], 'items': {'foo': 1, 'bar': True, 'baz': []}}


  data["state"] = 2
  data["items"]["bar"] = False
  user_data["some-uuid"] = data
  print(user_data["some-uuid"])  # {'state': 2, 'orders': [1, 2, 3, 4], 'items': {'foo': 1, 'bar': False, 'baz': []}}


  del user_data["some-uuid"]
  print(user_data["some-uuid"])  # None
  ```



  ```python
  from flipcache import FlipCache
  from dataclasses import dataclass, field


  @dataclass
  class Shape:
      name: str = "default"
      dimensions: list[float] = field(default_factory=list)
      edges: int = 0
      area: float = 0

      def __post_init__(self):
          if not self.area and self.dimensions:
              self.area = self.dimensions[0] * self.dimensions[1]


  def encode_shape(shape: Shape) -> str:
      return f"{shape.name}||{shape.dimensions}||{shape.edges}||{shape.area}"


  def decode_shape(shape: str) -> Shape:
      data = shape.split("||")
      return Shape(
          name=data[0],
          dimensions=[float(num) for num in data[1].strip('[]').split(',') if num],
          edges=int(data[2]),
          area=float(data[3])
      )


  my_shape = Shape(name='womp', dimensions=[4.1, 3.4], edges=6, area=16.38)
  shape2 = Shape(name='wat', dimensions=[11, 22])

  custom = FlipCache(
      "custom",
      local_max=0,
      key_type='int',
      value_type='custom',
      value_default=Shape(),
      value_encoder=encode_shape,
      value_decoder=decode_shape
  )

  custom[123] = my_shape
  custom[456] = shape2
  print(custom[123])  # Shape(name='womp', dimensions=[4.1, 3.4], edges=6, area=16.38)
  print(custom[321])  # Shape(name='default', dimensions=[], edges=0, area=0.0)
  print(custom[456])  # Shape(name='wat', dimensions=[11.0, 22.0], edges=0, area=242.0)
  ```

  For more usage examples and details, see [examples](./examples)


  - `local_max`: Maximum items in the in-memory cache.
  - `expire_time`: Redis key expiration time.
  - `key_type`: Expected key data type.
  - `value_type`: Expected value data type.
  - `value_encoder`: Custom function used to encode the value for redis
  - `value_decoder`: Custom function used to decode the value from redis
  - `refresh_expire_time_on_get`: Refresh Redis key expiration on access
  - `redis_protocol`: custom redis.Redis instance to be passed



  <details>
      <summary>Setup</summary>

  ```python
  from flipcache import FlipCache
  from redis import Redis

  KEYS = 1_000
  rdp = Redis(decode_responses=True)
  cache = FlipCache(name="my_cache", redis_protocol=rdp, local_max=KEYS)


  def redis_set():
      for i in range(KEYS):
          rdp.set(f"my_cache:{i}", i * 2)


  def pycache_set():
      for i in range(KEYS):
          cache[i] = i * 2


  def redis_get():
      for _ in range(100):
          for i in range(KEYS):
              v = rdp.get(f"my_cache:{i}")


  def pycache_get():
      for _ in range(100):
          for i in range(KEYS):
              v = cache[i]
  ```
  </details>

  | Benchmark Name | Mean Time (s) | Standard Deviation |
  |----------------|---------------|--------------------|
  | redis_set      | 0.252         | 0.013              |
  | flipcache_set  | 0.242         | 0.003              |
  | redis_get      | 22.986        | 0.518              |
  | flipcache_get  | 0.0172        | 0.000              |




  - Make it possible to use other redis implementations such as aioredis
  - Create readthedocs site for detailed documentation
  - Optimize and add new functionality
  - Make it threadsafe
  - Add tests


pkgId: 961e20972c7078120defcf7a7a377063b966f00ffa86b600447ef9051c5b02e0
name: python-FlowCyPy-help
arch: noarch
version: 1.3.2
epoch: 0
release: 1
summary: Development documents and examples for FlowCyPy
url: https://github.com/MartinPdeS/FlowCyPy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FlowCyPy-1.3.2-1.src.rpm
location_href: Packages/python-FlowCyPy-help-1.3.2-1.noarch.rpm
checksum_type: sha256
description:
  |logo|
     * - Meta
       - |python|
       - |docs|
       - |colab|
     * - Testing
       - |ci/cd|
       - |coverage|
       -
     * - PyPi
       - |PyPi|
       - |PyPi_download|
       -

rpm_license:
  MIT License  Copyright (c) 2020 Martin de Sivry  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: 52aabe2290c738387e1d904251cd6b92334f8fb1336b50f2d44b7e9a1d8552db
name: python-FrameworkAPI-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for FrameworkAPI
url: https://github.com/pedrohenriquecoimbra/FrameworkAPI
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FrameworkAPI-0.0.3-1.src.rpm
location_href: Packages/python-FrameworkAPI-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Easily run scripts written in Python, R, or Julia with dynamic argument support.
  - **Automatic Language Detection**: Identify script type and invoke the appropriate runtime (e.g., `python`, `Rscript`, `julia`).
  - **Flexible Argument Passing**: Pass command-line arguments directly to scripts for parameterized execution.
  - **Robust Error Handling**: Logs and handles errors during script execution.

  Effortlessly parse, validate, and manage YAML files with cross-references.
  - **Dynamic Parsing**: Load YAML configurations into Python objects.
  - **Cross-Reference Resolution**: Automatically resolve dependencies between keys within a single file or across multiple files.
  - **Flexible Configuration Management**: Merge or extend YAML files to build modular workflows.

  A simple API to link scripts and configurations for easy execution.
  - **Script Discovery**: Fetch script paths and parameters from the YAML configuration.
  - **Workflow Automation**: Execute scripts dynamically based on configuration settings.


pkgId: b5c7ce4106ce246006adec259514b1f1c900f82a5aca10a5de5defc2751baf4e
name: python-FreeClimb-help
arch: noarch
version: 4.9.0
epoch: 0
release: 1
summary: Development documents and examples for FreeClimb
url: https://freeclimb.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-FreeClimb-4.9.0-1.src.rpm
location_href: Packages/python-FreeClimb-help-4.9.0-1.noarch.rpm
checksum_type: sha256
description:
      FreeClimb is a cloud-based application programming interface (API) that puts the power of the Vail platform in your hands. FreeClimb simplifies the process of creating applications that can use a full range of telephony features without requiring specialized or on-site telephony equipment. Using the FreeClimb REST API to write applications is easy! You have the option to use the language of your choice or hit the API directly. Your application can execute a command by issuing a RESTful request to the FreeClimb API. The base URL to send HTTP requests to the FreeClimb REST API is: /apiserver. FreeClimb authenticates and processes your request.  # noqa: E501


pkgId: 21e21b95b1c912389ba21671c16d1383d81acd0bc0c61fe7385be08bac8667bd
name: python-GABRIEL-ratings-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for GABRIEL-ratings
url: https://github.com/elliottmokski/GABRIEL-distribution
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GABRIEL-ratings-2.0.0-1.src.rpm
location_href: Packages/python-GABRIEL-ratings-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  GABRIEL is a simple Python framework built on top of LLMs like ChatGPT to simplify quantitative text analysis in the social sciences.

  IMPORTANT: Follow this Colab tutorial notebook for the easiest setup guide: https://colab.research.google.com/drive/1tshfY-2al7asU7pTFvFFg1n4NSvLXtZg?usp=sharing

  The full documentation is below.



  The new Python library replaces the previous API and dramatically simplifies the use of the package. Installation is extremely simple using pip.

  Before you install our package, we require that you install the OpenAI library. Open your terminal or command prompt and run:

  ```bash
  pip install openai
  ```

  Once you have installed OpenAI, install GABRIEL using
  ```bash
  pip install gabriel-ratings
  ```




  The main way to get ratings from GABRIEL is using the Archangel class. The class requires an OpenAI api-key for instantiation. We strongly recommend you store the key as an environment variable. To create an Archangel object, use the following syntax.

  ```python
  from GABRIEL.Archangel import Archangel
  combined_assistant = Archangel(your_api_key)
  ```

  Once you create the object, you can run a simple ratings framework through the *rate_texts* function. You must supply a list of the texts to rate, *texts*; an *attributes_dict*, where the keys are your attributes, and the values are the definitions, and a *task_description*, which is a few sentence description of what you're trying to acccomplish (your data, your question, etc.). In addition, we require a *save_folder* and a *file_name*, which is where the output from your run will be saved.

  You can also specify a specific OpenAI model for your call, using the *model* parameter (the default is GPT-3.5-turbo). See below for the full list of parameters, and more detailed descriptions.

  The simplest ratings call, which returns a Pandas dataframe, is just:

  ```python
  ratings = archangel.rate_texts(texts, attribute_dict= attribute_dict, save_folder = 'path_to_your_folder', file_name = 'your_file_name.csv', task_description = 'your_task_description')
  ```



  The Archangel class comes with a number of easy to use features to help you run your code.
  - parallelization: the library parallelizes API calls to dramatically speed up running time. We configure this by default.
  - cost estimates: we provide a very rough cost estimate of each run when you begin the call, based on the model and texts you input.
  - auto-saving: the class will auto-save your results to a CSV at each iteration, as long as you provide a valid path.



  To simplify the task of choosing your hyperparameters, we provide two default options:
  - 'mazda': cheap, fast, and reliable. Uses GPT-3.5-turbo, with text truncation to 9500 words to allow for prompts. Runs 50 queries in parallel.
  - 'tesla': expensive. Uses GPT-4-turbo, with 30 parallel queries. Not recommended due to cost.



  The full list of parameters for the function is as follows.

  - **`attribute_dict`** A dictionary where the keys are the attributes you want to evaluate, and the values are the descriptions. See Colab notebook for examplse.
  <!-- - **`attributes`** (optional): A list containing the desired attributes for evaluation. If this is not specified, the model will generate **`n_search_attributes`** attributes itself. For example, `n_search_attributes = ['optimism', 'negativity', 'concern about unemployment']`. -->
  <!-- - **`n_search_attributes`** (optional): An integer containing the number of attributes to generate if no attributes were specified. Defaults to 5. For example, `n_search_attributes = 10`. -->
  <!-- - **`descriptions`** (optional): A list of descriptions for the attributes if **`attributes`** are provided explicitly. Otherwise, the descriptions will be generated by the model. For example, `descriptions = ['The happy attribute refers to a positive emotional state characterized by feelings of joy, contentment, and satisfaction.', 'The "sad" attribute is a feeling of sorrow, unhappiness, or distress. It is an emotional state characterized by a low mood and a sense of loss or disappointment.']`. -->
  <!-- - **`object_clarification`** (optional): A string providing further clarification on the objects (e.g., a string of comma-separated examples). -->
  <!-- - **`attribute_clarification`** (optional): A string providing further clarification on the attributes (e.g., a string of comma-separated examples). For use in the generation of attributes. -->
  <!-- - **`use_classification`** (optional - defaults to False): Toggles whether the model uses a ratings or classification approach. -->
  <!-- - **`classification_clarification`** (optional - only considered when `use_classification = True`): An additional string to provide context on the classification process. -->
  - **`truncate`** (optional, defaults to True): Whether to truncate the text. This avoids overloading the API token limit (16k tokens for the default model).
  -**`truncate_len`** (optional, defaults to 5000) the amount of text to keep.
  - **`project_probs`** (optional, defaults to False): Whether to project the probabilities from 0 to 100 to a 0 to 1 scale.
  - **`api_key`** (mandatory): Your OpenAI API key.
  - **`model`** (optional): Backend model, default = `gpt-3.5-turbo-1106`.
  - **`seed`** (optional, RECOMMENDED): Set a seed for cross-run replicability. For instance, `seed = 0`.



  Please cite the project using:

  The Generalized Attribute Based Ratings Information Extraction Library (GABRIEL). Hemanth Asirvatham and Elliott Mokski (2023). https://github.com/elliottmokski/GABRIEL-distribution.


pkgId: dd61ed1bef965d88c08cba5a4243ac17e7505db5e17a3bc120dab147a9de7066
name: python-GANDLF-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for GANDLF
url: https://pypi.org/project/GANDLF/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GANDLF-0.1.2-1.src.rpm
location_href: Packages/python-GANDLF-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub-Mark-Light](https://github.com/mlcommons/GaNDLF/blob/master/docs/images/logo/full.png?raw=true#gh-light-mode-only)

  ![GitHub-Mark-Dark](https://github.com/mlcommons/GaNDLF/blob/master/docs/images/logo/full_black.png?raw=true#gh-dark-mode-only)

  <p align="center">
    <a href="https://github.com/mlcommons/GaNDLF/actions/workflows/python-test.yml" alt="Build Status"><img src="https://github.com/mlcommons/GaNDLF/actions/workflows/python-test.yml/badge.svg" /></a>
    <a href="https://github.com/mlcommons/GaNDLF/actions/workflows/codeql-analysis.yml" alt="Code Analysis"><img src="https://github.com/mlcommons/GaNDLF/workflows/CodeQL/badge.svg" /></a>
    <a href="https://hub.docker.com/repository/docker/cbica/gandlf" alt="Docker CI"><img src="https://github.com/mlcommons/GaNDLF/actions/workflows/docker-image.yml/badge.svg" /></a>
    <a href="https://codecov.io/gh/mlcommons/GaNDLF" alt="Code Coverage"><img src="https://codecov.io/gh/mlcommons/GaNDLF/branch/master/graph/badge.svg?token=4I54XEI3WE" /></a>
    <a href="https://app.codacy.com/gh/mlcommons/GaNDLF/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage" alt="Codacy Code Coverage"><img src="https://app.codacy.com/project/badge/Coverage/51a47165e3644ec6acdfbac345843b7c" /></a><br>
    <a href="https://app.codacy.com/gh/mlcommons/GaNDLF/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade"><img alt="Codacy" src="https://app.codacy.com/project/badge/Grade/51a47165e3644ec6acdfbac345843b7c"></a>
    <a href="https://pypi.org/project/GANDLF/" alt="Install"><img src="https://img.shields.io/pypi/v/gandlf?color=blue" /></a>
    <a href="https://anaconda.org/conda-forge/gandlf" alt="Install"><img src="https://img.shields.io/conda/vn/conda-forge/gandlf?color=green" /></a>
    <a href="https://github.com/mlcommons/GaNDLF/discussions" alt="Issues"><img src="https://img.shields.io/badge/Support-Discussion-blue?color=red" /></a>
    <a href="https://doi.org/10.1038/s44172-023-00066-3" alt="Citation"><img src="https://img.shields.io/badge/Cite-citation-lightblue" /></a>
    <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/Code%20Style-black-000000.svg"></a>
  </p>

  The **G**ener**a**lly **N**uanced **D**eep **L**earning **F**ramework for segmentation, regression and classification.

  <p align="center">
      <img width="500" src="./docs/images/all_options_3.png" alt="GaNDLF all options">
  </p>



  - Supports multiple
    - Deep Learning model architectures
    - Data dimensions (2D/3D)
    - Channels/images/sequences
    - Prediction classes
    - Domain modalities (i.e., Radiology Scans and Digitized Histopathology Tissue Sections)
    - Problem types (segmentation, regression, classification)
    - Multi-GPU (on same machine) training
  - Built-in
    - Nested cross-validation (and related combined statistics)
    - Support for parallel HPC-based computing
    - Support for training check-pointing
    - Support for [Automatic mixed precision](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/)
  - Robust data augmentation, courtesy of [TorchIO](https://github.com/fepegar/torchio/)
  - Handles imbalanced classes (e.g., very small tumor in large organ)
  - Leverages robust open source software
  - No need to write any code to generate robust models



  Please cite the following article for GaNDLF ([full paper](https://www.nature.com/articles/s44172-023-00066-3)):

  ```bib
  @article{pati2023gandlf,
      author={Pati, Sarthak and Thakur, Siddhesh P. and Hamamc{\i}, {\.{I}}brahim Ethem and Baid, Ujjwal and Baheti, Bhakti and Bhalerao, Megh and G{\"u}ley, Orhun and Mouchtaris, Sofia and Lang, David and Thermos, Spyridon and Gotkowski, Karol and Gonz{\'a}lez, Camila and Grenko, Caleb and Getka, Alexander and Edwards, Brandon and Sheller, Micah and Wu, Junwen and Karkada, Deepthi and Panchumarthy, Ravi and Ahluwalia, Vinayak and Zou, Chunrui and Bashyam, Vishnu and Li, Yuemeng and Haghighi, Babak and Chitalia, Rhea and Abousamra, Shahira and Kurc, Tahsin M. and Gastounioti, Aimilia and Er, Sezgin and Bergman, Mark and Saltz, Joel H. and Fan, Yong and Shah, Prashant and Mukhopadhyay, Anirban and Tsaftaris, Sotirios A. and Menze, Bjoern and Davatzikos, Christos and Kontos, Despina and Karargyris, Alexandros and Umeton, Renato and Mattson, Peter and Bakas, Spyridon},
      title={GaNDLF: the generally nuanced deep learning framework for scalable end-to-end clinical workflows},
      journal={Communications Engineering},
      year={2023},
      month={May},
      day={16},
      volume={2},
      number={1},
      pages={23},
      abstract={Deep Learning (DL) has the potential to optimize machine learning in both the scientific and clinical communities. However, greater expertise is required to develop DL algorithms, and the variability of implementations hinders their reproducibility, translation, and deployment. Here we present the community-driven Generally Nuanced Deep Learning Framework (GaNDLF), with the goal of lowering these barriers. GaNDLF makes the mechanism of DL development, training, and inference more stable, reproducible, interpretable, and scalable, without requiring an extensive technical background. GaNDLF aims to provide an end-to-end solution for all DL-related tasks in computational precision medicine. We demonstrate the ability of GaNDLF to analyze both radiology and histology images, with built-in support for k-fold cross-validation, data augmentation, multiple modalities and output classes. Our quantitative performance evaluation on numerous use cases, anatomies, and computational tasks supports GaNDLF as a robust application framework for deployment in clinical workflows.},
      issn={2731-3395},
      doi={10.1038/s44172-023-00066-3},
      url={https://doi.org/10.1038/s44172-023-00066-3}
  }
  ```



  GaNDLF has extensive documentation and it is arranged in the following manner:

  - [Home](https://mlcommons.github.io/GaNDLF/)
  - [Installation](https://mlcommons.github.io/GaNDLF/setup)
  - [Usage](https://mlcommons.github.io/GaNDLF/usage)
  - [Extension](https://mlcommons.github.io/GaNDLF/extending)
  - [Frequently Asked Questions](https://mlcommons.github.io/GaNDLF/faq)
  - [Acknowledgements](https://mlcommons.github.io/GaNDLF/acknowledgements)



  Please see the [contributing guide](./CONTRIBUTING.md) for more information.



  The GaNDLF development team hosts a weekly meeting to discuss feature additions, issues, and general future directions. If you are interested to join, please <a href="mailto:gandlf@mlcommons.org?subject=Meeting Request">send us an email</a>!


  - The software has been designed for research purposes only and has neither been reviewed nor approved for clinical use by the Food and Drug Administration (FDA) or by any other federal/state agency.
  - This code (excluding dependent libraries) is governed by [the Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt) provided in the [LICENSE file](./LICENSE) unless otherwise specified.


  For more information or any support, please post on the [Discussions](https://github.com/mlcommons/GaNDLF/discussions) section.


pkgId: 94fe89c535c27e260e96b201a52b4f8a865b962f7e5fc9bbc0932be79048fe4a
name: python-GPminer-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for GPminer
url: https://github.com/LHanLi/GPminer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GPminer-2.0.2-1.src.rpm
location_href: Packages/python-GPminer-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  pip install GPminer



  遗传算法策略挖掘框架

  ![image](https://github.com/user-attachments/assets/1eaa5124-3c13-4cdb-ac80-6d6cd683b0f7)



  demo文件夹，数据与自定义参数可修改


  对于框架外需求或改进建议，可以联系作者。
  ![cde0c826807b3836377d0e13cf4bbf4](https://github.com/user-attachments/assets/3954cec9-8d4e-481c-a014-2ec971ab7cb4)


pkgId: 5e805670856058a4e00eccdf8e5355c48b5d0ed23e8a99f4471c8a726483ccdb
name: python-Gatria-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for Gatria
url: https://github.com/Canopus-Development/Gatria
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Gatria-0.1.0-1.src.rpm
location_href: Packages/python-Gatria-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - [Features](#features)
  - [Getting Started](#getting-started)
    - [Prerequisites](#prerequisites)
    - [Installation](#installation)
    - [Basic Usage](#basic-usage)
  - [Installation Options](#installation-options)
  - [Documentation](#documentation)
  - [Examples](#examples)
    - [Web Framework Integration](#web-framework-integration)
    - [Database Operations](#database-operations)
    - [Asynchronous Operations](#asynchronous-operations)
    - [Machine Learning Analytics](#machine-learning-analytics)
  - [Configuration](#configuration)
  - [Contributing](#contributing)
  - [License](#license)


pkgId: bc4c27cc65c64b75d8780bb2c70161046152409eed08fa892263eca1a6be9231
name: python-GenPhylo-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for GenPhylo
url: https://github.com/GenPhyloProject/GenPhylo
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GenPhylo-1.2.1-1.src.rpm
location_href: Packages/python-GenPhylo-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  We introduce **GenPhylo**, an open-source Python module for simulating genetic data along a phylogeny avoiding the restriction of continuous-time Markov processes. **GenPhylo** uses directly a general Markov model and therefore naturally incorporates heterogeneity across lineages.


pkgId: 09e954727b7119781aa5d6c7aa1a4b9e16dca19f55799000cdb28e593869b641
name: python-GibbsTS-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for GibbsTS
url: https://pypi.org/project/GibbsTS/
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GibbsTS-1.0.2-1.src.rpm
location_href: Packages/python-GibbsTS-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  - **Automated surface generation**: Builds thermodynamic surfaces for solid and liquid phases.
  - **Melting data**: Obtaining melting data for solid and liquid phases based on user-defined pressure conditions. With the *ab initio* molecular dynamics (AIMD) simulation data in the NVT (N, number of atoms; V, volume; T, temperature) ensemble and the reference point, GTS is able to rapidly present melting data, including volume, pressure, temperature, and thermodynamic potentials


pkgId: 143cf6e462d408ae84546c8ff4d5ea17b1d9e7a223355948e88b855a4e6aa9c6
name: python-GitHubKit-help
arch: noarch
version: 0.12.2
epoch: 0
release: 1
summary: Development documents and examples for GitHubKit
url: https://github.com/yanyongyu/githubkit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GitHubKit-0.12.2-1.src.rpm
location_href: Packages/python-GitHubKit-help-0.12.2-1.noarch.rpm
checksum_type: sha256
description:
  <!-- markdownlint-disable MD041 -->
  <div align="center">

  [![githubkit](https://socialify.git.ci/yanyongyu/githubkit/image?description=1&descriptionEditable=%E2%9C%A8%20GitHub%20SDK%20for%20Python%20%E2%9C%A8&font=Bitter&language=1&pattern=Circuit%20Board&theme=Light)](https://github.com/yanyongyu/githubkit)

  </div>

  <p align="center">
    <a href="https://raw.githubusercontent.com/yanyongyu/githubkit/master/LICENSE">
      <img src="https://img.shields.io/github/license/yanyongyu/githubkit" alt="license">
    </a>
    <a href="https://pypi.python.org/pypi/githubkit">
      <img src="https://img.shields.io/pypi/v/githubkit?logo=python&logoColor=edb641" alt="pypi">
    </a>
    <img src="https://img.shields.io/badge/python-3.8+-blue?logo=python&logoColor=edb641" alt="python">
    <a href="https://github.com/psf/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg?logo=python&logoColor=edb641" alt="black">
    </a>
    <a href="https://github.com/Microsoft/pyright">
      <img src="https://img.shields.io/badge/types-pyright-797952.svg?logo=python&logoColor=edb641" alt="pyright">
    </a>
    <a href="https://github.com/astral-sh/ruff">
      <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="ruff">
    </a>
    <a href="https://results.pre-commit.ci/latest/github/yanyongyu/githubkit/master">
      <img src="https://results.pre-commit.ci/badge/github/yanyongyu/githubkit/master.svg" alt="pre-commit" />
    </a>
  </p>

  <div align="center">

  <!-- markdownlint-capture -->
  <!-- markdownlint-disable MD036 -->

  _✨ The modern, all-batteries-included GitHub SDK for Python ✨_

  _✨ Support both **sync** and **async** calls, **fully typed** ✨_

  _✨ Always up to date, like octokit ✨_

  <!-- markdownlint-restore -->

  </div>

  <p align="center">
    <a href="https://yanyongyu.github.io/githubkit/"><b>Documentation</b></a> |
    <a href="https://github.com/yanyongyu/githubkit/issues"><b>Report Bug</b></a> |
    <a href="https://docs.github.com/"><b>GitHub Docs</b></a>
  </p>

  githubkit aims to be an easy-to-use, fully typed, and always up-to-date GitHub SDK for Python. It is inspired by [octokit](https://github.com/octokit).

  githubkit provides several features including:

  - Support both sync and async calls
  - Multiple authentication ways and OAuth flow support
  - Calling REST API and GraphQL easily
  - REST API versioning, including GHEC
  - Built-in pagination support
  - Optional data validation with [Pydantic](https://docs.pydantic.dev/latest/), for both webhook events and REST API responses
  - Built-in http cache (powered by [Hishel](https://hishel.com/) for HTTPX) and auto retry
  - Lazy loading of APIs and models
  - Fully typed APIs



  For more, see the [documentation](https://yanyongyu.github.io/githubkit).



  Install githubkit with the package manager of your choice:

  ```bash
  pip install githubkit

  poetry add githubkit

  pdm add githubkit

  uv add githubkit
  ```



  Create a [Personal Access Token (PAT)](https://github.com/settings/personal-access-tokens/new) and use it to create a `GitHub` instance:

  ```python
  from githubkit import GitHub

  github = GitHub("<your_token_here>")
  ```

  Then, enjoy githubkit now!

  ```python
  from githubkit import Response
  from githubkit.versions.latest.models import FullRepository

  resp: Response[FullRepository] = github.rest.repos.get("owner", "repo")
  repo: FullRepository = resp.parsed_data
  print(repo.full_name)
  ```



  See the [development](https://yanyongyu.github.io/githubkit/contributing/) in the contributing guide.



  Thanks to the following people who have contributed to this project:

  <a href="https://github.com/yanyongyu/githubkit/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=yanyongyu/githubkit&max=1000" alt="contributors" />
  </a>


pkgId: 70ac36c4ef49c8ce6912780756cbc3539f473de6f6c526e0a4239b2d5ca7af6d
name: python-GraphClusterer-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for GraphClusterer
url: https://github.com/yoelAshkenazi/GraphClusterer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GraphClusterer-0.0.2-1.src.rpm
location_href: Packages/python-GraphClusterer-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  We aim to improve the quality of a multi-document summary, given the connections between the texts (via shared authors, institution, subject etc.).
  Our method is as follows:
  1. Calculate the direct distances between the texts in the graph.
  2. Build a new graph with two edge types:
      * Blue edges: represent the original connections given.
      * Red edges: represent similarity between texts.
  3. Cluster the multi color edged graph.
  4. Summarize each cluster.
  5. Evaluate the summarization of each cluster.

  Our python package contains a full pipeline that performs the above operations (1-5), or alternatively perform specific operations individually.




  -  [Installation](#installation)
  -  [Quick tour](#quick-tour)


  We do not have an official python package manager installation available yet. However,
  this repository is public, and one can clone the repository and open it in any IDE that accepts git.



  To immediately use our package, you only need to run three functions (two if you wish to skip the final evaluations).<br>
  You need to have your data in one of the following formats:
    1. a prepared graph of texts in ''.gpickle'' format.
    2. two csv files to make the graph from: vertex metadata and edges.


  In this case you can skip the graph processing part, and go straight to the [clustering](#clustering) part.
  The prepared graph needs to include the followings:
    1. vertex attribute called 'content', whose value is the textual data of the vertex.
    2. (optional) vertex attribute called 'shape', in order to distinguish between texts in different languages (for now, this case deals with each language individually).


  In this case, we need to create the graph first.
  1. The csv containing vertex data has to be named '`{dataset name}_papers.csv`', and has to contain at least an ID column and 'abstract' column.
  The ID column values are used to identify texts, and the 'abstract' column should contain the texts.<br>
  2. The csv containing edges has to be named '`{dataset name}_graph.csv`' and have 2 columns by default, and each of its rows has to contain at least one identifiable text that appears in the vertex data file.
  In case the other element is not identifiable, a new vertex will be created, with a different type and no content.
  3. Rows with 3 or more elements will be dealt as a clique.

  Secondly, calculation of distances between texts are required. For that we firstly have to convert the texts to sets of embedding vectors.
  We do that in '`2_embed_abstracts.py`' using the `sentence-transformers` package, refer to each text as a set of sentence embeddings, and calculate 'energy distance' between two texts (two sets of vectors) in '`calc_energy.py`'.
  In order to successfully estimate the distance between two texts, we filter sentences that interrupt the procedure (in our case, we prefer to filter out the most common sentences, as well as the rarest sentences). We do that by combining all of the sentences' embeddings in the dataset into one list, order the items according to their frequencies, and filtering `least_cutoff_percentage` embeddings from the least common sentences. Similarly, we filter `most_cutoff_percentage` embeddings from the most common sentences. Both cutoff parameters are optimized for each dataset given.

  After filtering out the irrelevant embeddings, we compute the distances between each pair of texts using 'energy distance':
  ```python
  def compute_energy_distance_matrix(ds_name, least_cutoff_percentage, most_cutoff_percentage):
  ```

  Where:
  - `ds_name`: The name of the dataset.
  - `least_cutoff_percentage`: The percentage of data to filter among rare sentences.
  - `most_cutoff_percentage`: The percentage of data to filter among frequent sentences.
  We then calculate the energy distance between each pair of embeddings using the using `dcor` package.


  Returns: The energy distance matrix for the matched embedding.


  You can then run the graph creating part of our pipeline in '`functions.py`':
  ```python
  def make_graph(name, **kwargs):
  ```
  Where:
  - `name`: The name of the dataset.
  - `**kwargs`: A dictionary of values to manually configure the graph creation. Here is an example dictionary:
  ```python
  graph_kwargs = {
          'size': 2000,
          'color': '#1f78b4',
          'K': 5,
      }
  ```
  where:
    * `k`: The number of neighbors to account for in the distance based edges.
    * `color`: The default vertex color (needed in order to plot the final vertex partition).
    * `size`: The default vertex size (needed in order to plot the final vertex partition).


  Returns: Processed graph (`networkx.Graph` object)

  <img src="https://github.com/user-attachments/assets/e2715659-458f-41e5-b16b-7879c5aef7e0" alt="0" width="600px">


  After processing/creating the graph of texts (and keywords), we cluster the graph using the [Louvain method](https://en.wikipedia.org/wiki/Louvain_method) with the implementation embedded in the `networkx` module.
  In case the graph consists of keyword vertices, and not exclusively texts, the other vertices are included in the clustering part of our pipeline, but ignored from then on.
  The clustering is also done in the '`function.py`' source file. In addition to return the partition, our method also assigns each vertex with a color, as a way to map the vertices to clusters later on.
  ```python
  def cluster_graph(G, name, **kwargs):
  ```
  Where:
  * `G`: The processed/given graph.
  * `name`: The name of the dataset.
  * `**kwargs`: A dictionary of values to manually configure the clustering process. Here is an example dictionary:
  ```python
  clustering_kwargs = {
          'save': True,
          'resolution': res,
          'weight': weight,
          'K': K
      }
  ```
  Where:
  * `save`: A flag indicating whether to save the clustered graph as a '`.gpickle`' format or not.
  * `weight`: The assigned weight for distance based edges.
  * `k`: The number of neighbors to account for in the distance based edges.


  Returns: $\mathcal{P}$ a partition of vertices from `G` into communities.

  Example for the clustering:

  <img src="https://github.com/user-attachments/assets/54c32d5a-f4f5-4dc3-a144-ec990f7bb0b3" alt="unnamed" width="600px">



  As mentioned in the [introduction](#introduction) section, the main goal of our pipeline is to summarize clusters of vertices, rather than the full graph.
  To achieve that we perform the following steps:
  1. Cluster the graph (see [clustering](#clustering)).
  2. Divide the graph according to the clusters (done in `filter_by_color()`).
  3. Summarize each cluster individually. In this step, each time we are given a subgraph of only the cluster. Firstly we        filter out non-textual vertices, then we access the texts and save them in a list, and then we send the list with a         prompt to two iterations of LLM generation:
        1. `command-r`: in this iteration, we generate a draft of the final summary.
        2. `llama-3.1`: in this iteration, we refine the summary and enrich its language.


     And a third iteration generates a title for the summary (also made with `llama-3.1`).


  The full summarization process happen in `summarize_per_color()`:
  ```python
  def summarize_per_color(subgraphs, name):
  ```

  Where:
  * `subgraphs`: A list of subgraphs, each belong to a different cluster (see step 2).
  * `name`: The name of the dataset.


  The function fetches the texts from the vertices in the subgraph, send them to the above 3 iterations of LLM generation, and saves the summaries for each cluster as a '`.txt`' file in a folder named `name`.

  <img src="https://github.com/user-attachments/assets/3394ceaa-7660-4e79-803a-5d21836ec5b6" alt="0" width="600px">


  ```text
  Biomass-derived carbons (BDCs) and their composites with conductive materials, such as metals, metal sulfides, carbon nanotubes,
  and reduced graphene oxide, are used to enhance the performance of supercapacitors. By combining BDCs with conductive additives,
  researchers aim to improve conductivity, charge/discharge capabilities, and specific surface area, resulting in higher specific
  capacitance values. This approach integrates the benefits of electrochemical double-layer capacitors (EDLCs) and pseudocapacitors,
  leading to enhanced energy density. Layered double hydroxides (LDHs), synthetic two-dimensional nano-structured anionic clays, are
  also explored as hosts for Azo-compounds to create nano-hybrid materials. Intercalating large anionic pigments like phenyl azobenzoic
  sodium salt into Zn-Al LDH increases the interlayer spacing significantly, and the resulting nano-hybrid material is used as a filler
  for polyvinyl alcohol (PVA) to form nano-composites that exhibit improved thermal stability compared to pure PVA.
  ```


  In the evaluation section, we execute a series of tests in order to assess the quality of:
  * The [clustering](#clustering-scores).
  * The [summaries](#summary-scores) (as text documents).
  * The [consistency](#consistency-index) between a summary and its origin.



  The clustering scores evaluate how good the clustering partitioned the graph. For that we used two metrics (one is irrelevant if the graph is given by the user and not created by our '`make_graph()`' method). Here we computed everything by ourselves.
  1. 'Average index': This metric measures the proportion between the average distance between two vertices from the same cluster, compared to two random vertices. (This method is relevant only for graphs our method created)
  2. 'Largest cluster percentage': This metric measures the percentage of data in the largest cluster created.


  Both metrics are between 0 and 1, and we would expect different optimal results:
  * The optimal 'average index' should be as low as possible, but strictly positive.
  * The optimal 'largest cluster percentage' shoule be around 0.5 (or 50% of the data).



  The summary scores measure how understandable a summary is as a text. For that four scores are estimated:
  1. 'Fluency'
  2. 'Consistency'
  3. 'Coherence'
  4. 'Relevancy'


  The estimation is made with an LLM judge (we used '`command-r`', but other models perform similarly here).
  The scripts we used for each of the four metrics are from [this repository](https://github.com/microsoft/promptflow/tree/main/examples/flows/evaluation/eval-summarization).



  In addition to the other metrics, we also estimated how much a given summary agrees with texts from its origin compared to texts from other clusters.

  In order to estimate this metric, for each cluster we sampled texts from within and from outside it, then sent them with a specially designed prompt to an LLM judge (we used '`command-r`' here as well).

  <img src="https://github.com/user-attachments/assets/c1d93f94-d081-4a8d-97a2-919c8c810ad3" alt="0" width="600px">


  <img src="https://github.com/user-attachments/assets/a6be5c2f-b1a4-4dd3-b792-1662560bc237" alt="composite material" width="600px">


