# packages

pkgId: d55471693c2f478b449bb2f39bb98ffd4ba3161a719f7cb698ded17ee894fd12
name: python-rustimport-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for rustimport
url: https://github.com/mityax/rustimport
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rustimport-1.6.0-1.src.rpm
location_href: Packages/python-rustimport-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align=center>
      <a target="_blank" href="https://www.python.org/downloads/" title="Python version"><img src="https://img.shields.io/badge/python-%3E=_3.8-green.svg" /></a>
      <a target="_blank" href="https://pypi.org/project/rustimport/" title="PyPI version"><img src="https://img.shields.io/pypi/v/rustimport?logo=pypi" /></a>
      <a target="_blank" href="https://pypi.org/project/rustimport/" title="PyPI version"><img src="https://img.shields.io/pypi/dm/rustimport" /></a>
      <a target="_blank" href="LICENSE" title="License: MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg" /></a></a>
  </p>

  Arguably the simplest way to use rust from python – no manual compilation step, setup work or binding code required. rustimport provides a simple CLI, makes sure the compiled extension stays up to date with your source code and supports IPython/Jupyter notebooks.

  <i>rustimport was heavily inspired by and is partly based upon [cppimport](https://github.com/tbenthompson/cppimport). Check it out if you're interested in similar functionality for C and C++!</i>



  Install with `pip install rustimport`.



  Save the Rust code below as `somecode.rs`.
  ```rust
  // rustimport:pyo3

  use pyo3::prelude::*;


  fn square(x: i32) -> i32 {
      x * x
  }
  ```

  Then open a Python interpreter and import the Rust extension:

  ```python
  >>> import rustimport.import_hook
  >>> import somecode  # This will pause for a moment to compile the module
  >>> somecode.square(9)
  81
  ```

  Hurray, you've called some Rust code from Python using a combination of `rustimport` and [`pyo3`](https://github.com/PyO3/pyo3)

  This workflow enables you to edit both Rust files and Python and recompilation happens automatically and transparently! It's also handy for quickly whipping together an optimized version of a slow Python function.



  To easily create a new single-file extension (like above), or a complete crate, use the provided tool:
  ```bash
  $ python3 -m rustimport new my_single_file_extension.rs

  $ python3 -m rustimport new my_crate
  ```

  And import it from Python:
  ```python
  >>> import rustimport.import_hook
  >>> import my_single_file_extension, my_crate
  >>> my_single_file_extension.say_hello()
  Hello from my_single_file_extension, implemented in Rust!
  >>> my_crate.say_hello()
  Hello from my_crate, implemented in Rust!
  ```

  Smooth!

  The CLI can also be used to pre-compile your rust code for production so you don't have to have the rust toolchain on your production environments – see [below](#usage-in-production) for more.



  Okay, now that I've hopefully convinced you on how exciting this is, let's get into the details of how to do this yourself. First, the comment at top is essential to opt in to rustimport. Don't forget this! (See below for an explanation of why this is necessary.)
  ```rust
  // rustimport:pyo3
  ```

  The bulk of the file is a generic, simple [pyo3](https://github.com/PyO3/pyo3) extension. We use the `pyo3` crate, then define a simple function that squares `x`, and rustimport takes care of exporting that function as part of a Python extension called `somecode`.



  rustimport offers several layers of customization. This is archieved through a simple pre-processor and templates (well, the only existing template at the moment is `pyo3` - pull requests welcome :D).


  The first example in this Readme is the simplest possible form of using rustimport. You just tell rustimport to use the `pyo3` template by writing `rustimport:pyo3` in the first line, and define a function annotated with `pyo3`'s `#[pyfunction]` macro. In the background, rustimport handled a lot of stuff for you:

  1. It set up a minimalistic folder structure for a rust crate with your source code in a temporary location.
  2. It generated a Cargo.toml file with the basic configuration for pyo3 and your extension:
  ```toml
  [package]
  name = "somecode"
  version = "0.1.0"
  edition = "2021"

  [lib]
  name = "somecode"
  crate-type = [ "cdylib",]

  [dependencies.pyo3]
  version = "0.16.2"
  features = [ "extension-module",]
  ```
  3. It generated a code block exporting your method and appended it to the end of your file:
  ```rust

  fn somecode(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(square, m)?)?;
    Ok(())
  }
  ```


  You can do all the above yourself. rustimport will detect that and only fill in the missing parts to make your extension work.


  For example, to add additional contents to the generated `Cargo.toml` file, use the special `//:` comment syntax at the top of your `.rs` file:
  ```rust
  // rustimport:pyo3

  // Set the library's version and add a dependency:
  //: [package]
  //: version = "1.2.3"
  //:
  //: [dependencies]
  //: rand = "0.8.5"

  use rand::Rng;


  fn myfunc() {
      println!("{}", rand::thread_rng().gen_range(0..10))
  }
  ```


  To track additional files for changes, use the special `//d:` comment syntax:
  ```rust
  //d: ../other-folder/somefile.rs
  //d: ../*.rs
  //d: ./my-directory/**/*.json

  // --snip--
  ```
  rustimport will now track files matching these patterns too and re-compiles your extension if any of them changes.


  If you write a more complex extension, it's preferrable to just create a normal Rust crate:
  ```bash
  $ python3 -m rustimport new my_crate
  $ tree my_crate
  my_crate
  ├── Cargo.toml
  ├── .rustimport
  └── src
      └── lib.rs
  ```

  The crate contains all necessary configuration to be directly be imported by rustimport and also some additional explanations on how to configure manually.


  rustimport exposed most of it's settings via environment variables. This can be pretty handy in development but also in production environments.

  For example, to force recompilation, just run your script like this:
  ```commandline
  RUSTIMPORT_FORCE_REBUILD=true python my_script.py
  ```

  Or to instruct the compiler to optimize binaries (for example to examine the real performance boost rust gives you) run it like this:
  ```commandline
  RUSTIMPORT_RELEASE_BINARIES=true python my_script.py
  ```

  Take a look at [settings.py](./rustimport/settings.py) for all available environment variables.



  `rustimport` supports compiling code in a Jupyter notebook. To enable this feature load the `rustimport`
  extension from within the Jupyter notebook:

  ```python
  %load_ext rustimport
  ```

  Then, prefix a cell with the `%rustimport` marker to compile it:

  ```rust
  %rustimport
  use pyo3::prelude::*;


  fn square(x: i32) -> i32 {
      x * x
  }
  ```

  `%rustimport` supports release mode and force compilation with flags:

  ```rust
  %rustimport --release --force
  ...
  ```



  In production deployments you usually don't want to include the Rust toolchain, all the sources and compile at runtime. Therefore, a simple cli utility for pre-compiling all source files is provided. This utility may, for example, be used in CI/CD pipelines.

  Usage is as simple as

  ```commandline
  python -m rustimport build --release
  ```

  This will build a release-optimized binary for all `*.rs` files and Rust crates in the current directory (and it's subdirectories) if they are eligible to be imported (i.e. contain the `// rustimport` comment in the first line or a `.rustimport` file in case of a crate).

  Alternatively, you may specifiy one or more root directories or source files to be built:

  ```commandline
  python -m rustimport build --release ./my/root/folder/ ./my/single/file.rs ./my/crate/
  ```
  _Note: When specifying a path to a file, the header check (`// rustimport`) is skipped for that file._


  To further improve startup performance for production builds, you can opt-in to skip the checksum and compiled binary existence checks during importing by either setting the environment variable `RUSTIMPORT_RELEASE_MODE` to `true` or setting the configuration from within Python:
  ```python
  rustimport.settings.release_mode = True
  ```
  This essentially just disables the import hook and uses the standard python utilities to import the pre-compiled binary.

  **Warning:** Make sure to have all binaries pre-compiled with when in release mode, as importing any missing ones will cause exceptions.

  In case you would, for whatever reason, like the binaries to be checked and built in production too, set `rustimport.settings.compile_release_binaries` to `True` to use release-optimized binaries.





  Sometimes Python just isn't fast enough. Or you have existing code in a Rust crate. So, you write a Python *extension module*, a library of compiled code. I recommend [pyo3](https://github.com/PyO3/pyo3) for Rust to Python bindings.

  I discovered that my productivity is slower when my development process goes from *Edit -> Test* in just Python to *Edit -> Compile -> Test* in Python plus Rust. So, `rustimport` combines the process of compiling and importing an extension in Python so that you can just run `import foobar` and not have to worry about multiple steps. Internally, `rustimport` looks for a file `foobar.rs` or a Rust crate (discovered through `foobar/Cargo.toml`). Assuming one is found, the comments at it's beginning are parsed for either a template (`rustimport:pyo3`) or a cargo manifest, then it's compiled and loaded as an extension module.


  No! Compilation should only happen the first time the module is imported. The Rust source is compared with a checksum on each import to determine if any relevant file has changed. Additional dependencies can be tracked by adding to the header comments:

  ```rust
  //d: ../myothercrate/**/*.rs
  //d: ../myothercrate/Cargo.toml
  ```

  By default, rustimport tracks all `*.rs` files as well as `Cargo.toml` and `Cargo.lock` for crates and no additional dependencies for single-file Rust extensions.


  `rustimport` uses the standard Python logging tools. Thus, you can enable logging like this:

  ```python
  import logging
  logging.basicConfig(level=logging.DEBUG)  # or logging.INFO for a bit less verbosity

  ```


  To create release-optimized binaries, set

  ```python
  rustimport.settings.compile_release_binaries = True
  ```
  Or set the environment variable `RUSTIMPORT_RELEASE_BINARIES` to `true`

  Compilation might be a little bit slower now due to rust's optimization mechanisms, but at runtime the extension is significantly faster in most cases.



  Set:
  ```python
  rustimport.settings.force_rebuild = True
  ```
  Or set the environment variable `RUSTIMPORT_FORCE_REBUILD` to `true`

  And if this is a common occurrence, I would love to hear your use case and why the normal dependency tracking is insufficient!


  Sure! Though I recommend using `pyo3` due to it's simplicity, you're completely free to use any other library, for example [`rust-cpython`](https://github.com/dgrunwald/rust-cpython).

  There is an example using `rust-cpython` in [examples/doublecount.rs](./examples/doublecount.rs)



  Compilation happens incrementally by default. That is, the first compilation might take a bit, but subsequent ones are usually much faster.

  rustimport uses a temporary directory for caching, which is deleted after a reboot on most systems. Therefore it might be beneficial for you to set a custom cache directory to have a more permanent cache:

  ```python
  rustimport.settings.cache_dir = os.path.realpath("./.rust-cache")
  ```
  Or - you guessed it - use the `RUSTIMPORT_CACHE_DIR` environment variable.

  If this directory doesn't exist, it will be created automatically by rustimport.


  Yes, macOS is supported. No additional config should be necessary for pyo3 as the [required linker args](https://pyo3.rs/v0.17.1/building_and_distribution.html#macos) are set automatically by rustimport.


  Modifying the Python import system is a global modification and thus affects all imports from any other package. As a result, when `cppimport` was first implemented, other packages (e.g. `scipy`) suddenly started breaking because import statements internal to those packages were importing C or C++ files instead of the modules they were intended to import. To avoid this failure mode, the import hook uses an "opt in" system where C and C++ files can specify they are meant to be used with cppimport by having a comment on the first line that includes the text "cppimport".

  rustimport has adopted from this and follows the same pattern. Since rustimport also supports importing whole crates, an additional mechanism was necessary to make that work in the same fashion: You can either create a `.rustimport` file in the crate's root folder (next to `Cargo.toml`) or, alternatively, add a `# rustimport` comment to `Cargo.toml`s first line.

  As an alternative to the import hook, you can use `imp` or `imp_from_path`. The `rustimport.imp` and `rustimport.imp_from_path` performs exactly the same operation as the import hook but in a slightly more explicit way:
  ```python
  foobar = rustimport.imp("foobar")
  foobar = rustimport.imp_from_path("./some/path/foobar.rs")
  mycrate = rustimport.imp_from_path("./mycrate/")
  ```
  By default, these explicit function do not require the "rustimport" keyword on the first line of the .rs source file or the according marker in the crate.



  See [CONTRIBUTING.md](CONTRIBUTING.md) for details on the internals of `rustimport` and how to get involved in development.


  rustimport uses the MIT License.


pkgId: 7d1234ef29e8c2eb6ecd4bccb4369acf09466116ea138fec882942829dcf1fb1
name: python-rvc-inferpy-help
arch: noarch
version: 0.5.6
epoch: 0
release: 1
summary: Development documents and examples for rvc-inferpy
url: https://pypi.org/project/rvc-inferpy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rvc-inferpy-0.5.6-1.src.rpm
location_href: Packages/python-rvc-inferpy-help-0.5.6-1.noarch.rpm
checksum_type: sha256
description:
  > [!NOTE]
   > This project is still under development.</a>.


  [![PyPI version](https://badge.fury.io/py/rvc-inferpy.svg)](https://badge.fury.io/py/rvc-inferpy)

  `rvc_inferpy` is a Python library for performing audio inference with RVC (Retrieval-based Voice Conversion). It provides a simple command-line interface (CLI) and can be integrated into Python projects for audio processing with customizable parameters.



  You can install the package using `pip`:

  ```bash
  pip install rvc-inferpy
  ```





  You can interact with `rvc_inferpy` through the command line. To view the available options and how to use the tool, run:

  ```bash
  rvc-infer -h
  ```

  Here’s a breakdown of the full command-line options:

  ```bash
  usage: rvc-infer [-h] [--model_name MODEL_NAME] [--audio_path AUDIO_PATH]
                   [--f0_change F0_CHANGE] [--f0_method F0_METHOD]
                   [--min_pitch MIN_PITCH] [--max_pitch MAX_PITCH]
                   [--crepe_hop_length CREPE_HOP_LENGTH] [--index_rate INDEX_RATE]
                   [--filter_radius FILTER_RADIUS] [--rms_mix_rate RMS_MIX_RATE]
                   [--protect PROTECT] [--split_infer] [--min_silence MIN_SILENCE]
                   [--silence_threshold SILENCE_THRESHOLD] [--seek_step SEEK_STEP]
                   [--keep_silence KEEP_SILENCE] [--do_formant] [--quefrency QUEFRENCY]
                   [--timbre TIMBRE] [--f0_autotune] [--audio_format AUDIO_FORMAT]
                   [--resample_sr RESAMPLE_SR] [--hubert_model_path HUBERT_MODEL_PATH]
                   [--rmvpe_model_path RMVPE_MODEL_PATH] [--fcpe_model_path FCPE_MODEL_PATH]
  ```


  - `-h, --help`: Show help message and exit.
  - `--model_name MODEL_NAME`: Name or path of the model.
  - `--audio_path AUDIO_PATH`: Path to the input audio file.
  - `--f0_change F0_CHANGE`: Pitch change factor.
  - `--f0_method F0_METHOD`: Method for F0 estimation (e.g., "crepe").
  - `--min_pitch MIN_PITCH`: Minimum pitch value.
  - `--max_pitch MAX_PITCH`: Maximum pitch value.
  - `--crepe_hop_length CREPE_HOP_LENGTH`: Crepe hop length.
  - `--index_rate INDEX_RATE`: Index rate.
  - `--filter_radius FILTER_RADIUS`: Filter radius.
  - `--rms_mix_rate RMS_MIX_RATE`: RMS mix rate.
  - `--protect PROTECT`: Protect factor to avoid distortion.
  - `--split_infer`: Enable split inference.
  - `--min_silence MIN_SILENCE`: Minimum silence duration (in seconds).
  - `--silence_threshold SILENCE_THRESHOLD`: Silence threshold in dB.
  - `--seek_step SEEK_STEP`: Step size for silence detection.
  - `--keep_silence KEEP_SILENCE`: Duration to keep silence (in seconds).
  - `--do_formant`: Enable formant processing.
  - `--quefrency QUEFRENCY`: Quefrency adjustment.
  - `--timbre TIMBRE`: Timbre adjustment factor.
  - `--f0_autotune`: Enable automatic F0 tuning.
  - `--audio_format AUDIO_FORMAT`: Desired output audio format (e.g., "wav", "mp3").
  - `--resample_sr RESAMPLE_SR`: Resample sample rate.
  - `--hubert_model_path HUBERT_MODEL_PATH`: Path to Hubert model.
  - `--rmvpe_model_path RMVPE_MODEL_PATH`: Path to RMVPE model.
  - `--fcpe_model_path FCPE_MODEL_PATH`: Path to FCPE model.



  ```bash
  rvc-infer --model_name "model_name_here" --audio_path "path_to_audio.wav" --f0_change 0 --f0_method "crepe" --min_pitch 50 --max_pitch 800
  ```



  You can also use `rvc_inferpy` directly in your Python projects. Here's an example:

  ```python
  from rvc_inferpy import infer_audio

  inferred_audio = infer_audio(
      MODEL_NAME="model_name_here",       # Name or path to the RVC model
      SOUND_PATH="path_to_audio.wav",     # Path to the input audio file
      F0_CHANGE=0,                        # Change in fundamental frequency
      F0_METHOD="crepe",                  # F0 extraction method ("crepe", "dio", etc.)
      MIN_PITCH=50,                       # Minimum pitch value
      MAX_PITCH=800,                      # Maximum pitch value
      CREPE_HOP_LENGTH=128,               # Hop length for Crepe
      INDEX_RATE=1.0,                     # Index rate for model inference
      FILTER_RADIUS=3,                    # Radius for smoothing filters
      RMS_MIX_RATE=0.75,                  # Mixing rate for RMS
      PROTECT=0.33,                       # Protect level to prevent overfitting
      SPLIT_INFER=True,                   # Whether to split audio for inference
      MIN_SILENCE=0.5,                    # Minimum silence duration for splitting
      SILENCE_THRESHOLD=-40,              # Silence threshold in dB
      SEEK_STEP=10,                       # Seek step in milliseconds
      KEEP_SILENCE=0.1,                   # Keep silence duration in seconds
      QUEFRENCY=0.0,                      # Cepstrum quefrency adjustment
      TIMBRE=1.0,                         # Timbre preservation level
      F0_AUTOTUNE=False,                  # Enable or disable F0 autotuning
      OUTPUT_FORMAT="wav"                 # Desired output format (e.g., "wav", "mp3")
  )
  ```

  The `infer_audio` function will return the processed audio object based on the provided parameters.



  Ensure that you upload your models in the `models/{model_name}` folder.



  - **IAHispano's Applio**: Base of this project.
  - **RVC-Project**: Original RVC repository.



  This project is licensed under the [MIT License](https://github.com/TheNeodev/rvc_inferpy/tree/main#).


pkgId: a128a11695aa2d97a846040931a1cb2369a4586958a27a7ee803954be336194c
name: python-rwoka-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for rwoka
url: https://github.com/marryqueen2024/intranetflow
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rwoka-0.1.3-1.src.rpm
location_href: Packages/python-rwoka-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  **IntraNetFlow** is a Python package that simplifies HTTP requests, multi-threaded URL handling, and package installation from GitHub sources. It is designed to be efficient, easy-to-use, and integrate seamlessly into your projects.

  This package is particularly useful for automating HTTP requests (GET and POST) and installing Python packages directly from GitHub releases.



  - **HTTP Request Handling**:
    - Perform GET and POST requests easily.
    - Support for single and multiple URLs with threading for enhanced performance.

  - **GitHub Package Installation**:
    - Install Python packages directly from GitHub using a predefined or custom source URL.
    - URL validation ensures security and prevents malicious downloads.

  - **Internet Connection Check**:
    - Check for active internet connectivity before initiating downloads or requests.



  ```
  from IntraNetFlow import IntraNetFlow, PackageManager

  ```



  ```
  response = IntraNetFlow.get("https://example.com")
  print(response.text)

  ```

  ```
  urls = ["https://example.com", "https://example.org"]
  responses = IntraNetFlow.get(urls)
  for response in responses:
      print(f"{response.url}: {response.status_code}")

  ```


  ```
  response = IntraNetFlow.post("https://example.com/api", data={"key": "value"})
  print(response.text)
  ```


  Default GitHub Source
  By default, the package installs from a predefined GitHub URL:

  ```
  pm = PackageManager()
  pm.install()
  ```


  You can install this package from PyPI:

  ```bash
  pip install rwoka
  ```


pkgId: 8a8aff8dc5044223745e0a8e005a0538e2f04209b2a134b770dcf78602db2271
name: python-rx-data-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for rx-data
url: https://pypi.org/project/rx-data/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-rx-data-0.0.4-1.src.rpm
location_href: Packages/python-rx-data-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains:

  - Versioned lists of LFNs
  - Utilities to download them and link them into a tree structure

  for all the $R_X$ like analyses.



  To install this project run:

  ```bash
  pip install rx_data



  pip install --upgrade rx_data
  ```

  The download would require a grid proxy, which can be made with:

  ```bash
  . /cvmfs/lhcb.cern.ch/lib/LbEnv


  lhcb-proxy-init -v 100:00
  ```



  In order to see what triggers are present in the current version of the ntuples do:

  ```bash
  list_triggers -v v1


  list_triggers -v v1 -o triggers.yaml
  ```



  For this, run:

  ```bash
  download_rx_data -m 5 -p /path/to/downloaded/.data -v v1 -d -t triggers.yaml
  ```

  which will use 5 threads to download the ntuples associated to the triggers in `triggers.yaml`
  and version `v1` to the specified path.

  **IMPORTANT**: In order to prevent deleting the data, save it in a hiden folder, e.g. one starting with a period.
  Above it is `.data`.



  All the ntuples will be downloaded in a single directory.
  In order to group them by sample and trigger run:

  ```bash
  make_tree_structure -i /path/to/downloaded/.data/v1 -o /path/to/directory/structure
  ```

  this will not make a copy of the ntuples, it will only create symbolic links to them.


pkgId: fef1302e3970faf3d0e3e63e89ddea9f56da15217a2c97f89625b58efd5edfe4
name: python-s3dict-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for s3dict
url: https://pypi.org/project/s3dict/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-s3dict-0.1.0-1.src.rpm
location_href: Packages/python-s3dict-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
      pip install s3dict



      import boto3
      import s3dict
      s3dict.enable()

      
      bucket = boto3.resource("s3").Bucket('s3dict-test')

      
      bucket['hello'] = 'world'
      bucket['hola'] = 'mundo'

      for k, v in bucket.items():
          print(f'{k} -> {v}')

      del bucket['hello']



  Just for curiosity. `bucket[k] = v` is easier than `bucket.put_object(Key=k, Body=pickle.dumps(v))` right? :)

  Please let us know if you found a real use case.



  - Buckets are not ordered like Python dictionaries are ordered (by insertion order).
  - `len(bucket)` runs O(N) - it lists bucket objects and counts.
  - `popitem()` returns an arbitrary item (since unordered).
  - `keys()` and `values()` are iterators, not [views](https://www.codeguage.com/courses/python/dictionaries-views).
  - Dictionary keys must be `str`. They cannot be too long (underlying S3 key may not be >1024 chars).
  - Dictionary values must be serializable (Pickle by default, you can bring your own serialization / "codec").



  They are welcome. TODOs offers some ideas.


pkgId: c5c5f89c216156a4cd6ee5c0080387bec4b13d098d1bda902d2268497b9bfdeb
name: python-s3p-sdk-help
arch: noarch
version: 0.2.8
epoch: 0
release: 1
summary: Development documents and examples for s3p-sdk
url: https://github.com/CuberHuber/S3P-SDK
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-s3p-sdk-0.2.8-1.src.rpm
location_href: Packages/python-s3p-sdk-help-0.2.8-1.noarch.rpm
checksum_type: sha256
description:
  ```shell
  pip install s3p-sdk
  ```


  1. [Конфигурация](docs/config.md)
  2. [Логика](docs/payload.md)
  3. [Сборшик](docs/source-plugin)


  Официально пакет представлен в [пакетном репозитории python](https://pypi.org/project/s3p-sdk/)


pkgId: e94e411affc9561f4677cf8256a7a4517befcafd314897b8042be860a7c17aa8
name: python-s6r-odoo-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for s6r-odoo
url: https://github.com/ScalizerOrg/s6r-odoo
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-s6r-odoo-2.0.1-1.src.rpm
location_href: Packages/python-s6r-odoo-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
      pip install s6r-odoo
  ```



  ```python
  from s6r_odoo import OdooConnection

  odoo = OdooConnection(url='http://odoo.localhost',
                            dbname='odoo',
                            user='admin',
                            password='admin')
  res_partner = odoo.model('res.partner')
  partner_ids = res_partner.search([],  fields=['name', 'email'])
  for partner_id in partner_ids:
      print(f'{partner_id.name} : {partner_id.email}')
  ```



  This project is licensed under the [GNU Lesser General Public License (LGPL) Version 3](https://www.gnu.org/licenses/lgpl-3.0.html).




  Contributions are welcome! If you find any issues or have suggestions for improvements,
  please open an issue or submit a pull request.

  - GitHub Repository: [ScalizerOrg/s6r-odoo](https://github.com/ScalizerOrg/s6r-odoo)



  * David Halgand - [GitHub](https://github.com/halgandd)
  * Michel Perrocheau - [GitHub](https://github.com/myrrkel)




  This software is maintained by [Scalizer](https://www.scalizer.fr).


  <div style="text-align: center;">

  [![Scaliser](./logo_scalizer.png)](https://www.scalizer.fr)

  </div>

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


pkgId: 728a786c99b829ddf4f403f4a89ca382bc611bbc3a93a1c4de6ea2a2455fea46
name: python-sae-lens-help
arch: noarch
version: 5.2.1
epoch: 0
release: 1
summary: Development documents and examples for sae-lens
url: https://jbloomaus.github.io/SAELens
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sae-lens-5.2.1-1.src.rpm
location_href: Packages/python-sae-lens-help-5.2.1-1.noarch.rpm
checksum_type: sha256
description:
  <img width="1308" alt="Screenshot 2024-03-21 at 3 08 28 pm" src="https://github.com/jbloomAus/mats_sae_training/assets/69127271/209012ec-a779-4036-b4be-7b7739ea87f6">


  [![PyPI](https://img.shields.io/pypi/v/sae-lens?color=blue)](https://pypi.org/project/sae-lens/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![build](https://github.com/jbloomAus/SAELens/actions/workflows/build.yml/badge.svg)](https://github.com/jbloomAus/SAELens/actions/workflows/build.yml)
  [![Deploy Docs](https://github.com/jbloomAus/SAELens/actions/workflows/deploy_docs.yml/badge.svg)](https://github.com/jbloomAus/SAELens/actions/workflows/deploy_docs.yml)
  [![codecov](https://codecov.io/gh/jbloomAus/SAELens/graph/badge.svg?token=N83NGH8CGE)](https://codecov.io/gh/jbloomAus/SAELens)

  SAELens exists to help researchers:
  - Train sparse autoencoders.
  - Analyse sparse autoencoders / research mechanistic interpretability.
  - Generate insights which make it easier to create safe and aligned AI systems.

  Please refer to the [documentation](https://jbloomaus.github.io/SAELens/) for information on how to:
  - Download and Analyse pre-trained sparse autoencoders.
  - Train your own sparse autoencoders.
  - Generate feature dashboards with the [SAE-Vis Library](https://github.com/callummcdougall/sae_vis/tree/main).

  SAE Lens is the result of many contributors working collectively to improve humanity's understanding of neural networks, many of whom are motivated by a desire to [safeguard humanity from risks posed by artificial intelligence](https://80000hours.org/problem-profiles/artificial-intelligence/).

  This library is maintained by [Joseph Bloom](https://www.jbloomaus.com/) and [David Chanin](https://github.com/chanind).



  Pre-trained SAEs for various models can be imported via SAE Lens. See this [page](https://jbloomaus.github.io/SAELens/sae_table/) in the readme for a list of all SAEs.


  - [SAE Lens + Neuronpedia](tutorials/tutorial_2_0.ipynb)[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/jbloomAus/SAELens/blob/main/tutorials/tutorial_2_0.ipynb)
  - [Loading and Analysing Pre-Trained Sparse Autoencoders](tutorials/basic_loading_and_analysing.ipynb)
   [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/jbloomAus/SAELens/blob/main/tutorials/basic_loading_and_analysing.ipynb)
   - [Understanding SAE Features with the Logit Lens](tutorials/logits_lens_with_features.ipynb)
   [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/jbloomAus/SAELens/blob/main/tutorials/logits_lens_with_features.ipynb)
    - [Training a Sparse Autoencoder](tutorials/training_a_sparse_autoencoder.ipynb)
   [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/jbloomAus/SAELens/blob/main/tutorials/training_a_sparse_autoencoder.ipynb)




  Feel free to join the [Open Source Mechanistic Interpretability Slack](https://join.slack.com/t/opensourcemechanistic/shared_invite/zt-2k0id7mv8-CsIgPLmmHd03RPJmLUcapw) for support!




  Please cite the package as follows:

  ```
  @misc{bloom2024saetrainingcodebase,
     title = {SAELens},
     author = {Joseph Bloom, Curt Tigges and David Chanin},
     year = {2024},
     howpublished = {\url{https://github.com/jbloomAus/SAELens}},
  }
  ```


pkgId: a259f9391e16a18c9ae64a81badae7e406376e33126d372122c9b858644d8d40
name: python-sae-vis-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for sae-vis
url: https://pypi.org/project/sae-vis/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sae-vis-0.3.1-1.src.rpm
location_href: Packages/python-sae-vis-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  This codebase was designed to replicate Anthropic's sparse autoencoder visualisations, which you can see [here](https://transformer-circuits.pub/2023/monosemantic-features/vis/a1.html). The codebase provides 2 different views: a **feature-centric view** (which is like the one in the link, i.e. we look at one particular feature and see things like which tokens fire strongest on that feature) and a **prompt-centric view** (where we look at once particular prompt and see which features fire strongest on that prompt according to a variety of different metrics).
  Install with `pip install sae-vis`. Link to PyPI page [here](https://pypi.org/project/sae-vis/).
  See [here](https://colab.research.google.com/drive/1SuoFIjLvzOAuSg1nkqNbtkwXr8EvQ7SY?usp=drive_link) for a demo Colab notebook (all the code to produce it is also in this repo, in the file `sae_vis/demos/demo.py`, as well as the files containing the created visualizations).
  The library supports two types of visualizations:
  1. **Feature-centric vis**, where you look at a single feature and see e.g. which sequences in a large dataset this feature fires strongest on.
  <img src="https://raw.githubusercontent.com/callummcdougall/computational-thread-art/master/example_images/misc/feature-vis-video.gif" width="800">
  2. **Prompt-centric vis**, where you input a custom prompt and see which features score highest on that prompt, according to a variety of possible metrics.
  <img src="https://raw.githubusercontent.com/callummcdougall/computational-thread-art/master/example_images/misc/prompt-vis-video.gif" width="800">

  To cite this work, you can use this bibtex citation:
  ```
  @misc{sae_vis,
      title  = {{SAE Visualizer}},
      author = {Callum McDougall},
      howpublished    = {\url{https://github.com/callummcdougall/sae_vis}},
      year   = {2024}
  }
  ```

  This project is uses [Poetry](https://python-poetry.org/) for dependency management. After cloning the repo, install dependencies with `poetry install`.
  This project uses [Ruff](https://docs.astral.sh/ruff/) for formatting and linting, [Pyright](https://github.com/microsoft/pyright) for type-checking, and [Pytest](https://docs.pytest.org/) for tests. If you submit a PR, make sure that your code passes all checks. You can run all checks with `make check-all`.

  - `0.2.9` - added table for pairwise feature correlations (not just encoder-B correlations)
  - `0.2.10` - fix some anomalous characters
  - `0.2.11` - update PyPI with longer description
  - `0.2.12` - fix height parameter of config, add videos to PyPI description
  - `0.2.13` - add to dependencies, and fix SAELens section
  - `0.2.14` - fix mistake in dependencies
  - `0.2.15` - refactor to support eventual scatterplot-based feature browser, fix `&rsquo;` HTML
  - `0.2.16` - allow disabling buffer in feature generation, fix demo notebook, fix sae-lens compatibility & type checking
  - `0.2.17` - use main branch of `sae-lens`
  - `0.2.18` - remove circular dependency with `sae-lens`
  - `0.2.19` - formatting, error-checking
  - `0.2.20` - fix bugs, remove use of `batch_size` in config
  - `0.2.21` - formatting
  - `0.3.0` - major refactor which makes several improvements, removing complexity and adding new features:
      - OthelloGPT SAEs with linear probes (input / output space)
      - Attention output SAEs with max DFA visualized
      - Tokens labelled with their `(batch, seq)` indices as well as the change in correct-token probability on feature ablation, when hovered over


pkgId: fc2d0d29898676f6fa835fa7f6e0b89bf4cc39bf59679bdc14a29a5e6cf6cd75
name: python-safe-eth-py-help
arch: noarch
version: 6.1.1
epoch: 0
release: 1
summary: Development documents and examples for safe-eth-py
url: https://github.com/safe-global/safe-eth-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-safe-eth-py-6.1.1-1.src.rpm
location_href: Packages/python-safe-eth-py-help-6.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Just run ``pip install safe-eth-py`` or add it to your **requirements.txt**
  If you want django ethereum utils (models, serializers, filters...) you need to run
  ``pip install safe-eth-py[django]``
  If you have issues building **coincurve** maybe
  `you are missing some libraries <https://ofek.dev/coincurve/install/#source>`_


pkgId: e1f2f7f56813d4e85cc8fcff01201c330dc9a9783ea5aecae96add220a01638a
name: python-safir-arq-help
arch: noarch
version: 9.1.0
epoch: 0
release: 1
summary: Development documents and examples for safir-arq
url: https://safir.lsst.io
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-safir-arq-9.1.0-1.src.rpm
location_href: Packages/python-safir-arq-help-9.1.0-1.noarch.rpm
checksum_type: sha256
description:
  safir-arq is a subpackage of Safir, Rubin Observatory's library for building [FastAPI](https://fastapi.tiangolo.com/) services for the [Rubin Science Platform (Phalanx)](https://github.com/lsst-sqre/phalanx) and [Roundtable](https://github.com/lsst-sqre/roundtable) Kubernetes clusters.
  It is a separate PyPI module so that it can be used as a dependency in contexts where the full Safir dependency is undesirable.

  safir-arq is available from [PyPI](https://pypi.org/project/safir-arq/):

  ```sh
  pip install safir-arq
  ```

  safir-arq is developed and tested in conjunction with Safir.
  Read more about Safir at https://safir.lsst.io.

rpm_license:
  MIT License  Copyright (c) 2020-2024 Association of Universities for Research in Astronomy, Inc. (AURA)  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: d5fdbfd3c5c7e85bca66ade2605a2638d772c17ba02c5bdf0f728e85d75ac4fc
name: python-safir-help
arch: noarch
version: 9.1.0
epoch: 0
release: 1
summary: Development documents and examples for safir
url: https://safir.lsst.io
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-safir-9.1.0-1.src.rpm
location_href: Packages/python-safir-help-9.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Safir is Rubin Observatory's library for building [FastAPI](https://fastapi.tiangolo.com/) services for the [Rubin Science Platform (Phalanx)](https://github.com/lsst-sqre/phalanx) and [Roundtable](https://github.com/lsst-sqre/roundtable) Kubernetes clusters.
  Safir is developed, maintained, and field tested by the SQuaRE team.

  Safir is available from [PyPI](https://pypi.org/project/safir/):

  ```sh
  pip install safir
  ```

  The best way to create a new FastAPI/Safir service is with the [`fastapi_safir_app` template](https://github.com/lsst/templates/blob/main/project_templates/fastapi_safir_app).

  Read more about Safir at https://safir.lsst.io.



  - Set up an `httpx.AsyncClient` as part of the application start-up and shutdown lifecycle.
  - Set up structlog-based logging.
  - Middleware for attaching request context to the logger to include a request UUID, method, and route in all log messages.
  - Process `X-Forwarded-*` headers to determine the source IP and related information of the request.
  - Gather and structure standard metadata about your application.
  - Operate a distributed Redis job queue with [arq](https://arq-docs.helpmanual.io) using convenient clients, testing mocks, and a FastAPI dependency.



  See https://safir.lsst.io/dev/development.html.

rpm_license:
  MIT License  Copyright (c) 2020-2024 Association of Universities for Research in Astronomy, Inc. (AURA)  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: dd47197237af22135bfce3bf3e0f4428625d8b4b93e1d44986bad3e2619ea78a
name: python-safir-logging-help
arch: noarch
version: 9.1.0
epoch: 0
release: 1
summary: Development documents and examples for safir-logging
url: https://safir.lsst.io
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-safir-logging-9.1.0-1.src.rpm
location_href: Packages/python-safir-logging-help-9.1.0-1.noarch.rpm
checksum_type: sha256
description:
  safir-logging is a subpackage of Safir, Rubin Observatory's library for building [FastAPI](https://fastapi.tiangolo.com/) services for the [Rubin Science Platform (Phalanx)](https://github.com/lsst-sqre/phalanx) and [Roundtable](https://github.com/lsst-sqre/roundtable) Kubernetes clusters.
  It is a separate PyPI module so that it can be used as a dependency in contexts where the full Safir dependency is undesirable.

  safir-logging is available from [PyPI](https://pypi.org/project/safir-logging/):

  ```sh
  pip install safir-logging
  ```

  safir-logging is developed and tested in conjunction with Safir.
  Read more about Safir at https://safir.lsst.io.

rpm_license:
  MIT License  Copyright (c) 2020-2024 Association of Universities for Research in Astronomy, Inc. (AURA)  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: 5e7edd30dd564bcf00b2650ec572ad50a56d246faafdb92c0505db133b88ab2c
name: python-sage-flatsurf-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for sage-flatsurf
url: https://pypi.org/project/sage-flatsurf/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sage-flatsurf-0.7.1-1.src.rpm
location_href: Packages/python-sage-flatsurf-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="logo" src="https://github.com/flatsurf/sage-flatsurf/raw/master/doc/static/logo.svg?sanitize=true">
  </p>

  <h1><p align="center">sage-flatsurf</p></h1>

  sage-flatsurf is a Python package for working with flat surfaces in
  [SageMath](https://sagemath.org).

  We aim for sage-flatsurf to support the investigation of geometric, algebraic
  and dynamical questions related to flat surfaces. By flat surface we mean a
  surface modeled on the plane with monodromy given by similarities of the plane,
  though current efforts are focused on [translation
  surfaces](https://en.wikipedia.org/wiki/Translation_surface) and
  [half-translation
  surfaces](https://en.wikipedia.org/wiki/Translation_surface#Half-translation_surfaces).

  Take the [Tour of flatsurf](https://flatsurf.github.io/sage-flatsurf/examples/tour)
  to see some of the capabilities of sage-flatsurf.

  sage-flatsurf is free software, released under the [GPL v2 (or later)](./COPYING).

  We welcome any help to improve sage-flatsurf. If you would like to help, have
  ideas for improvements, or if you need any assistance in using sage-flatsurf,
  please don't hesitate to [contact us](https://flatsurf.github.io#contact).



  If you are on **Linux or macOS**, download the latest `.unix.tar.gz` file from our
  [Releases page](https://github.com/flatsurf/sage-flatsurf/releases).

  Extract it anywhere (make sure there are no spaces in the directory name) and
  run `./sage` or `./jupyterlab`.

  ```sh
  tar zxf sage-flatsurf-0.7.1.unix.tar.gz
  ./sage-flatsurf-0.7.1/jupyterlab  # or
  ./sage-flatsurf-0.7.1/sage
  ```

  If you are on **Windows**, download the latest `.exe` installer from our [Releases
  page](https://github.com/flatsurf/sage-flatsurf/releases).

  Please also consult [our
  documentation](https://flatsurf.github.io/sage-flatsurf/#installation) for
  other options and more detailed instructions.



  We recommend you install [pixi](https://pixi.sh) to provide all the
  dependencies for sage-flatsurf. Once installed, `git clone` this repository and
  then

  ```sh
  pixi run sage  # to run SageMath with your version of sage-flatsurf installed
  pixi run test  # to run the test suite
  pixi run lint  # to check for errors and formatting issues
  ```

  Please consult our [Developer's
  Guide](https://flatsurf.github.io/sage-flatsurf/developer.html) for more
  details.



  The main authors and current maintainers of sage-flatsurf are:

  * Vincent Delecroix (Bordeaux)
  * W. Patrick Hooper (City College of New York and CUNY Graduate Center)
  * Julian Rüth

  We welcome others to [contribute](https://flatsurf.github.io#contact).



  If you have used this project, please cite us as described [on our
  zenodo website](https://zenodo.org/badge/latestdoi/13970050).



  * sage-flatsurf was started during a thematic semester at
    [ICERM](https://icerm.brown.edu).
  * Vincent Delecroix's contribution to the project has been supported by
    OpenDreamKit, Horizon 2020 European Research Infrastructures project #676541.
  * W. Patrick Hooper's contribution to the project has been supported by the National
    Science Foundation under Grant Number DMS-1500965. Any opinions, findings,
    and conclusions or recommendations expressed in this material are those of
    the authors and do not necessarily reflect the views of the National Science
    Foundation.
  * Julian Rüth's contributions to this project have been supported by the Simons
    Foundation Investigator grant of Alex Eskin.


pkgId: 5c380491d5300a3b23cbd718e528938dc4a756d999559e86305daa10b2edb4f7
name: python-sageintacctsdk-help
arch: noarch
version: 1.25.1
epoch: 0
release: 1
summary: Development documents and examples for sageintacctsdk
url: https://github.com/fylein/sageintacct-sdk-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sageintacctsdk-1.25.1-1.src.rpm
location_href: Packages/python-sageintacctsdk-help-1.25.1-1.noarch.rpm
checksum_type: sha256
description:
  Python SDK to access Sage Intacct web services



  This project requires [Python 3+](https://www.python.org/downloads/) and [Requests](https://pypi.org/project/requests/) library (pip install requests).

  1. Download this project and use it (copy it in your project, etc).
  2. Install it from [pip](https://pypi.org).

          $ pip install sageintacctsdk



  To use this SDK you'll need these Sage Intacct credentials used for authentication: **sender ID**, **sender password**, **user ID**, **company ID** and **user password**.

  This SDK is very easy to use.
  1. First you'll need to create a connection using the main class SageIntacctSDK.
  ```python
  from sageintacctsdk import SageIntacctSDK

  connection = SageIntacctSDK(
      sender_id='<YOUR SENDER ID>',
      sender_password='<YOUR SENDER PASSWORD>',
      user_id='<YOUR USER ID>',
      company_id='<YOUR COMPANY ID>',
      user_password='<YOUR USER PASSWORD>'
  )
  ```
  2. After that you'll be able to access any of the 28 API classes: accounts, ap_payments, ar_invoices, ar_payments, attachments, bills, charge_card_accounts, charge_card_transactions, checking_accounts, classes, contacts, customers, departments, employees, expense_payment_types, expense_reports, expense_types, gl_detail, items, locations, order_entry_transactions, projects, reimbursements, revenue_recognition_schedules, revenue_recognition_schedule_entries, savings_accounts, tasks and vendors.
  ```python
  """
  USAGE: <SageIntacctSDK INSTANCE>.<API_NAME>.<API_METHOD>(<PARAMETERS>)
  """


  data = {
      'employeeid': 'E101',
      'datecreated': {
          'year': 2019,
          'month': 11,
          'day': 28
      },
      'state': 'Approved',
      'description': 'Team lunch',
      'expenses': {
          'expense': [
              {
                  'expensetype': 'Food',
                  'amount': 3800,
                  'expensedate': {
                      'year': 2019,
                      'month': 11,
                      'day': 28
                  }
              }
          ]
      }
  }
  response = connection.employees.post(data)


  response = connection.accounts.get_all()


  response = connection.employees.get(field='EMPLOYEEID', value='E101')
  ```


  Several methods of querying the Sage Inacct API exists within the SDK.  <get_by_query> allows you to specify multiple
  critera using textual mathematical operators and logical filters.

  Arguments are passed to and_filter, or_filter, or both.  The and_filter is the default operator to pass filters to.
  For example if you want to pass a single operator without a logical context you would pass it to and_filter.

  You must pass multiple operators to or_filter.

  You may also format your own filter payload in accordance with API documentation and pass to the function.

  See query structures here: https://developer.intacct.com/web-services/queries/

  Warning: Operators can only be used once in a given logical context. and_filter cannot accept multiple 'equalto' operators
  for example.  This is an API limitation.

  ```python


  print(connection.gl_detail.get_lookup())


  query_tuple_between = [('between','ENTRY_DATE',['01/01/2020','12/31/2020'])]
  fields = ['RECORDNO','ENTRY_DATE','BATCH_NO','ACCOUNTNO','DEBITAMOUNT']
  response = connection.gl_detail.get_by_query(fields=fields,and_filter=query_tuple_between)


  query_tuple_multiple =[('greaterthan','ACOUNTNO','6000'),('lessthan','ACCOUNTNO','7000')]
  response = connection.gl_detail.get_by_query(fields=fields,and_filter=query_tuple_multiple)


  in_list = ['1000','1100','1200']
  query_tuple_in = [('in','ACCOUNTNO',in_list)]
  response = connection.gl_detail.get_by_query(fields=fields,and_filter=query_tuple_in)

  payload = {'and':{'equalto':{'field':'ACCOUNTNO','value':'1000'}}}
  response = connnection.gl_detail.get_by_query(filter_payload=payload)

  ```

  See more details about the usage into the wiki pages of this project.



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


pkgId: fc92144f39cbb45061a11377ec41dc0e1bfde2deab4fb6eb83a4b098dc226fd1
name: python-sageworks-help
arch: noarch
version: 0.8.87
epoch: 0
release: 1
summary: Development documents and examples for sageworks
url: https://github.com/SuperCowPowers/sageworks
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sageworks-0.8.87-1.src.rpm
location_href: Packages/python-sageworks-help-0.8.87-1.noarch.rpm
checksum_type: sha256
description:
  Everyone knows that good data science requires... **Some Awesome Themes!**

  <table>
    <tr>
      <td>
        <a href="https://github.com/user-attachments/assets/82ab4eab-0688-4b93-ad8e-9b954564777b">
          <img width="400" alt="theme_dark" src="https://github.com/user-attachments/assets/82ab4eab-0688-4b93-ad8e-9b954564777b" />
        </a>
      </td>
      <td>
        <a href="https://github.com/user-attachments/assets/b63a0789-c144-4048-afb6-f03e3d993680">
          <img width="400" alt="theme_light" src="https://github.com/user-attachments/assets/b63a0789-c144-4048-afb6-f03e3d993680" />
        </a>
      </td>
    </tr>
    <tr>
      <td>
        <a href="https://github.com/user-attachments/assets/8a59be19-0c5d-42c6-9922-feafb1a1eecd">
          <img width="400" alt="theme_quartz" src="https://github.com/user-attachments/assets/8a59be19-0c5d-42c6-9922-feafb1a1eecd" />
        </a>
      </td>
      <td>
        <a href="https://github.com/user-attachments/assets/5b01ec64-8d56-43bf-96c5-7da8ec48f527">
          <img width="400" alt="theme_quartz_dark" src="https://github.com/user-attachments/assets/5b01ec64-8d56-43bf-96c5-7da8ec48f527" />
        </a>
      </td>
    </tr>
  </table>

  All of the Dashboard pages, subpages, and plugins use our new `ThemeManager()` class. See [SageWorks Themes](https://supercowpowers.github.io/sageworks/themes/), also big thanks to our friends at [Dash Bootstrap Templates](https://github.com/AnnMarieW/dash-bootstrap-templates)





  Powered by AWS® to accelerate your Machine Learning Pipelines development with our new [Dashboard for ML Pipelines](https://aws.amazon.com/marketplace/pp/prodview-5idedc7uptbqo). Getting started with SageWorks is a snap and can be billed through AWS.

  **Road Map: `v0.9.0`**

  We've used the feedback from our current beta testers to improve the framework and we've constructed a mini road map for the upcoming SageWorks version 0.9.0. Please see [SageWorks RoadMaps](https://supercowpowers.github.io/sageworks/road_maps/0_9_0/)


  The SageWorks framework makes AWS® both easier to use and more powerful. SageWorks handles all the details around updating and managing a complex set of AWS Services. With a simple-to-use Python API and a beautiful set of web interfaces, SageWorks makes creating AWS ML pipelines a snap. It also dramatically improves both the usability and visibility across the entire spectrum of services: Glue Job, Athena, Feature Store, Models, and Endpoints, SageWorks makes it easy to build production ready, AWS powered, machine learning pipelines.

  <img align="right" width="480" alt="sageworks_new_light" src="https://github.com/SuperCowPowers/sageworks/assets/4806709/ed2ed1bd-e2d8-49a1-b350-b2e19e2b7832">


  - Health Monitoring 🟢
  - Dynamic Updates
  - High Level Summary


  - Incoming Data
  - Glue Jobs
  - DataSources
  - FeatureSets
  - Models
  - Endpoints


  *Secure your Data, Empower your ML Pipelines*

  SageWorks is architected as a **Private SaaS** (also called BYOC: Bring Your Own Cloud). This hybrid architecture is the ultimate solution for businesses that prioritize data control and security. SageWorks deploys as an AWS Stack within your own cloud environment, ensuring compliance with stringent corporate and regulatory standards. It offers the flexibility to tailor solutions to your specific business needs through our comprehensive plugin support. By using SageWorks, you maintain absolute control over your data while benefiting from the power, security, and scalability of AWS cloud services. [SageWorks Private SaaS Architecture](https://docs.google.com/presentation/d/1f_1gmE4-UAeUDDsoNdzK_d_MxALFXIkxORZwbJBjPq4/edit?usp=sharing)

  <img alt="private_saas_compare" src="https://github.com/user-attachments/assets/2f6d3724-e340-4a70-bb97-d05383917cfe">



  - ```pip install sageworks```  Installs SageWorks

  - ```sageworks``` Runs the SageWorks REPL/Initial Setup

  For the full instructions for connecting your AWS Account see:

  - Getting Started: [Initial Setup](https://supercowpowers.github.io/sageworks/getting_started/)
  - One time AWS Onboarding: [AWS Setup](https://supercowpowers.github.io/sageworks/aws_setup/core_stack/)



  Even though SageWorks makes AWS easier, it's taking something very complex (the full set of AWS ML Pipelines/Services) and making it less complex. SageWorks has a depth and breadth of functionality so we've provided higher level conceptual documentation See: [SageWorks Presentations](https://supercowpowers.github.io/sageworks/presentations/)

  <img align="right" width="420" alt="sageworks_api" style="padding-left: 10px;"  src="https://github.com/SuperCowPowers/sageworks/assets/4806709/bf0e8591-75d4-44c1-be05-4bfdee4b7186">



  The SageWorks documentation [SageWorks Docs](https://supercowpowers.github.io/sageworks/) covers the Python API in depth and contains code examples. The documentation is fully searchable and fairly comprehensive.

  The code examples are provided in the Github repo `examples/` directory. For a full code listing of any example please visit our [SageWorks Examples](https://github.com/SuperCowPowers/sageworks/blob/main/examples)


  The SuperCowPowers team is happy to answer any questions you may have about AWS and SageWorks. Please contact us at [sageworks@supercowpowers.com](mailto:sageworks@supercowpowers.com) or chat us up on [Discord](https://discord.gg/WHAJuz8sw8)



  Using SageWorks will minimize the time and manpower needed to incorporate AWS ML into your organization. If your company would like to be a SageWorks Beta Tester, contact us at [sageworks@supercowpowers.com](mailto:sageworks@supercowpowers.com).




  ```
  pip install sageworks             # Installs SageWorks with Core Dependencies
  pip install 'sageworks[ml-tools]' # + Shap and NetworkX
  pip install 'sageworks[chem]'     # + RDKIT and Mordred (community)
  pip install 'sageworks[ui]'       # + Plotly/Dash
  pip install 'sageworks[dev]'      # + Pytest/flake8/black
  pip install 'sageworks[all]'      # + All the things :)

  *Note: Shells may interpret square brackets as globs, so the quotes are needed
  ```


  If you'd like to contribute to the SageWorks project, you're more than welcome. All contributions will fall under the existing project [license](https://github.com/SuperCowPowers/sageworks/blob/main/LICENSE). If you are interested in contributing or have questions please feel free to contact us at [sageworks@supercowpowers.com](mailto:sageworks@supercowpowers.com).

  <img align="right" src="docs/images/scp.png" width="180">

  ® Amazon Web Services, AWS, the Powered by AWS logo, are trademarks of Amazon.com, Inc. or its affiliates


pkgId: f2b553a3a7de80b86e7e3f04c41caebf9a7e1ce3b36e425f51c6456d3bf4c82f
name: python-saintess-help
arch: noarch
version: 0.4
epoch: 0
release: 1
summary: Development documents and examples for saintess
url: https://github.com/yourusername/saintess
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-saintess-0.4-1.src.rpm
location_href: Packages/python-saintess-help-0.4-1.noarch.rpm
checksum_type: sha256
description:
  Saintess is an official wrapper for Discord API that simplifies hybrid commands, guild/user checks, and mobile status integration.


  - Simplified Hybrid Commands with `@saintess`
  - Guild and User Context Checks using `@guild` and `@user`
  - Discord Mobile Status Wrapper


  ```bash
  pip install saintess


pkgId: 54688f5fc69cc155f91d8a2055c000f9abb08f0c69168c488cd0585be21a2ade
name: python-salientsdk-help
arch: noarch
version: 0.3.14
epoch: 0
release: 1
summary: Development documents and examples for salientsdk
url: https://salientpredictions.com
rpm_license: LicenseRef-Custom
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-salientsdk-0.3.14-1.src.rpm
location_href: Packages/python-salientsdk-help-0.3.14-1.noarch.rpm
checksum_type: sha256
description:
  The Salient SDK is a python convenience wrapper around Salient Predictions' customer-facing
  [web API](https://api.salientpredictions.com/v2/documentation/api/). It also contains utility functions for manipulating and analyzing the data delivered from the API.



  The Salient SDK is a Python package that depends on Python v3.11 and installs from [PyPI](https://pypi.org/project/salientsdk):

  ```bash
  python3 --version | grep -q '3.11' && echo "Py OK" || echo "Need Py 3.11"
  pip install salientsdk poetry --upgrade
  pip show salientsdk
  ```

  If you "need Py 3.11", follow the instructions in [Getting Python 3.11](#getting-python-311).

  The `install` will also get `poetry`, which `salientsdk` uses to manage dependencies.





  The Salient SDK contains a full command line interface that can access each of the primary
  API functions without even opening Python.

  ```bash

  salientsdk version

  salientsdk --help
  ```

  To verify that you can access Salient's API, use the limited `test*` credentials to log in. If you see errors or warnings relating to `VERIFY SSL` you may need to adjust your firewall settings.

  ```bash
  salientsdk login -u testusr -p testpwd


  ```

  To verify that you can download data from Salient, try these `testusr`/`testpwd` credentials to download historical data with the `data_timeseries` function. This will download a NetCDF file to your current directory and display its contents.

  ```bash
  salientsdk data_timeseries -fld all \
  -lat 42 -lon -73 \
  --start 2020-01-01 --end 2020-12-31 \
  -u testusr -p testpwd
  ```

  To test that your specific Salient-issued credentials are functioning properly, try them with the `forecast_timeseries` function. Replace `username` and `password` in the example below with your credentials. Note that you may need to change the location (North America) and timescale (seasonal) if your license does not include them.

  ```bash
  salientsdk forecast_timeseries --variable precip \
  -lat 42 -lon -73 \
  --timescale seasonal --date 2020-01-01 \
  -u username -p "password"
  ```



  The package ships with examples that show `salientsdk` in action. You can list the file locations and copy them to a working directory for use. Let's work with the `hindcast_summary` notebook example:

  ```bash
  mkdir salient_env && cd salient_env

  salientsdk examples

  salientsdk examples | grep "hindcast_summary" | xargs -I {} cp {} .
  ```

  `salientsdk` uses the `poetry` dependency manager to set up a virtual environment with all the dependencies needed to run the examples:

  ```bash

  rm -f pyproject.toml

  poetry init --no-interaction

  poetry add jupyter salientsdk@latest

  poetry run ipython kernel install --user --name="salient_env"

  poetry run jupyter notebook hindcast_summary.ipynb
  ```

  Once the hindcast_summary notebook launches in your browser:

  - If "salient env" is not already selected as a kernel:<br>
    Kernel > Change Kernel > salient_env > Select
  - Add your username/password credentials to the "login" step in the first cell:<br>
    `sk.login(<username>, <password>, verbose=False)`
  - The notebook assumes you are licenced for regions `north-america` and `europe`, and variables `temp` and `precip`. If you are not, change cell 2 to generate a request consistent with your licensing:<br>
    `loc=sk.Location(region=["<region1>", "<region2>"]),`<br>
    `variable=["<var1>", <var2>"],`
  - Run > Run All Cells
  - This will generate files in the `hindcast_summary_example` directory:<br>
    `hindcast_summary_<hash>.csv` the source validation files from the API.<br>
    `hindcast_summary_transposed.csv` a combined version of the results



  In a python 3.11 script, this example code will login and request a historical ERA5 data timeseries.

  ```python
  import salientsdk as sk
  import xarray as xr
  import netcdf4

  session = sk.login("testusr","testpwd")
  history = sk.data_timeseries(loc = Location(lat=42, lon=-73), field="all", variable="temp", session=session)
  print(xr.open_file(history))
  ```

  Note that this example uses the limited credentials `testusr` and `testpwd`. To access the full capabilities of your license, use your Salient-provided credentials.

  See all available functions in the [API Reference](api.md).





  The Salient SDK requires Python 3.11 to use. If you have Python installed, you can check your version with:

  ```bash
  python3 --version
  ```

  To get version 3.11:

  ```bash

  sudo apt update
  sudo apt install software-properties-common
  sudo add-apt-repository ppa:deadsnakes/ppa
  sudo apt update
  sudo apt install python3.11
  ```

  ```bash

  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  brew update
  brew install python@3.11
  ```



  This SDK is licensed for use by Salient customers [details](https://salient-predictions.github.io/salientsdk/LICENSE/).

  Copyright 2024 [Salient Predictions](https://www.salientpredictions.com/)


pkgId: 3ef40d95dae7b64159ebaed3f8f9ba5363078e2b2bd79578c828ed636017b2c4
name: python-saltshaker-sn-help
arch: noarch
version: 1.4
epoch: 0
release: 1
summary: Development documents and examples for saltshaker-sn
url: https://pypi.org/project/saltshaker-sn/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-saltshaker-sn-1.4-1.src.rpm
location_href: Packages/python-saltshaker-sn-help-1.4-1.noarch.rpm
checksum_type: sha256
description:
  This repo is a refactoring of the SALT training code
  for modeling Type Ia supernovae, originally developed by J. Guy.
  When using the SALT3 model, please cite arXiv 2104.07795 (<em>https://arxiv.org/abs/2104.07795</em>).
  We are also developing an additional testing and simulation framework.
  Please feel free to message us with any questions and see
  <em>https://saltshaker.readthedocs.io/en/latest/</em> for
  information on the ongoing work.


pkgId: 750706ebedd71d01c1e72d0cc48c7612d90561115b6f5e95555aa03c8e0f8589
name: python-sambo-help
arch: noarch
version: 1.24.0
epoch: 0
release: 1
summary: Development documents and examples for sambo
url: https://sambo-optimization.github.io
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sambo-1.24.0-1.src.rpm
location_href: Packages/python-sambo-help-1.24.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://img.shields.io/github/actions/workflow/status/sambo-optimization/sambo/ci.yml?branch=master&style=for-the-badge)](https://github.com/sambo-optimization/sambo/actions)
  [![sambo on PyPI](https://img.shields.io/pypi/v/sambo.svg?color=blue&style=for-the-badge)](https://pypi.org/project/sambo)
  [![package downloads](https://img.shields.io/pypi/dm/sambo.svg?color=skyblue&style=for-the-badge)](https://pypi.org/project/sambo)
  [![GitHub Sponsors](https://img.shields.io/github/sponsors/kernc?color=pink&style=for-the-badge)](https://github.com/sponsors/kernc)
  SAMBO: Sequential And Model-Based (Bayesian) Optimization of black-box objective functions.
  [**Project website**](https://sambo-optimization.github.io)
  [Documentation]
  [Documentation]: https://sambo-optimization.github.io/doc/sambo/


pkgId: ff87dc4376cea395d6aec176f906d92692d99994c4ba90d40eee9fc1a1d48dfa
name: python-sammhelper-help
arch: noarch
version: 0.3.14
epoch: 0
release: 1
summary: Development documents and examples for sammhelper
url: https://pypi.org/project/sammhelper/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sammhelper-0.3.14-1.src.rpm
location_href: Packages/python-sammhelper-help-0.3.14-1.noarch.rpm
checksum_type: sha256
description:
  **sammhelper** is a Python package that supports mathematical modeling in the field of urban water management. It provides all functions required in the ETH Zurich lecture [Systems Analysis and Mathematical Modeling in Urban Water Management](https://sww.ifu.ethz.ch/education/lectures/systems-analysis.html).


  **sammhelper** provides wrapper functions for:
  - Ideal reactors modeling
  - Sensitivity functions
  - Parameter identification
  - Error propagation
  - Monte Carlo simulation
  - PID controller


  The source code is currently hosted on ... (**TBD**).
  The binary installer for the latest released version is available at the Python Package Index (PyPI):
  ```
  pip install sammhelper
  ```


  - [Numpy](https://numpy.org/)
  - [Scipy](https://scipy.org/)
  - ...


  The official documentation is hosted on ...


  Work on **sammhelper** started at the [Chairs of Urban Water Management](https://sww.ifu.ethz.ch/) (ETH Zurich) in 2021 and has been under active development since then.


  <sww@ifu.baug.ethz.ch>

rpm_license:
  Copyright (c) 2018 The Python Packaging Authority  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: 6957007e5871fdb6f093c192e3c7a6148e1c8c2cbf0a1ab8fcba640997d4aa76
name: python-samping-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for samping
url: https://pypi.org/project/samping/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-samping-0.1.6-1.src.rpm
location_href: Packages/python-samping-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  Samping is a simple task queue library and background task processing. Currently it only support SQS driver and integrate well with AWS Lambda.


pkgId: 317290700381ea321ccb75956fd38de31e5dd12c5702948937ac41583f5d459a
name: python-sandlersteam-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for sandlersteam
url: https://pypi.org/project/sandlersteam/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sandlersteam-0.1.3-1.src.rpm
location_href: Packages/python-sandlersteam-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  > Digitized steam tables from Sandler's 5th ed.

  Sandlersteam implements a python interface to the steam tables found in Appendix III of _Chemical, Biochemical, and Engineering Thermodynamics_ (5th edition) by Stan Sandler (Wiley, USA). It should be used for educational purposes only.

  The interface operates similarly to the IAPWS steam tables (which you should use instead of these).



  Sandlersteam is available via `pip`:

  ```sh
  pip install sandlersteam
  ```



  Below we create a `State` object to define a thermodynamic state for steam at 100 deg. C and 0.1 MPa:

  ```python
  >>> from sandlersteam.state import State
  >>> state1 = State(T=100.0,P=0.1)
  >>> state1.h  # enthalpy in kJ/kg
  2676.2
  >>> state1.u  # internal energy in kJ/kg
  2506.7
  >>> state1.v  # volume in m3/kg
  1.6958
  >>> state1.s  # entropy in kJ/kg-K
  7.3614
  ```

  Specifying a state requires values for two independent state variables.  The state variables recognized by sandlersteam are:

  * `T` temperature in C
  * `P` pressure in MPa
  * `u` specific internal energy in kJ/kg
  * `v` specific volume in m<sup>3</sup>/kg
  * `h` specific enthalpy in kJ/kg
  * `s` specific entropy in kJ/kg
  * `x` quality; mass fraction of vapor in a saturated vapor/liquid system (between 0 and 1)

  Initializing a `State` instance with any two of these values set by keyword parameters results in the other
  properties receiving values by (bi)linear interpolation.

  When specifying quality, a `State` objects acquires `Liquid` and `Vapor` attributes that each hold intensive, saturated single-phase property values.  The property value attributes owned directly by the `State` object reflect the quality-weighted sum of the respective single-phase values:

  ```python
  >>> s = State(T=100,x=0.5)
  >>> s.P
  0.10135
  >>> s.v
  0.836972
  >>> s.Vapor.v
  1.6729
  >>> s.Liquid.v
  0.001044
  >>> 0.5*(s.Vapor.v+s.Liquid.v)
  0.836972
  ```



  * 0.1.3
      * Updated interpolators
  * 0.1.1
      * Updated pyproject.toml and README.md
  * 0.1.0
      * Initial version



  Cameron F. Abrams – cfa22@drexel.edu

  Distributed under the MIT license. See ``LICENSE`` for more information.

  [https://github.com/cameronabrams](https://github.com/cameronabrams/)



  1. Fork it (<https://github.com/cameronabrams/sandlersteam/fork>)
  2. Create your feature branch (`git checkout -b feature/fooBar`)
  3. Commit your changes (`git commit -am 'Add some fooBar'`)
  4. Push to the branch (`git push origin feature/fooBar`)
  5. Create a new Pull Request


pkgId: d0bb4364226294ae0e35a2a3f50bbcadaf4ab4b848d120d97688752b16ef0fbe
name: python-sapiopycommons-help
arch: noarch
version: 33.0.18.24.7.5
epoch: 0
release: 1
summary: Development documents and examples for sapiopycommons
url: https://github.com/sapiosciences
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sapiopycommons-33.0.18.24.7.5-1.src.rpm
location_href: Packages/python-sapiopycommons-help-33.0.18.24.7.5-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Latest Release](https://img.shields.io/pypi/v/sapiopycommons.svg)](https://pypi.org/project/sapiopycommons/) [![License](https://img.shields.io/pypi/l/sapiopycommons.svg)](https://github.com/sapiosciences/sapio-py-tutorials/blob/master/LICENSE)

  sapiopycommons is a utilities package, developed and maintained by Sapio Sciences, designed to be used in conjunction with sapiopylib. It provides classes and methods for more easily interacting with the Sapio Informatics Platform's webservice API.

  Installation is simple:
  ```sh
  pip install sapiopycommons
  ```
  However, you may need to pay attention to the library version to ensure it is compatible with your Sapio Informatics Platform.

  sapiopycommons is licensed under MPL 2.0.
  pypi.org is granted the right to distribute sapiopycommons forever.
  This license does not provide any rights to use any other copyrighted artifacts from Sapio Sciences. (And they are typically written in another programming language with no linkages to this library.)

  The following dependencies are required for this package:
  - [sapiopylib - The official Sapio Informatics Platform Python API package.](https://pypi.org/project/sapiopylib/)
  - [databind - Databind is a library inspired by jackson-databind to de-/serialize Python dataclasses.](https://pypi.org/project/databind/)

  If you have a support contract with Sapio Sciences, please use our [technical support channels](https://sapio-sciences.atlassian.net/servicedesk/customer/portals).

  Sapio is at the forefront of the Digital Lab with its science-aware platform for managing all your life science data with its integrated Electronic Lab Notebook, LIMS Software and Scientific Data Management System.
  Visit us at <a href="https://www.sapiosciences.com">Sapio Sciences</a>.


pkgId: 73e3b88f5b403e922dd515eadddafa7f52324ae7806c07c0395c99d1f5152e08
name: python-sapiopylib-help
arch: noarch
version: 2024.7.27.233
epoch: 0
release: 1
summary: Development documents and examples for sapiopylib
url: https://github.com/sapiosciences
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sapiopylib-2024.7.27.233-1.src.rpm
location_href: Packages/python-sapiopylib-help-2024.7.27.233-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Latest Release](https://img.shields.io/pypi/v/sapiopylib.svg)](https://pypi.org/project/sapiopylib/) [![License](https://img.shields.io/pypi/l/sapiopylib.svg)](https://github.com/sapiosciences/sapio-py-tutorials/blob/master/LICENSE) [![Issues](https://img.shields.io/github/issues/sapiosciences/sapio-py-tutorials)](https://github.com/sapiosciences/sapio-py-tutorials/issues)

  sapiopylib is a powerful Python package, developed and maintained by Sapio Sciences, that provides the ability to create endpoints to manipulate data and make configuration changes within the Sapio lab informatics platform in a quick and straightforward manner.
  The package makes it easy to automate changes to and queries of different types of data in the system, ranging from records to notebooks and the entries within them. Intuitive datatypes, such as record models that allow for simple manipulation of data records and their fields, within the package help to make development nearly as straightforward as performing the same tasks in the application.
  As well as serving as the most direct way to programmatically alter data in the application, sapiopylib makes it possible to create endpoints to alter and query configurations in the system. Configurations for system data types, lists used by the system, and more can be easily accessed using this package.

  Here is a list of major features in this library:
  - Support all Sapio REST API functions.
  - Manipulate data records with record models using client-based caching. This allows you to batch requests easily for performance. Making your changes in mini-batch is also provides transactional commits outside of a webhook context for data record changes.
  - Create new temporary data types easily with FormBuilder utility.
  - Provides Protocol-Step API as we have defined in Sapio Java API.
  - Supports creation of a Flask-based webhook server. Implement additional toolbar buttons, rules, validation logic to customize your ELN experiment, workflows, and user interface.

  Installation is simple:
  ```sh
  pip install sapiopylib
  ```
  However, you may need to pay attention to the library version to ensure it is compatible with your Sapio Informatics Platform.
  The correct versions for each platform can be found under the tutorial github. The github will create a branch under 'prior_releases' folder when a specific sapiopylib is made against a platform release. The installation manual inside the tutorial, with the correct branch checked out, will make a reference to the exact version you should install for that platform.
  Pre-releases will reference the bleeding-edge non-GA Sapio Platform.
  The latest release of sapiopylib marked with final status will reference the latest GA Sapio Platform.

  sapiopylib along with its tutorials in the github are licensed under MPL 2.0.
  pypi.org is granted the right to distribute sapiopylib forever.
  This license does not provide any rights to use any other copyrighted artifacts from Sapio Sciences. (And they are typically written in another programming language with no linkages to this library.)

  The following dependencies are required for this package:
  - [requests - Requests is an Apache2 Licensed HTTP library, written in Python, for human beings.](https://pypi.org/project/requests/2.7.0/)
  - [pandas - pandasis a fast, powerful, flexible and easy to use open source data analysis and manipulation tool,
    built on top of the Python programming language.](https://pandas.pydata.org/)
  - [Flask - A simple framework for building complex web applications.](https://pypi.org/project/Flask/)
  - [buslane - A simple implementation of event-bus system with proper type hinting](https://pypi.org/project/buslane/)
  - [plotly.py - An open-source, interactive data visualization library for Python](https://pypi.org/project/plotly/)
  - [kaleido - Static image export for web-based visualization libraries with zero dependencies](https://pypi.org/project/kaleido/)

  All documentations, including code examples and installation guide, are provided at [our sapiopylib tutorial github](https://github.com/sapiosciences/sapio-py-tutorials).

  If you have support contract with Sapio Sciences, please use our [technical support channels](https://sapio-sciences.atlassian.net/servicedesk/customer/portals).
  If you have any questions about how to use sapiopylib, please visit our tutorial page.
  If you would like to report an issue on sapiopylib, or its tutorial content, please feel free to create a issue ticket at the tutorial github.

  Sapio is at the forefront of the Digital Lab with its science-aware platform for managing all your life science data with its integrated Electronic Lab Notebook, LIMS Software and Scientific Data Management System.
  Visit us at <a href="https://www.sapiosciences.com">Sapio Sciences</a>


pkgId: 8fe6ecf317c7e17d0bc7b145351e8d280108e3f01407b543dd4ec506c9b37a95
name: python-saritasa-invocations-help
arch: noarch
version: 1.3.1
epoch: 0
release: 1
summary: Development documents and examples for saritasa-invocations
url: https://pypi.org/project/saritasa-invocations/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-saritasa-invocations-1.3.1-1.src.rpm
location_href: Packages/python-saritasa-invocations-help-1.3.1-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/saritasa-nest/saritasa-invocations/checks.yml)
  ![PyPI](https://img.shields.io/pypi/v/saritasa-invocations)
  ![PyPI - Status](https://img.shields.io/pypi/status/saritasa-invocations)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/saritasa-invocations)
  ![PyPI - License](https://img.shields.io/pypi/l/saritasa-invocations)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/saritasa-invocations)
  [![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)

  Collection of [invoke](https://www.pyinvoke.org/) commands used by Saritasa



  * [Installation](#installation)
  * [Configuration](#configuration)
  * [Modules](#modules)
    * [printing](#printing)
    * [system](#system)
      * [system.copy-local-settings](#systemcopy-local-settings)
      * [system.copy-vscode-settings](#systemcopy-vscode-settings)
      * [system.chown](#systemchown)
      * [system.create-tmp-folder](#systemcreate-tmp-folder)
    * [git](#git)
      * [git.set-git-setting](#gitset-git-setting)
      * [git.setup](#gitsetup)
      * [git.clone-repo](#gitclone-repo)
    * [pre-commit](#pre-commit)
      * [pre-commit.install](#pre-commitinstall)
      * [pre-commit.run-hooks](#pre-commitrun-hooks)
      * [pre-commit.update](#pre-commitupdate)
    * [docker](#docker)
      * [docker.build-service](#dockerbuild-service)
      * [docker.buildpack](#dockerbuildpack)
      * [docker.stop-all-containers](#dockerstop-all-containers)
      * [docker.up](#dockerup)
      * [docker.stop](#dockerstop)
      * [docker.clear](#dockerclear)
    * [github-actions](#github-actions)
      * [github-actions.set-up-hosts](#github-actionsset-up-hosts)
    * [python](#python)
      * [python.run](#pythonrun)
    * [django](#django)
      * [django.manage](#djangomanage)
      * [django.makemigrations](#djangomakemigrations)
      * [django.migrate](#djangomigrate)
      * [django.resetdb](#djangoresetdb)
      * [django.createsuperuser](#djangocreatesuperuser)
      * [django.run](#djangorun)
      * [django.shell](#djangoshell)
      * [django.dbshell](#djangodbshell)
      * [django.django.recompile-messages](#djangorecompile-messages)
      * [django.load-db-dump](#djangoload-db-dump)
      * [django.backup-local-db](#djangobackup-local-db)
      * [django.backup-remote-db](#djangobackup-remote-db)
      * [django.load-remote-db](#djangoload-remote-db)
      * [django.wait-for-database](#djangowait-for-database)
    * [fastapi](#fastapi)
      * [fastapi.run](#fastapirun)
    * [alembic](#alembic)
      * [alembic.run](#alembicrun)
      * [alembic.autogenerate](#alembicautogenerate)
      * [alembic.upgrade](#alembicupgrade)
      * [alembic.downgrade](#alembicdowngrade)
      * [alembic.check-for-migrations](#alembiccheck-for-migrations)
      * [alembic.check-for-adjust-messages](#alembiccheck-for-adjust-messages)
      * [alembic.load-db-dump](#alembicload-db-dump)
      * [alembic.backup-local-db](#alembicbackup-local-db)
      * [alembic.backup-remote-db](#alembicbackup-remote-db)
      * [alembic.load-remote-db](#alembicload-remote-db)
      * [alembic.wait-for-database](#alembicwait-for-database)
    * [celery](#celery)
      * [celery.run](#celeryrun)
      * [celery.send-task](#celerysend-task)
    * [open-api](#open-api)
      * [open-api.validate-swagger](#open-apivalidate-swagger)
    * [db](#db)
      * [db.load-db-dump](#dbload-db-dump)
      * [db.backup-local-db](#dbbackup-local-db)
    * [k8s](#k8s)
      * [k8s.login](#k8slogin)
      * [k8s.set-context](#k8sset-context)
      * [k8s.logs](#k8slogs)
      * [k8s.pods](#k8spods)
      * [k8s.execute](#k8sexecute)
      * [k8s.python-shell](#k8spython-shell)
      * [k8s.health-check](#k8shealth-check)
      * [k8s.download-file](#k8sdownload-file)
    * [db-k8s](#db-k8s)
      * [db-k8s.create-dump](#db-k8screate-dump)
      * [db-k8s.get-dump](#db-k8sget-dump)
    * [cruft](#cruft)
      * [cruft.check-for-cruft-files](#cruftcheck-for-cruft-files)
      * [cruft.create_project](#cruftcreate_project)
    * [poetry](#poetry)
      * [poetry.install](#poetryinstall)
      * [poetry.update](#poetryupdate)
      * [poetry.update-to-latest](#poetryupdate-to-latest)
    * [pip](#pip)
      * [pip.install](#pipinstall)
      * [pip.compile](#pipcompile)
    * [mypy](#mypy)
      * [mypy.run](#mypyrun)
    * [pytest](#pytest)
      * [pytest.run](#pytestrun)
    * [secrets](#secrets)
      * [secrets.setup-env-credentials](#secretssetup-env-credentials)



  ```bash
  pip install saritasa-invocations
  ```

  or if you are using [poetry](https://python-poetry.org/)

  ```bash
  poetry add saritasa-invocations
  ```



  Configuration can be set in `tasks.py` file.

  Below is an example of config:

  ```python
  import invoke

  import saritasa_invocations

  ns = invoke.Collection(
      saritasa_invocations.docker,
      saritasa_invocations.git,
      saritasa_invocations.github_actions,
      saritasa_invocations.pre_commit,
      saritasa_invocations.system,
  )


  ns.configure(
      {
          "run": {
              "pty": True,
              "echo": True,
          },
          "saritasa_invocations": saritasa_invocations.Config(
              pre_commit=saritasa_invocations.PreCommitSettings(
                  hooks=(
                      "pre-commit",
                      "pre-push",
                      "commit-msg",
                  )
              ),
              git=saritasa_invocations.GitSettings(
                  merge_ff="true",
                  pull_ff="only",
              ),
              docker=saritasa_invocations.DockerSettings(
                  main_containers=(
                      "opensearch",
                      "redis",
                  ),
              ),
              system=saritasa_invocations.SystemSettings(
                  vs_code_settings_template=".vscode/recommended_settings.json",
                  settings_template="config/.env.local",
                  save_settings_from_template_to="config/.env",
              ),
              
              k8s_defaults=saritasa_invocations.K8SDefaultSettings(
                  proxy="teleport.company.com",
                  db_config=saritasa_invocations.K8SDBSettings(
                      namespace="db",
                      pod_selector="app=pod-selector-db",
                  ),
              )
          ),
      },
  )



  saritasa_invocations.K8SSettings(
      name="dev",
      cluster="teleport.company.somewhere.com",
      namespace="project_name",
  )
  saritasa_invocations.K8SSettings(
      name="prod",
      cluster="teleport.client.somewhere.com",
      namespace="project_name",
      proxy="teleport.client.com",
  )
  ```





  While this module doesn't contain any invocations, it's used to print message
  via `rich.panel.Panel`. There are three types:

  * `print_success` - print message in green panel
  * `print_warning` - print message in yellow panel
  * `print_error` - print message in red panel





  Copies local template for settings into specified file

  Settings:

  * `settings_template` path to settings template (Default: `config/settings/local.template.py`)
  * `save_settings_from_template_to` path to where save settings (Default: `config/settings/local.py`)



  Copies local template for vscode settings into `.vscode` folder

  Settings:

  * `vs_code_settings_template` path to settings template (Default: `.vscode/recommended_settings.json`)



  Change ownership of files to user(current user by default).

  Shortcut for owning apps dir by specified user after some files were
  generated using docker-compose (migrations, new app, etc).



  Create folder for temporary files(`.tmp`).





  Set git setting in config



  Preform setup of git:

  * Install pre-commit hooks
  * Set merge.ff
  * Set pull.ff

  Settings:

  * `merge_ff` setting value for `merge.ff` (Default: `false`)
  * `pull_ff` setting value for `pull.ff` (Default: `only`)



  Clone repo or pull latest changes to specified repo



  Command for creating copies of a file with git blame history saving.

  Original script written in bash [here](https://dev.to/deckstar/how-to-git-copy-copying-files-while-keeping-git-history-1c9j)

  Usage:

  ```shell
    inv git.blame-copy <path to original file> <path to copy>,<path to copy>...
  ```

  If `<path to copy>` is file, then data will be copied in it.

  If `<path to copy>` is directory, then data will be copied in provided
  directory with original name.

  Algorithm:

  1) Remember current HEAD state
  2) For each copy path:
      move file to copy path, restore file using `checkout`,
      remember result commits
  3) Restore state of branch
  4) Move file to temp file
  5) Merge copy commits to branch
  6) Move file to it's original path from temp file

  Settings:

  * `copy_commit_template` template for commits created during command workflow
  * `copy_init_message_template` template for init message printed at command start

  Template variables:

  * `action` - The copy algorithm consists of several intermediate actions
  (creating temporary files, merging commits, etc.)
  The `action` variable stores the header of the intermediate action.
  * `original_path` - Contains value of first argument of the command
  (path of original file that will be copied)
  * `destination_paths` - Sequence of paths to which the original file will be copied
  * `project_task` - project task that will be parsed from current git branch.
  If no task found in branch, then will be empty

  Default values for templates:

  * `copy_commit_template`:

  ```python
    "[automated-commit]: {action}\n\n"
    "copy: {original_path}\n"
    "to:\n* {destination_paths}\n\n"
    "{project_task}"
  ```

  * `copy_init_message_template`:

  ```python
    "Copy {original_path} to:\n"
    "* {destination_paths}\n\n"
    "Count of created commits: {commits_count}"
  ```





  Install git hooks via pre-commit.

  Settings:

  * `hooks` list of hooks to install (Default: `["pre-commit", "pre-push", "commit-msg"]`)



  Run all hooks against all files.



  Update pre-commit dependencies.





  Build service image from docker compose



  Build project via [pack-cli](https://buildpacks.io/docs/tools/pack/)

  Settings:

  * `buildpack_builder` image tag of builder (Default: `paketobuildpacks/builder:base`)
  * `buildpack_runner` image tag of runner (Default: `paketobuildpacks/run:base`)
  * `build_image_tag` image tag of builder (Default: Name of project from `project_name`)
  * `buildpack_requirements_path` path to folder with requirements (Default: `requirements`)



  Shortcut for stopping ALL running docker containers



  Bring up main containers and start them.

  Settings:

  * `main_containers` image tag of builder (Default: `["postgres", "redis"]`)



  Stop main containers.

  Settings:

  * `main_containers` image tag of builder (Default: `["postgres", "redis"]`)



  Stop and remove all containers defined in docker-compose. Also remove images.





  Add hosts to `/etc/hosts`.

  Settings:

  * `hosts` image tag of builder (Default: see `docker-main-containers`)



  As of now we support two environments for python `local` and `docker`.

  * `local` is a python that is located in your current virtualenv
  * `docker` is python that is located inside your docker image of service (`python_docker_service`).

  This was done to have ability to run code against environment close deployed one or simply test it out.

  Example of usage

  ```bash
  PYTHON_ENV=docker inv python.run --command="--version"
  ```



  Run python command depending on `PYTHON_ENV` variable(`docker` or `local`).

  Settings:

  * `entry` python entry command (Default: `python`)
  * `docker_service` python service name (Default: `web`)
  * `docker_service_params` params for docker (Default: `--rm`)





  Run `manage.py` with specified command.

  This command also handle starting of required services and waiting DB to
  be ready.

  Requires [django_probes](https://github.com/painless-software/django-probes#basic-usage)

  Settings:

  * `manage_file_path` path to `manage.py` file (Default: `./manage.py`)



  Run `makemigrations` command and chown created migrations (only for docker env).



  Check if there is new migrations or not. Result should be check via exit code.



  Run `migrate` command.

  Settings:

  * `migrate_command` migrate command (Default: `migrate`)



  Reset database to initial state (including test DB).

  Requires [django-extensions](https://django-extensions.readthedocs.io/en/latest/installation_instructions.html)

  Settings:

  * `settings_path` default django settings (Default: `config.settings.local`)



  Create superuser.

  Settings:

  * `default_superuser_email` default email of superuser.
  if empty, will try to grab it from git config, before resorting to default (Default: `root@localhost`)
  * `default_superuser_username` default username of superuser
  if empty, will try to grab it from git config, before resorting to default (Default: `root`)
  * `default_superuser_password` default password of superuser (Default: `root`)
  * `verbose_email_name` verbose name for `email` field (Default: `Email address`)
  * `verbose_username_name` verbose name for `username` field (Default: `Username`)
  * `verbose_password_name` verbose name for `password` field (Default: `Password`)

  Note:

  * Values for `verbose_email_name`, `verbose_username_name`, `verbose_password_name`
  should match with verbose names of model that used
  [this setting](https://docs.djangoproject.com/en/4.2/topics/auth/customizing/#substituting-a-custom-user-model)



  Run development web-server.

  Settings:

  * `runserver_docker_params` params for docker (Default: `--rm --service-ports`)
  * `runserver_command` runserver command (Default: `runserver_plus`)
  * `runserver_host` host of server (Default: `0.0.0.0`)
  * `runserver_port` port of server (Default: `8000`)
  * `runserver_params` params for runserver command (Default: `""`)



  Shortcut for manage.py shell command.

  Settings:

  * `shell_command` command to start python shell (Default: `shell_plus --ipython`)



  Open database shell with credentials from current django settings.



  Generate and recompile translation messages.

  Requires [gettext](https://www.gnu.org/software/gettext/)

  Settings:

  * `makemessages_params` params for makemessages command (Default: `--all --ignore venv`)
  * `compilemessages_params` params for compilemessages command (Default: `""`)



  Reset db and load db dump.

  Uses [resetdb](#djangoresetdb) and [load-db-dump](#dbload-db-dump)

  Settings:

  * `django_settings_path` default django settings (Default: `config.settings.local`)



  Back up local db.

  Uses [backup_local_db](#dbbackup-local-db)

  Settings:

  * `settings_path` default django settings (Default: `config.settings.local`)



  Make dump of remote db and download it.

  Uses [create_dump](#db-k8screate-dump) and [get-dump](#db-k8sget-dump)

  Settings:

  * `settings_path` default django settings (Default: `config.settings.local`)
  * `remote_db_config_mapping` Mapping of db config
    Default:

    ```python
    {
        "dbname": "RDS_DB_NAME",
        "host": "RDS_DB_HOST",
        "port": "RDS_DB_PORT",
        "username": "RDS_DB_USER",
        "password": "RDS_DB_PASSWORD",
    }
    ```



  Make dump of remote db and download it and apply to local db.

  Uses [create_dump](#db-k8screate-dump) and [get-dump](#db-k8sget-dump) and
  [load-db-dump](#djangoload-db-dump)

  Settings:

  * `settings_path` default django settings (Default: `config.settings.local`)



  Create django app from a template using cookiecutter.

  Settings:

  * `app_boilerplate_link` link to app template
  * `app_template_directory` path to app template in project template (Default: `.`)
  * `apps_path` path to apps folder in project (Default: `apps`)



  Launch docker compose and wait for database connection.





  Run development web-server.

  Settings:

  * `docker_params` params for docker (Default: `--rm --service-ports`)
  * `uvicorn_command` uvicorn command (Default: `-m uvicorn`)
  * `app` path to fastapi app (Default: `config:fastapi_app`)
  * `host` host of server (Default: `0.0.0.0`)
  * `port` port of server (Default: `8000`)
  * `params` params for uvicorn (Default: `--reload`)





  Run alembic command

  Settings:

  * `command` alembic command (Default: `-m alembic`)
  * `connect_attempts` numbers of attempts to connect to database (Default: `10`)



  Generate migrations

  Settings:

  * `migrations_folder` migrations files location (Default: `db/migrations/versions`)



  Upgrade database



  Downgrade database



  Check if there any missing migrations to be generated



  Check migration files for adjust messages

  Settings:

  * `migrations_folder` migrations files location (Default: `db/migrations/versions`)
  * `adjust_messages` list of alembic adjust messages (Default: `# ### commands auto generated by Alembic - please adjust! ###`, `# ### end Alembic commands ###`)



  Reset db and load db dump.

  Uses [downgrade](#alembicdowngrade) and [load-db-dump](#dbload-db-dump)

  Requires [python-decouple](https://github.com/HBNetwork/python-decouple)

  Installed with `[env_settings]`

  Settings:

  * `db_config_mapping` Mapping of db config

    Default:

    ```python
    {
      "dbname": "rds_db_name",
      "host": "rds_db_host",
      "port": "rds_db_port",
      "username": "rds_db_user",
      "password": "rds_db_password",
    }
    ```



  Back up local db.

  Uses [backup_local_db](#dbbackup-local-db)

  Requires [python-decouple](https://github.com/HBNetwork/python-decouple)

  Installed with `[env_settings]`

  Settings:

  * `db_config_mapping` Mapping of db config

    Default:

    ```python
    {
      "dbname": "rds_db_name",
      "host": "rds_db_host",
      "port": "rds_db_port",
      "username": "rds_db_user",
      "password": "rds_db_password",
    }
    ```



  Make dump of remote db and download it.

  Uses [create_dump](#db-k8screate-dump) and [get-dump](#db-k8sget-dump)

  Requires [python-decouple](https://github.com/HBNetwork/python-decouple)

  Installed with `[env_settings]`

  Settings:

  * `db_config_mapping` Mapping of db config

    Default:

    ```python
    {
      "dbname": "rds_db_name",
      "host": "rds_db_host",
      "port": "rds_db_port",
      "username": "rds_db_user",
      "password": "rds_db_password",
    }
    ```



  Make dump of remote db and download it and apply to local db.

  Uses [create-dump](#db-k8screate-dump) and [get-dump](#db-k8sget-dump) and
  [load-db-dump](#alembicload-db-dump)

  Requires [python-decouple](https://github.com/HBNetwork/python-decouple)

  Installed with `[env_settings]`

  Settings:

  * `db_config_mapping` Mapping of db config

    Default:

    ```python
    {
      "dbname": "rds_db_name",
      "host": "rds_db_host",
      "port": "rds_db_port",
      "username": "rds_db_user",
      "password": "rds_db_password",
    }
    ```



  Launch docker compose and wait for database connection.





  Start celery worker.

  Settings:

  * `app` path to app  (Default: `config.celery.app`)
  * `scheduler` scheduler (Default: `django`)
  * `loglevel` log level for celery (Default: `info`)
  * `extra_params` extra params for worker (Default: `("--beat",)`)
  * `local_cmd` command for celery (Default: `celery --app {app} worker --scheduler={scheduler} --loglevel={info} {extra_params}`)
  * `service_name` name of celery service (Default: `celery`)



  Send task to celery worker.

  Settings:

  * `app` path to app  (Default: `config.celery.app`)





  Check that generated open_api spec is valid. This command uses
  [drf-spectacular](https://github.com/tfranzel/drf-spectacular) and
  it's default validator. It creates spec file in ./tmp folder and then validates it.





  Load db dump to local db.

  Settings:

  * `load_dump_command` template for load command(Default located in `_config.pp > dbSettings`)
  * `dump_filename` filename for dump (Default: `local_db_dump`)
  * `load_additional_params` additional params for load command (Default: `--quite`)



  Back up local db.

  Settings:

  * `dump_command` template for dump command (Default located in `_config.pp > dbSettings`)
  * `dump_filename` filename for dump (Default: `local_db_dump`)
  * `dump_additional_params` additional params for dump command (Default: `--no-owner`)



  For K8S settings you just need to create a instances of `K8SSettings` for each
  environnement. It'll be all collected automatically.



  Login into k8s via teleport.

  Settings:

  * `proxy` teleport proxy (**REQUIRED**)
  * `port` teleport port (Default: `443`)
  * `auth` teleport auth method (Default: `github`)



  Set k8s context to current project

  Settings:

  * `namespace` namespace for k8s (Default: Name of project from `project_name`)



  Get logs for k8s pod

  Settings:

  * `default_component` default component (Default: `backend`)



  Get pods from k8s.



  Execute command inside k8s pod.

  Settings:

  * `default_component` default component (Default: `backend`)
  * `default_entry` default entry cmd (Default: `/cnb/lifecycle/launcher bash`)



  Enter python shell inside k8s pod.

  Settings:

  * `default_component` default component (Default: `backend`)
  * `python_shell` shell cmd (Default: `shell_plus`)



  Check health of component.

  Settings:

  * `default_component` default component (Default: `backend`)
  * `health_check` health check cmd (Default: `health_check`)



  Download file from pod.

  * `default_component` default component (Default: `backend`)



  While you probably won't use this module directly some other modules
  commands are use it(getting remote db dump)

  Make sure to set up these configs:

  * `pod_namespace` db namespace (**REQUIRED**)
  * `pod_selector` pod selector for db (**REQUIRED**)



  Execute dump command in db pod.

  Settings:

  * `pod_namespace` db namespace (**REQUIRED**)
  * `pod_selector` pod selector for db (**REQUIRED**)
  * `get_pod_name_command` template for fetching db pod (Default located in `_config.pp > K8SdbSettings`)
  * `dump_filename` default dump filename (Default: Name of project from `project_name` plus `_db_dump`)
  * `dump_command` dump command template (Default located in `_config.pp > K8SDBSettings`)
  * `dump_dir` folder where to put dump file (Default: `tmp`)
  * `dump_additional_params` additional dump commands (Default: `--no-owner`)



  Download db data from db pod if it present

  Settings:

  * `pod_namespace` db namespace (**REQUIRED**)
  * `pod_selector` pod selector for db (**REQUIRED**)
  * `get_pod_name_command` template for fetching db pod (Default located in `_config.pp > K8SDBSettings`)
  * `dump_filename` default dump filename (Default: Name of project from `project_name` plus `_db_dump`)



  [Cruft](https://cruft.github.io/cruft/) is a tool used to synchronize changes
  with cookiecutter based boilerplates.



  Check that there are no cruft files (`*.rej`).



  **Not invocation**, but a shortcut for creating cruft projects for testing
  boilerplates





  Install dependencies via poetry.



  Update dependencies with respect to
  [version constraints](https://python-poetry.org/docs/dependency-specification/)
  using [poetry up plugin](https://github.com/MousaZeidBaker/poetry-plugin-up).

  Fallbacks to `poetry update` in case of an error.



  Update dependencies to latest versions using
  [poetry up plugin](https://github.com/MousaZeidBaker/poetry-plugin-up).

  By default fallbacks to [`update`](#poetryupdate) task in case of an error.
  Use `--no-fallback` to stop on error.





  Install dependencies via pip.

  Settings:

  * `dependencies_folder` path to folder with dependencies files (Default: `requirements`)



  Compile dependencies via
  [pip-compile](https://github.com/jazzband/pip-tools#requirements-from-requirementsin).

  Settings:

  * `dependencies_folder` path to folder with dependencies files (Default: `requirements`)
  * `in_files` sequence of `.in` files (Default: `"production.in"`, `"development.in"`)





  Run mypy in `path` with `params`.

  Settings:

  * `mypy_entry` python entry command (Default: `-m mypy`)





  Run pytest in `path` with `params`.

  Settings:

  * `pytest_entry` python entry command (Default: `-m pytest`)





  Fill specified credentials in your file from k8s.
  This invocations downloads `.env` file from pod in k8s.
  It will replace specified credentials(`--credentials`) in
  specified file `.env` file (`--env_file_path` or `.env` as default)

  Requires [python-decouple](https://github.com/HBNetwork/python-decouple)

  Settings for k8s:

  * `secret_file_path_in_pod` path to secret in pod (**REQUIRED**)
  * `temp_secret_file_path` path for temporary file (Default: `.env.to_delete`)


pkgId: 94da40586d874c67e0447bdee3631e1c21286a481a49b83b03e89a8ac1e0e40f
name: python-satip-help
arch: noarch
version: 2.12.19
epoch: 0
release: 1
summary: Development documents and examples for satip
url: https://pypi.org/project/satip/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-satip-2.12.19-1.src.rpm
location_href: Packages/python-satip-help-2.12.19-1.noarch.rpm
checksum_type: sha256
description:
  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-14-orange.svg?style=flat-square)](#contributors-)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  [![PyPI version](https://badge.fury.io/py/satip.svg)](https://badge.fury.io/py/satip)

  [![codecov](https://codecov.io/gh/openclimatefix/Satip/branch/main/graph/badge.svg?token=GTQDR2ZZ2S)](https://codecov.io/gh/openclimatefix/Satip)

  > Satip is a library for <b>sat</b>ellite <b>i</b>mage <b>p</b>rocessing, and provides all of the functionality necessary for retrieving, and storing EUMETSAT data

  <br>




  To install the `satip` library please run:

  ```bash
  pip install satip
  ```

  Or if you're working in the development environment you can run the following from the directory root:

  ```bash
  pip install -e .
  ```



  Or, if you want to use `conda` from a cloned Satip repository:

  ```bash
  conda env create -f environment.yml
  conda activate satip
  pip install -e .
  ```

  If you plan to work on the development of Satip then also consider installing these development tools:

  ```bash
  conda install pytest flake8 jedi mypy black pre-commit
  pre-commit install
  ```



  In order to contribute:
  - it's recommended that you use a Linux-based OS. This is currently used for all CI/CD testing, production, and development.
  - At the time of writing (21-Dec-23), the Python version used is 3.11 with work being done to update to Python 3.12. This is subject to updates over time.





  In order to contribute to development or just test-run some scripts, you will need your own Eumetsat-API-key. Please follow these steps:

  1. Go to https://eoportal.eumetsat.int and register an account.
  2. You can log in and go to https://data.eumetsat.int/ to check available data services. From there go to your profile and choose the option "API key" or go to https://api.eumetsat.int/api-key/ directly.
  3. Please make sure that you added the key and secret to your user's environment variables.



  We have moved this to [here](https://github.com/openclimatefix/dagster-dags/blob/main/containers/sat/download_process_sat.py)


  `scripts/convert_native_to_zarr.py` converts EUMETSAT `.nat` files to Zarr datasets, using very mild lossy [JPEG-XL](https://en.wikipedia.org/wiki/JPEG_XL) compression. (JPEG-XL is the "new kid on the block" of image compression algorithms). JPEG-XL makes the files about a quarter the size of the equivalent `bz2` compressed files, whilst the images are visually indistinguishable. JPEG-XL cannot represent NaNs so NaNs. JPEG-XL understands float32 values in the range `[0, 1]`. NaNs are encoded as the value `0.025`. All "real" values are in the range `[0.075, 1]`. We leave a gap between "NaNs" and "real values" because there is very slight "ringing" around areas of constant value (see [this comment for more details](https://github.com/openclimatefix/Satip/issues/67#issuecomment-1036456502)). Use `satip.jpeg_xl_float_with_nans.JpegXlFloatWithNaNs` to decode the satellite data. This class will reconstruct the NaNs and rescale the data to the range `[0, 1]`.




  The live service uses `app.py` as the entrypoint for running the live data download for OCF's forecasting service, and has a few configuration options, configurable by command line argument or environment variable.

  `--api-key` or `API_KEY` is the EUMETSAT API key

  `--api-secret` or `API_SECRET` is the EUMETSAT API secret

  `--save-dir` or `SAVE_DIR` is the top level directory to save the output files, a `latest` subfolder will be added to that directory to contain the latest data

  `--history` or `HISTORY` is the amount of history timesteps to use in the `latest.zarr` files

  `--db-url` or `DB_URL` is the URL to the database to save to when a run has finished

  `--use-rescaler` or `USE_RESCALER` tells whether to rescale the satellite data to between 0 and 1 or not when saving to disk. Primarily used as backwards compatibility for the current production models, all new training and production Zarrs should use the rescaled data.

  `--use-iodc` or `USE_IODC` is an option to get the IODC satellite data



  To run tests, simply run ```pytest .``` from the root of the repository. To generate the test plots, run ```python scripts/generate_test_plots.py```.


  Some tests require environmental variables to be set that would be passed in by command line argument when running the code in production. These are as follows:
   - `EUMETSAT_USER_KEY`: the EUMETSAT API key
   - `EUMETSAT_USER_SECRET`: the EUMETSAT API secret

   These can be added using the `export` command in your shell environment. To add these permanently, the export statements can be added to the configuration file for the shell environment (e.g. "~/.bashrc" if using bash).



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://www.jacobbieker.com"><img src="https://avatars.githubusercontent.com/u/7170359?v=4?s=100" width="100px;" alt="Jacob Bieker"/><br /><sub><b>Jacob Bieker</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=jacobbieker" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://jack-kelly.com"><img src="https://avatars.githubusercontent.com/u/460756?v=4?s=100" width="100px;" alt="Jack Kelly"/><br /><sub><b>Jack Kelly</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=JackKelly" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/AyrtonB"><img src="https://avatars.githubusercontent.com/u/29051639?v=4?s=100" width="100px;" alt="Ayrton Bourn"/><br /><sub><b>Ayrton Bourn</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=AyrtonB" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://laurencewatson.com"><img src="https://avatars.githubusercontent.com/u/1125376?v=4?s=100" width="100px;" alt="Laurence Watson"/><br /><sub><b>Laurence Watson</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=Rabscuttler" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/notger"><img src="https://avatars.githubusercontent.com/u/1180540?v=4?s=100" width="100px;" alt="Notger Heinz"/><br /><sub><b>Notger Heinz</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=notger" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/peterdudfield"><img src="https://avatars.githubusercontent.com/u/34686298?v=4?s=100" width="100px;" alt="Peter Dudfield"/><br /><sub><b>Peter Dudfield</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=peterdudfield" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/norbline"><img src="https://avatars.githubusercontent.com/u/39647420?v=4?s=100" width="100px;" alt="Azah Norbline"/><br /><sub><b>Azah Norbline</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=norbline" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/TomPughe"><img src="https://avatars.githubusercontent.com/u/147526382?v=4?s=100" width="100px;" alt="Tom Pughe"/><br /><sub><b>Tom Pughe</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=TomPughe" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://huggingface.co/64bits"><img src="https://avatars.githubusercontent.com/u/40121574?v=4?s=100" width="100px;" alt="Zhenbang Feng"/><br /><sub><b>Zhenbang Feng</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=JasonFengGit" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jsbaasi"><img src="https://avatars.githubusercontent.com/u/72830904?v=4?s=100" width="100px;" alt="jsbaasi"/><br /><sub><b>jsbaasi</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=jsbaasi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/suleman1412"><img src="https://avatars.githubusercontent.com/u/37236131?v=4?s=100" width="100px;" alt="Suleman Karigar"/><br /><sub><b>Suleman Karigar</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=suleman1412" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://richasharma.co.in/"><img src="https://avatars.githubusercontent.com/u/41283476?v=4?s=100" width="100px;" alt="Richa"/><br /><sub><b>Richa</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/commits?author=14Richa" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://phinate.github.io"><img src="https://avatars.githubusercontent.com/u/49782545?v=4?s=100" width="100px;" alt="Nathan Simpson"/><br /><sub><b>Nathan Simpson</b></sub></a><br /><a href="https://github.com/openclimatefix/Satip/issues?q=author%3Aphinate" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/peach280"><img src="https://avatars.githubusercontent.com/u/187241561?v=4?s=100" width="100px;" alt="peach280"/><br /><sub><b>peach280</b></sub></a><br /><a href="#maintenance-peach280" title="Maintenance">🚧</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 41dfdf69b82f4c6a2f729c5baa8b433cee908e219fb3733b2677b553a10305e2
name: python-sausero-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for sausero
url: https://github.com/Kennicutt/SAUSERO
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sausero-0.1.1-1.src.rpm
location_href: Packages/python-sausero-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  __SAUSERO__ is a reduction software for Broad Band Imaging mode of OSIRIS+.

  Developed by __Fabricio M. Pérez-Toledo__



  SAUSERO processes raw science frames to address noise, cosmetic defects, and pixel heterogeneity, preparing them for photometric studies. These corrections are essential before any analysis can be performed. The operations applied to the images depend on the type of observation. This software has been specifically designed to reduce and prepare science frames for photometric studies.



  1. Application of a __Bad Pixel Mask (BPM)__ to all frames.
  2. Creation of the __Master Bias__.
  3. Creation of the __Master Flat__.
  4. Application of master calibration frames to both __standard star__ and __science frames__.
  5. Removal of __cosmic rays__.
  6. __Sky subtraction__.
  7. Alignment of __science frames__.
  8. __Astrometric calibration__.
  9. __Flux calibration__.



  The software requires the following frames as input:

  - __Bias frames__
  - __Sky flat frames__
  - __Photometric standard star frames__
  - __Science frames__



  The generated results consist of one image per observed band. For each image, the following corrections and calibrations will have been applied:

  - __Bias subtraction__
  - __Flat-field correction__ (including fringing correction for the Sloan z band, if applicable)
  - __Image alignment and stacking__
  - __Astrometric calibration__
  - __Photometric calibration__ (estimation of the zero-point, ZP ± error)

  To address cosmetic defects, a __Bad Pixel Mask (BPM)__ is applied, and the __LACosmic algorithm__ is used to handle cosmic ray removal.




  - __Any__: The software is designed to run within a __Conda environment__, ensuring compatibility across platforms.


  The following Python packages are required (minimum versions specified):

  -  `astroalign>=2.4.1`
  -  `astrometry_net_client>=0.3.0`
  -  `astropy>=5.3.4`
  -  `astroquery>=0.4.6`
  -  `ccdproc>=2.4.1`
  -  `lacosmic>=1.1.0`
  -  `loguru>=0.7.2`
  -  `matplotlib>=3.8.0`
  -  `numpy>=1.25.2`
  -  `PyYAML>=6.0.2`
  -  `sep>=1.2.1`


  - __RAM__: Minimum 4GB (higher is recommended for large datasets).



  Installing SAUSERO is straightforward. Follow these steps:

  1. __Activate your Conda environment__ (or create a new one if needed):
      ```
      conda activate <your_env>

  2. __Install SAUSERO__ using `pip`:
      ```
      pip install sausero

  That's it! SAUSERO is now ready to use.



  If you don’t have an existing Conda environment, you can create one specifically for SAUSERO with the following commands:

      conda create -n sausero_env python=3.9 -y
      conda activate sausero_env
      pip install sausero



  Once the Conda environment is set up, you can run __SAUSERO__ using the following command:

      sausero -pr <your_program> -bl <your_ob>

  - `-pr`: Your GTC program indicator.
  - `-bl`: The observed block number.



  The first time you run the command, it will fail because __SAUSERO__ needs to know the path to your frames.
  To resolve this, you must edit the configuration file, which is located in your home directory inside
  a folder named `sausero`.

  You need to set the following parameters in the configuration file:

  1. `PATH_DATA`: Set this to the root directory containing your frames. Example:

      ```
      "PATH_DATA": "/path/to/your/frames/"

  The directory structure must follow the format `<Your_Program>_<Your_OB>/`. Inside this directory, you should have
  a `raw/` folder where the original frames are stored. During execution, __SAUSERO__ will create a new folder named
  `reduced/`, where the reduced frames will be saved.

  2. `No_Session`: This is your Astrometry.net API key. Example:

      ```
      "No_Session":"astrometry-api-key"

  To obtain this key, create an account on [Astrometry.net](https://nova.astrometry.net/). Copy your API key and paste it into the configuration file.



  After updating and saving the configuration file, you can run the command again. This time, the software will execute successfully.



  Once the process is complete, you will find a collection of reduced frames in the `reduced/` folder inside your frame
  directory. The output includes:

  A. __Reduced science frames__:
  - One version with the sky included.
  - One version with the sky subtracted.

  B. __Aligned frames__:
  - Both sky-included and sky-subtracted versions.

  C. __Astrometrized frames__:
  - Frames with astrometric calibration applied.

  D. __Visualization PNG files__:
  - A PNG showing the detected sources in the Field of View (FoV).
  - A PNG showing the photometric standard star.

  E. __Final reduced science frames__:
  - Both sky-included and sky-subtracted versions.




  - By default, __SAUSERO__ ensures your data remains private when using Astrometry.net. The software's internal configuration avoids sharing any data with the Astrometry.net community, ensuring your data's security.



      SAUSERO/
          BPM/
              BPM_OSIRIS_PLUS.fits -> BAD PIXEL MASK
          config/
              configuration.json   -> Configuration file.
          aligning_osirisplus.py   -> Aligns the science frames.
          astrometry_osirisplus.py -> Astrometrization of the science frames.
          Color_Codes.py           -> Gives color to the comments
          OsirisDRP.py             -> Handles all the sofware and manages the frames.
          photometry_osirisplus.py -> Carries out the photometric calibration.
          reduction_osirisplus.py  -> Carries out the clean process.



  The code is designed to work with __OSIRIS+__ frames. They must be in __FITS__ format.



  This software is under __GPL v3.0__ license. More information is available in the
  repository.



  - __Email__: [fabricio.perez@gtc.iac.es](fabricio.perez@gtc.iac.es)

  - __Repository__: [https://github.com/Kennicutt/SAUSERO](https://github.com/Kennicutt/SAUSERO)


pkgId: 0bd8c67d22d1a692853f5a5947fe7e7c431e0d715a0af5ccc9081bef4081cadd
name: python-saverun-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for saverun
url: https://github.com/zlliu246/saverun
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-saverun-0.0.2-1.src.rpm
location_href: Packages/python-saverun-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This file is the first thing users see when they visit PyPI or github

  describe what your project does here


pkgId: 17078d411543966ebe7b56ec2bdc43c696eb18268c94231f791850f446daccc4
name: python-savis-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for savis
url: https://github.com/Seongbuming/savis
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-savis-0.4.1-1.src.rpm
location_href: Packages/python-savis-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  SAVIS (Sentence-level Attention VISualization) is a Python library for visualizing inter-sentence attention in large language models (LLMs). This tool enhances the interpretability of LLMs by providing an intuitive visualization of how attention is distributed across sentences in generated text.

  <center>
  <img src="https://raw.githubusercontent.com/Seongbuming/savis/master/images/savis.png" width="500" alt="SAVIS analyzing reviews">
  </center>



  - Inter-sentence attention calculation
  - Interactive visualization of attention patterns
  - Support for various LLMs through [Hugging Face](https://huggingface.co)'s `transformers` library



  ```bash
  pip install savis
  ```



  ```python
  from savis import TextGenerator, ISA, ISAVisualization


  generator = TextGenerator("Model name")


  input_text = "Your input prompt here"
  generated_text, attentions, tokenizer, input_ids, outputs = generator.generate_text(input_text)


  isa = ISA(outputs.sequences[0], attentions, tokenizer)


  vis = ISAVisualization(isa.sentence_attention, isa.sentences)
  vis.visualize_sentence_attention()
  ```



  1. `TextGenerator`: Interfaces with the LLM to generate text and extract attention information.
  2. `Attention`: Manages the underlying LLM and provides methods for obtaining attention data from the model.
  3. `ISA` (Inter-Sentence Attention): Processes raw attention data to compute attention between sentences.
  4. `ISAVisualization`: Creates interactive visualizations of the computed inter-sentence attention.

  These components work together to provide a comprehensive pipeline from text generation to attention visualization:

  - `TextGenerator` uses the LLM to generate text based on input prompts.
  - `Attention` handles the interaction with the LLM, extracting detailed attention information.
  - `ISA` takes the raw attention data and computes meaningful inter-sentence attention scores.
  - `ISAVisualization` takes these scores and creates interactive visualizations.



  SAVIS is released under the MIT License. See the [LICENSE](https://github.com/Seongbuming/savis/blob/master/LICENSE) file for more details.

rpm_license:
  Copyright (c) 2012-2024 Scott Chacon and others  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: ca92d35fb7a721f0703d86e1b57d142b79b34ac7873e1cc35448769054d43ef3
name: python-sawalni-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for sawalni
url: https://pypi.org/project/sawalni/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sawalni-0.2.6-1.src.rpm
location_href: Packages/python-sawalni-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  This is the official Python SDK for the Sawalni API, providing easy access to language-related services such as embedding generation, language identification, and translation. Sawalni API is developed by [Omneity Labs](https://sawalni.com/developers), and provides unique multilingual models and NLP capabilities, including pioneering Moroccan Darija support.



  Install the package using pip:

  ```bash
  pip install sawalni
  ```



  To use the Sawalni SDK, you'll need an API key. You can set it as an environment variable or pass it directly to the client:

  ```py
  from sawalni import Sawalni

  client = Sawalni(api_key='your_api_key_here')

  ```



  The SDK supports both synchronous and asynchronous operations for the following services:

  1. **Chat**: Generate chat completions using our `Sawalni` multilingual models, supporting Moroccan Darija, English, French, Arabic and many other languages.
  2. **Search**: Perform internet searches in multiple languages with a single query.
  3. **Generate Embeddings**: Create embeddings for text in multiple languages using `Madmon`.
  4. **Identify Language**: Detect the language of a given text with `Gherbal`, supporting up to 33 languages.
  5. **Translate Text**: Translate text between 13 supported languages with `Tarjamli`.
  6. **Transliterate Text**: Convert Moroccan Arabic script to Moroccan Latin script with `Daktilo`.

  The Sawalni SDK includes an OpenAI compatible client, which can be accessed via the `chat` and `embeddings` properties, or direct use via the OpenAI client as detailed below.



  ```py

  chat = client.chat.completions.create(messages=[{"role": "user", "content": "Hello, how are you?"}], model="sawalni-small")


  stream = client.chat.completions.create(messages=[{"role": "user", "content": "Hello, how are you?"}], model="sawalni-small", stream=True)
  for chunk in stream:
      print(chunk.choices[0].delta.content)
  ```



  ```py
  search = client.search("Hello, how are you?")
  ```



  ```py
  embeddings = client.embed("Hello, world!")
  ```



  ```py
  language = client.identify("Bonjour le monde")
  ```



  ```py

  translation = client.translate("Hello", source="auto", target="ary_Latn")
  ```



  ```py
  transliteration = client.transliterate("اهلا بيك", model="daktilo-mini", to="latn", temperature=0.1)


  ```



  For asynchronous operations, use the SawalniAsync client:

  ```py
  from sawalni import SawalniAsync

  async_client = SawalniAsync(api_key='your_api_key_here')
  embeddings = await async_client.embed("Hello, world!")
  ```



  The SDK also includes an OpenAI compatible client, which can be accessed via the `chat` and `embeddings` properties:

  ```py
  chat = client.chat
  embeddings = client.embeddings
  ```

  You can also use the OpenAI client directly with the base URL set to `https://api.sawalni.com/v1` and the API key set to your Sawalni API key.

  ```py
  import openai
  client = openai.OpenAI(base_url="https://api.sawalni.com/v1", api_key="your_api_key_here")
  ```

  Only the `chat` and `embeddings` properties are supported with this approach.



  For detailed information about available models, parameters, languages and and response formats, please refer to the complete API documentation at https://api.sawalni.com.



  If you encounter any issues or have questions, please contact api@sawalni.com.


pkgId: a7d4b756259c053ac96a07eb6864d0424cd71389475e54022485cfcf264d3797
name: python-sbe-help
arch: noarch
version: 0.4.3
epoch: 0
release: 1
summary: Development documents and examples for sbe
url: https://github.com/kizzx2/sbe-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sbe-0.4.3-1.src.rpm
location_href: Packages/python-sbe-help-0.4.3-1.noarch.rpm
checksum_type: sha256
description:
  Easy to use, fast, pure Python FIX [SBE](https://www.fixtrading.org/standards/sbe/) encoder and decoder.



  ```bash
  pip install sbe
  ```





  Decode SBE to Python dictionaries in one line. Good for exploratory data analysis.

  ```python
  import sbe

  with open('your-schema.xml', 'r') as f:
    schema = sbe.Schema.parse(f)

  wtih open('your-data.sbe', 'rb') as f:
    buf = f.read()


  x = schema.decode(buf)

  x.name  # The template message name

  x.value







  schema.decode(buf[19:])



  schema.decode_header(buf)['templateId']
  ```



  This gives you decent performance while still retaining high code readability.

  ```python
  import sbe

  with open('your-schema.xml', 'r') as f:
    schema = sbe.Schema.parse(f)

  wtih open('your-data.sbe', 'rb') as f:
    buf = f.read()



  x = schema.wrap(buf)

  x.header['templateId']
  x.body['price']
  x.body['someGroup'][2]['price']
  ```



  `get_raw_pointer` gives you the required information to unpack a variable from `memoryview` / `bytes`. This gets you very close to the fastest achievable performance in Python:

  ```python
  import sbe

  with open('your-schema.xml', 'r') as f:
    schema = sbe.Schema.parse(f)

  header_pointer = schema.header_wrapper.get_raw_pointer('templateId')


  price_pointer = schema.message_wrappers[3].get_raw_pointer('price')

  wtih open('your-data.sbe', 'rb') as f:
    buf = f.read()


  buf = memoryview(buf)[initial_offset:]
  template_id = header_pointer.unpack(buf)  # calls buf[offset:offset+size].cast("I")[0] directly

  if template_id == 3:
    print(price_pointer.unpack(buf))
  ```



  ```python
  import sbe

  with open('./your-schema.xml', 'r') as f:
    schema = sbe.Schema.parse(f)


  message_id = 3

  obj = {
    'userId': 11,
    'price': 5678.0,
    
  }


  schema.encode(schema.messages[3], obj)


  schema.encode(schema.messages[3], obj, headers)
  ```


pkgId: 7258bfd3766213f62259b53247edd3e0b1c7ff05cd00a0a59d00f0ced274e5e9
name: python-sbvirtualdisplay-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for sbvirtualdisplay
url: https://github.com/mdmintz/sbVirtualDisplay
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sbvirtualdisplay-1.4.0-1.src.rpm
location_href: Packages/python-sbvirtualdisplay-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  A customized [pyvirtualdisplay](https://github.com/ponty/PyVirtualDisplay) for use with [SeleniumBase](https://github.com/seleniumbase/SeleniumBase) automation.



  ```python
  from sbvirtualdisplay import Display

  display = Display(visible=0, size=(1440, 1880))
  display.start()



  display.stop()
  ```



  ```python
  with Display(visible=0, size=(1440, 1880)):
      
      ...
  ```



  If you need to run browser tests on a headless machine (such as a Linux backend), and you can't use a browser's headless mode (such as Chrome's headless mode), then this may help. For example, Chrome does not allow extensions in headless mode, so if you need to run automated tests on a headless Linux machine and you need to use Chrome extensions, then this will let you run those tests using a virtual display.




  * [Xvfb](https://en.wikipedia.org/wiki/Xvfb) is required for this to work.


pkgId: 9a310ef8a0b2f5132eeb98c9ce07866d1a168c4f86dae18bd54e98b2054d9da8
name: python-sc-echidna-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for sc-echidna
url: https://github.com/azizilab/echidna
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sc-echidna-1.0.0-1.src.rpm
location_href: Packages/python-sc-echidna-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src=./echidna_logo.png width="100" />

   A Bayesian framework for quantifying gene dosage effect impacting phenotypic plasticity through integrating single-cell RNA sequencing (scRNA-seq) and bulk whole-genome sequencing (WGS) from a single or multiple time points.


  <img src=./echidna_concept.png width="800" />



  Echidna is available on PyPI under the name `echidna-sc`.


  Create a conda environment with a recent Python version: conda create -n "echidna-env" python=3.10


  Ensure you have the right version of torch installed for your device. See instructions on [pytorch.org](https://pytorch.org/get-started/locally/).

  Echidna is available through pip via: `pip install echidna-sc`.



  There are four example notebooks:

  1. 1-single-timepoint.ipynb
  2. 2-multi-timepoint.ipynb
  3. 3-infer-gene-dosage.ipynb
  4. 4-echidna-model.ipynb

  The notebooks are meant to be run sequentially, and they build off of each other.

  Notebook 1 introduces you to the package - preparing your data, setting hyperparamters, performing posterior predictive checks - with data collected from a single point in time.

  In notebook 2, we look at a multi-timepoint setting, where we have paired single-cell and WGS data collected over time.

  The saved model runs from notebook 2 will be used in notebook 3, where you will see how to infer amplifications and deletions by cluster of genes across a given genome. This notebook also shows you how to calculate and plot gene dosage effect with Echidna.

  Notebook 4 is meant to show you how to do more custom work with the model. We package together many functions for your convenience, but this notebook will show you how to work directly with the model for the experiments not covered in the package. Some [Pyro](https://pyro.ai/) knowledge is assumed.





  | Setting        | Type   | Default         | Description                               |
  |----------------|--------|-----------------|-------------------------------------------|
  | `timepoint_label` | `str`  | `"timepoint"`    | Label for timepoints in the data.         |
  | `counts_layer`    | `str`  | `"counts"`       | Name of the counts layer in the data.     |
  | `clusters`        | `str`  | `"leiden"`       | Clustering method used in the data. This can also be celltype annotations, if you have them.       |



  | Setting         | Type   | Default         | Description                                               |
  |-----------------|--------|-----------------|-----------------------------------------------------------|
  | `seed`          | `int`  | `42`            | Random seed for reproducibility.                          |
  | `n_steps`       | `int`  | `10000`         | Maximum number of steps for Stochastic Variational Inference (SVI). |
  | `learning_rate` | `float`| `0.1`           | Learning rate for the Adam optimizer.                     |
  | `val_split`     | `float`| `0.1`           | Percentage of training data to use for validation.         |
  | `patience`      | `int`  | `30`            | Early stopping patience (set to >0 to enable early stopping). |
  | `device`        | `str`  | `"cuda" if is_available() else "cpu"` | Device to use for training (GPU if available, otherwise CPU). |
  | `verbose`       | `bool` | `True`          | Whether to enable logging output.                         |



  | Setting              | Type    | Default   | Description                                                                        |
  |----------------------|---------|-----------|------------------------------------------------------------------------------------|
  | `inverse_gamma`       | `bool`  | `False`   | Whether to use inverse gamma for noisier data.                                     |
  | `lkj_concentration`   | `float` | `1.0`     | Concentration parameter of LKJ prior. Values > 1.0 result in more diagonal covariance matrices. |
  | `q_shape_rate_scaler` | `float` | `10.0`    | Scaler for the shape and rate parameters of the covariance diagonal for variational inference. |
  | `q_corr_init`         | `float` | `0.01`    | Initial scale of the variational correlation.                                      |
  | `q_cov_scaler`        | `float` | `0.01`    | Scaler for the covariance of the variational correlation.                          |
  | `eta_mean_init`       | `float` | `2.0`     | Initial mean value for the eta parameter.                                          |
  | `eps`                 | `float` | `5e-3`    | Small constant added to the diagonal to ensure positive definiteness (PD).         |


pkgId: 16c52fa8fa96b48153df2d41f102f5ff703b82e247b451f1c0cee5556846502c
name: python-sc-file-help
arch: noarch
version: 3.6.1
epoch: 0
release: 1
summary: Development documents and examples for sc-file
url: https://github.com/onejeuu/sc-file
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sc-file-3.6.1-1.src.rpm
location_href: Packages/python-sc-file-help-3.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Utility and Library for decoding and converting stalcraft asset files, such as models and textures, into popular formats.

  Designed for artworks creation.

  For answers to common questions, please refer to [FAQ section](FAQ.md).

  You can download executable from [Releases page](https://github.com/onejeuu/sc-file/releases).

  ![Build](https://github.com/onejeuu/sc-file/actions/workflows/build.yml/badge.svg)

  > [!WARNING]
  > Do not use game assets directly. \
  > Any changes in game client can be detected.



  | Type    | Source        | Output                 |
  | ------- | ------------- | ---------------------- |
  | Model   | .mcsa / .mcvd | .obj, .dae, ms3d, .txt |
  | Texture | .ol           | .dds                   |
  | Image   | .mic          | .png                   |



  - Versions supported: 7.0, 8.0, 10.0, 11.0
  - Skeleton and Animations currently unsupported



  - Formats supported: DXT1, DXT3, DXT5, RGBA8, BGRA8, DXN_XY
  - Formats supported partially: Cubemaps (HDRI)
  - Formats unsupported: RGBA32F
  - Some normal map textures can be inverted



  From bash:

  ```bash
  scfile [FILES]... [OPTIONS]
  ```

  > [!TIP]
  > You can just drag and drop one or multiple files onto `scfile.exe`.



  - `FILES`: **List of file paths to be converted**. Multiple files should be separated by **spaces**. Accepts both full and relative paths. Only one directory can be specified.



  - `-F`, `--formats`: **Preferred format for models**. To specify multiple formats, **option** must be used multiple times.
  - `-O`, `--output`: **One path to output directory**. If not specified, file will be saved in same directory with a new suffix.



  - `--subdir`: Recreates input subdirectories to output directory.
  - `--no-overwrite`: Do not overwrite output file if already exists.
  - `--silent`: Suppress all console prints.



  1. Convert model with specified formats

     ```bash
     scfile model.mcsa -F obj -F dae
     ```

     _Will be saved in same location with a new suffix._

  2. Convert multiple files to a specified directory:

     ```bash
     scfile model1.mcsa model2.mcsa -O path/to/output
     ```

  3. Convert all `.mcsa` files in current directory:

     ```bash
     scfile *.mcsa
     ```

     _Will be saved in same location. Subdirectories are not included._

  4. Convert all `.mcsa` files with subdirectories to a specified directory:

     ```bash
     scfile path/to/files/**/*.mcsa -O path/to/output --subdir
     ```





  ```bash
  pip install sc-file -U
  ```





  ```python
  from scfile import convert



  convert.mcsa_to_obj("path/to/model.mcsa", "path/to/model.obj")
  convert.ol_to_dds("path/to/texture.ol", "path/to/texture.dds")
  convert.mic_to_png("path/to/image.mic", "path/to/image.png")


  convert.mcsa_to_ms3d("path/to/model.mcsa", "path/to/model.ms3d")
  convert.mcsa_to_ms3d_ascii("path/to/model.mcsa", "path/to/model.txt")


  convert.auto("path/to/model.mcsa")
  ```



  - Default usage

  ```python
  from scfile.file.data import ModelData
  from scfile.file import McsaDecoder, ObjEncoder

  mcsa = McsaDecoder("model.mcsa")
  data: ModelData = mcsa.decode()
  mcsa.close() # ? Necessary to close decoder

  obj = ObjEncoder(data)
  obj.encode().save("model.obj") # ? Buffer closes after save
  ```

  - Use encoded content bytes

  ```python
  obj = ObjEncoder(data) # ? data - ModelData from McsaDecoder
  obj.encode() # ? Write bytes into buffer

  with open("model.obj", "wb") as fp:
      fp.write(obj.content) # ? obj.content - Encoder buffer bytes

  obj.close() # ? Necessary to close encoder
  ```

  - Use convert methods

  > [!IMPORTANT]
  > Unclosed buffer can cause memory leaks. \
  > When using `convert_to` or `to_xxx` methods, encoder buffer remains open. \
  > `close()` or `save()` or another context (`with`) **is necessary**.

  ```python
  mcsa = McsaDecoder("model.mcsa")
  mcsa.convert_to(ObjEncoder).save("model.obj") # ? Encoder buffer closes after save
  mcsa.close() # ? Necessary to close decoder
  ```

  ```python
  mcsa = McsaDecoder("model.mcsa")
  mcsa.to_obj().save("model.obj") # ? Encoder buffer closes after save
  mcsa.close() # ? Necessary to close decoder
  ```

  - Use context manager (`with`)

  ```python
  with McsaDecoder("model.mcsa") as mcsa:
      data: ModelData = mcsa.decode()

  with ObjEncoder(data) as obj:
      obj.encode().save("model.obj")
  ```

  - Use context manager + convert methods

  ```python
  with McsaDecoder("model.mcsa") as mcsa:
      obj = mcsa.convert_to(ObjEncoder)
      obj.close() # ? Necessary to close encoder
  ```

  or

  ```python
  with McsaDecoder("model.mcsa") as mcsa:
      mcsa.to_obj().save("model.obj") # ? Encoder buffer closes after save
  ```

  - Save multiple copies

  ```python
  with McsaDecoder("model.mcsa") as mcsa:
      with mcsa.to_obj() as obj:
          obj.save_as("model_1.obj") # ? Encoder buffer remains open after save_as
          obj.save_as("model_2.obj")
      
  ```



  1. Download project

     ```bash
     git clone https://github.com/onejeuu/sc-file.git
     ```

     ```bash
     cd sc-file
     ```

  2. Recommended to create virtual environment

     ```bash
     python -m venv .venv
     ```

     ```bash
     .venv\Scripts\activate
     ```

  3. Install dependencies

     via poetry

     ```bash
     poetry install
     ```

     or via pip

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

  4. Run script to compile

     ```bash
     python scripts/build.py
     ```

     Executable file `scfile.exe` will be created in `/dist` directory.


pkgId: cd60910e2a5dda8225f743e3cce8bc1a27626a33347d6e2fe915475de6118100
name: python-sc-gallery-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for sc-gallery
url: https://github.com/siliconcompiler/scgallery
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sc-gallery-0.0.10-1.src.rpm
location_href: Packages/python-sc-gallery-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  [![General CI](https://github.com/siliconcompiler/scgallery/actions/workflows/general_ci.yml/badge.svg)](https://github.com/siliconcompiler/scgallery/actions/workflows/general_ci.yml)
  [![Lint](https://github.com/siliconcompiler/scgallery/actions/workflows/lint.yml/badge.svg?branch=main)](https://github.com/siliconcompiler/scgallery/actions/workflows/lint.yml)


  Design gallery for [SiliconCompiler](https://github.com/silicompiler/siliconcompiler).
  This library uses the rtl2gds flow in SiliconCompiler to compile the designs from RTL to a GDS file.

  ![Gallery](images/montage.jpg)


  Utilize the same python environment as SiliconCompiler.

      git clone https://github.com/siliconcompiler/scgallery.git
      cd scgallery
      python3 -m pip install .



      sc-gallery -design sha512  # Will run on all supported targets
      sc-gallery -design sha512 -target asap7_demo  # Will only run on asap7
      sc-gallery -target asap7_demo  # Will run all designs supported on asap7
      sc-gallery  # Will run all designs on all targets



      sc-gallery -gallery private.gallery -design aes  # Will run on all supported targets in your private gallery
      sc-gallery -gallery private.gallery  # Will run all designs on all targets in your private gallery



      python3 -m scgallery.rules -cfg <cfg> -rules <rules> -check  # Check if run met the rule requirements.
      python3 -m scgallery.rules -cfg <cfg> -rules <rules> -create  # Create an initial set of rules.
      python3 -m scgallery.rules -cfg <cfg> -rules <rules> -update_all  # Update rules based on the run.
      python3 -m scgallery.rules -cfg <cfg> -rules <rules> -tighten_passing  # Update passing rules based on the run.
      python3 -m scgallery.rules -cfg <cfg> -rules <rules> -update_failing  # Update failing rules based on the run.




  1. Create a folder with the design name (\<design\>) in scgallery/designs
  2. add source files to scgallery/designs/\<design\>/src
  3. add constraints to scgallery/designs/\<design\>/constraints (using the name of the library it is associated with)
  4. create scgallery/designs/\<design\>/\<design\>.py
  5. add the design to [scgallery/designs/\_\_init\_\_.py](scgallery/designs/__init__.py)



  We use [GitHub Issues](https://github.com/siliconcompiler/scgallery/issues)
  for tracking requests and bugs.



  [Apache License 2.0](LICENSE)

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  Copyright 2023 Zero ASIC Corporation  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: ca3622e2f9440d595a595fa59dddc790cfe9b347a42d6c2a6b772b3f03457ce4
name: python-sc2bench-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for sc2bench
url: https://github.com/yoshitomo-matsubara/sc2-benchmark
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sc2bench-0.1.0-1.src.rpm
location_href: Packages/python-sc2bench-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/sc2bench.svg)](https://badge.fury.io/py/sc2bench)
  [![GitHub Discussions](https://img.shields.io/github/discussions/yoshitomo-matsubara/sc2-benchmark)](https://github.com/yoshitomo-matsubara/sc2-benchmark/discussions)

  This is the official repository of `sc2bench` package and our TMLR paper, ["SC2 Benchmark: Supervised Compression for Split Computing"](#citation).

  As an intermediate option between local computing and edge computing (full offloading), ***split computing*** has been
  attracting considerable attention from the research communities.

  In split computing, we split a neural network model into two sequences so that some elementary feature transformations
  are applied by the first sequence of the model on a weak mobile (local) device.
  Then, intermediate, informative features are transmitted through a wireless communication channel to a powerful
  edge server that processes the bulk part of the computation (the second sequence of the model).


  ![R-D (rate-distortion), ExR-D, and Three-way tradeoffs](https://raw.githubusercontent.com/yoshitomo-matsubara/sc2-benchmark/main/imgs/ilsvrc2012-overview.png)
  ImageNet (ILSVRC 2012): R-D (rate-distortion), ExR-D, and three-way tradeoffs for input compression and supervised compression with ResNet-50 as a reference model

  ![Input compression vs. Supervised compression](https://raw.githubusercontent.com/yoshitomo-matsubara/sc2-benchmark/main/imgs/input_vs_supervised_compression.png)

  Input compression is an approach to save transmitted data, but it leads to transmitting information irrelevant to
  the supervised task.
  To achieve better supervised rate-distortion tradeoff, we define ***supervised compression*** as
  learning compressed representations for supervised downstream tasks such as classification, detection, or segmentation.
  Specifically for split computing, we term the problem setting **SC2** (*Supervised Compression for Split Computing*).

  Note that the training process can be done offline (i.e., on a single device without splitting),
  and it is different from "split learning".



  Local processing cost should be minimized as local (mobile) devices usually have battery constraints and limited computing power.
  As a simple proxy for the computing costs, we measure the number of encoder parameters and
  define the encoder size as the total number of bits to represent the parameters of the encoder.


  We want to penalize large data being transferred from the mobile device to the edge server while the BPP does not
  penalize it when feeding higher resolution images to downstream models for achieving higher model accuracy.


  While minimizing the two metrics, we want to maximize model accuracy (minimize supervised distortion).
  Example supervised distortions are accuracy, mean average precision (mAP), and mean intersection over union (mIoU) for
  image classification, object detection, and semantic segmentation, respectively.


  ```shell
  pip install sc2bench
  ```


  For pipenv users,
  ```shell
  pipenv install --python 3.9

  pipenv install sc2bench
  ```


  See instructions [here](script#datasets)


  You can download our checkpoints including trained model weights [here](https://github.com/yoshitomo-matsubara/sc2-benchmark/releases/tag/v0.0.3).
  Unzip the downloaded zip files under `./`, then there will be `./resource/ckpt/`.


  1. CR + BQ: ["Neural Compression and Filtering for Edge-assisted Real-time Object Detection in Challenged Networks"](https://arxiv.org/abs/2007.15818)
  2. End-to-End: ["End-to-end Learning of Compressible Features"](https://arxiv.org/abs/2007.11797)
  3. Entropic Student: ["Supervised Compression for Resource-Constrained Edge Computing Systems"](https://openaccess.thecvf.com/content/WACV2022/html/Matsubara_Supervised_Compression_for_Resource-Constrained_Edge_Computing_Systems_WACV_2022_paper.html)

  [README.md](https://github.com/yoshitomo-matsubara/sc2-benchmark/tree/main/script/task) explains how to train/test implemented supervised compression methods.


  - [Codec-based input compression](https://github.com/yoshitomo-matsubara/sc2-benchmark/tree/main/script/codec_input_compression): JPEG, WebP, BPG
  - [Neural input compression](https://github.com/yoshitomo-matsubara/sc2-benchmark/tree/main/script/neural_input_compression): Factorized Prior, Scale Hyperprior, Mean-scale Hyperprior, and Joint Autoregressive Hierarchical Prior

  Each **README.md** gives instructions to run the baseline experiments.


  ```shell

  python script/task/image_classification.py -test_only --config configs/ilsvrc2012/feature_compression/jpeg-resnet50.yaml

  python script/task/image_classification.py -test_only --config configs/ilsvrc2012/feature_compression/webp-resnet50.yaml
  ```


  [[Paper](https://openreview.net/forum?id=p28wv4G65d)] [[Preprint](https://arxiv.org/abs/2203.08875)]
  ```bibtex
  @article{matsubara2023sc2,
    title={{SC2 Benchmark: Supervised Compression for Split Computing}},
    author={Matsubara, Yoshitomo and Yang, Ruihan and Levorato, Marco and Mandt, Stephan},
    journal={Transactions on Machine Learning Research},
    issn={2835-8856},
    year={2023},
    url={https://openreview.net/forum?id=p28wv4G65d}
  }
  ```


  For measuring data size per sample precisely, it is important to keep test batch size of 1 when testing.
  E.g., some baseline modules may expect larger batch size if you have multiple GPUs.
  Then, add `CUDA_VISIBLE_DEVICES=0` before your execution command (e.g., `sh`, `bash`, `python`)
  so that you can force the script to use one GPU (use GPU: 0 in this case).

  For instance, an input compression experiment using factorized prior (pretrained input compression model)
  and ResNet-50 (pretrained classifier)
  ```shell
  CUDA_VISIBLE_DEVICES=0 sh script/neural_input_compression/ilsvrc2012-image_classification.sh factorized_prior-resnet50 8
  ```


  The documentation is work-in-progress. In the meantime, feel free to create an issue if you find a bug.
  If you have either a question or feature request, start a new discussion [here](https://github.com/yoshitomo-matsubara/sc2-benchmark/discussions).


  - [PyTorch (torchvision)](https://github.com/pytorch/vision)
  - [PyTorch Image Models (timm)](https://github.com/rwightman/pytorch-image-models)
  - [CompressAI](https://github.com/InterDigitalInc/CompressAI)
  - [torchdistill](https://github.com/yoshitomo-matsubara/torchdistill)
  - Johannes Ballé, David Minnen, Saurabh Singh, Sung Jin Hwang and Nick Johnston. ["Variational image compression with a scale hyperprior"](https://openreview.net/forum?id=rkcQFMZRb) (ICLR 2018)
  - David Minnen, Johannes Ballé and George D. Toderici. ["Joint Autoregressive and Hierarchical Priors for Learned Image Compression"](https://proceedings.neurips.cc/paper/2018/hash/53edebc543333dfbf7c5933af792c9c4-Abstract.html) (NeurIPS 2018)
  - Yoshitomo Matsubara and Marco Levorato. ["Neural Compression and Filtering for Edge-assisted Real-time Object Detection in Challenged Networks"](https://arxiv.org/abs/2007.15818) (ICPR 2020)
  - Saurabh Singh, Sami Abu-El-Haija, Nick Johnston, Johannes Ballé, Abhinav Shrivastava and George Toderici. ["End-to-end Learning of Compressible Features"](https://arxiv.org/abs/2007.11797) (ICIP 2020)
  - Yoshitomo Matsubara, Ruihan Yang, Marco Levorato and Stephan Mandt. ["Supervised Compression for Resource-Constrained Edge Computing Systems"](https://openaccess.thecvf.com/content/WACV2022/html/Matsubara_Supervised_Compression_for_Resource-Constrained_Edge_Computing_Systems_WACV_2022_paper.html) (WACV 2022)


pkgId: 706d2635e8bd2381aabaab98312d3f16fdcf4fbcecbcdecd4cddfc4209986ec3
name: python-scFountain-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for scFountain
url: https://github.com/BioX-NKU/Fountain
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scFountain-0.0.5-1.src.rpm
location_href: Packages/python-scFountain-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Single-cell assay for transposase-accessible chromatin using sequencing (scATAC-seq) deciphers genome-wide chromatin accessibility, providing profound insights into gene regulation mechanisms. With the rapid advance of sequencing technology, scATAC-seq data typically encompasses numerous samples generated under various conditions, leading to complex and multifactorial batch effects, thus necessitating reliable batch integration tools. Although numerous batch integration tools exist for single-cell RNA sequencing (scRNA-seq) data, their effectiveness on scATAC-seq data has proven limited due to the characteristic differences between scRNA-seq and scATAC-seq data. Existing integration methods for scATAC-seq data suffer from several fundamental limitations, such as disrupting the  biological heterogeneity and focusing solely on low-dimensional correction, which can lead to data distortion and hinder downstream analysis. Here we propose Fountain, a deep learning framework for scATAC-seq data integration via rigorous barycentric mapping. Fountain regularizes barycentric mapping with geometric data information to achieve biological heterogeneity-preserving integration. Through comprehensive experiments on multiple datasets involving various laboratory protocols, sample composition and species, we demonstrate the advantages of Fountain over existing methods in batch correction and biological conservation. Additionally, the trained Fountain model can integrate data from new batches alongside already integrated data without retraining, thereby facilitating the incorporation of additional data and enabling continuous online data integration. Moreover, we provide a reconstruction strategy to obtain batch-corrected ATAC profiles, which has been proven to  better capture cellular heterogeneity and reveal cell type-specific implications such as expression enrichment analysis and partitioned heritability analysis.


pkgId: dfdffe08ae747353e579b61a50e5a9d23f6880111fae0864d7e33c65c5429be1
name: python-schemapack-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for schemapack
url: https://pypi.org/project/schemapack/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-schemapack-1.0.0-1.src.rpm
location_href: Packages/python-schemapack-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ![tests](https://github.com/ghga-de/schemapack/actions/workflows/unit_and_int_tests.yaml/badge.svg)
  [![PyPI version shields.io](https://img.shields.io/pypi/v/schemapack.svg)](https://pypi.python.org/pypi/schemapack/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/schemapack.svg)](https://pypi.python.org/pypi/schemapack/)
  [![Coverage Status](https://coveralls.io/repos/github/ghga-de/schemapack/badge.svg?branch=main)](https://coveralls.io/github/ghga-de/schemapack?branch=main)



  Make your JSON Schemas sociable and create linked data model.


  This package is available at PyPI:
  https://pypi.org/project/schemapack

  You can install it from there using:
  ```
  pip install schemapack
  ```


  For setting up the development environment, we rely on the
  [devcontainer feature](https://code.visualstudio.com/docs/remote/containers) of vscode.

  To use it, you have to have Docker as well as vscode with its "Remote - Containers"
  extension (`ms-vscode-remote.remote-containers`) extension installed.
  Then, you just have to open this repo in vscode and run the command
  `Remote-Containers: Reopen in Container` from the vscode "Command Palette".

  This will give you a full-fledged, pre-configured development environment including:
  - infrastructural dependencies of the service (databases, etc.)
  - all relevant vscode extensions pre-installed
  - pre-configured linting and auto-formating
  - a pre-configured debugger
  - automatic license-header insertion

  Moreover, inside the devcontainer, there is follwing convenience command available
  (please type it in the integrated terminal of vscode):
  - `dev_install` - install the lib with all development dependencies and pre-commit hooks
  (please run that if you are starting the devcontainer for the first time
  or if added any python dependencies to the [`./setup.cfg`](./setup.cfg))


  This repository is free to use and modify according to the [Apache 2.0 License](./LICENSE).


pkgId: 531235d15c6f40c90a969a1d0560ac10d32c87324022816e855b91e3398cdec4
name: python-schug-help
arch: noarch
version: 1.6.2
epoch: 0
release: 1
summary: Development documents and examples for schug
url: https://pypi.org/project/schug/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-schug-1.6.2-1.src.rpm
location_href: Packages/python-schug-help-1.6.2-1.noarch.rpm
checksum_type: sha256
description:
  Schug :stew: is a service that gather data about genes, transcripts and exons from multiple sources and merge the
  information. There is a [REST API][rest-api] with relevant endpoints.



  You can test Schug on your local computer using Docker. Make sure you have [Docker][docker] installed and type the following commands in a terminal window:

  ```
  git clone https://github.com/Clinical-Genomics/schug
  cd schug
  docker-compose up
  ```

  Then the app endpoints should be listed available at the following address http://localhost:8000/docs

  The command to stop the demo is `docker-compose down`.




  Make sure [poetry][poetry] is installed

  ```
  git clone https://github.com/Clinical-Genomics/schug
  cd schug
  poetry install
  schug serve --reload
  ```
  Go to http://localhost:8000/docs and check out the API.



  Once having set up an instance of Schug, you can use the following endpoints:

   - **/genes/ensembl_genes/**

     Downloads genes from Ensembl in text format. Specify a genome build by using the parameters `37` or `38`.

     Usage: `curl -X 'GET' 'http://0.0.0.0:8000/genes/ensembl_genes/?build=38' > genes_GRCh38.txt`

   - **/transcripts/ensembl_transcripts/**

     Downloads gene transcripts from Ensembl in text format. Specify a genome build by using the parameters `37` or `38`.

     Usage: `curl -X 'GET' 'http://0.0.0.0:8000/transcripts/ensembl_transcripts/?build=38' > transcripts_GRCh38.txt`

   - **/exons/ensembl_exons/**

     Downloads gene exons from Ensembl in text format. Specify a genome build by using the parameters `37` or `38`.

     Usage: `curl -X 'GET' 'http://0.0.0.0:8000/exons/ensembl_exons/?build=38' > exons_GRCh38.txt`



  The basic structure is outlined and implemented, however there are many details left to implement before
  this can be used.
  Some of the basic endpoints are in place but these need to be extended according to the needs of the
  users. Also the gene information needs to be completed, this will be done in a similar fashion as in
  [Scout][scout-genes].

  [docker]: https://www.docker.com/
  [poetry]: https://python-poetry.org/docs/basic-usage/
  [rest-api]: https://realpython.com/api-integration-in-python/
  [scout-genes]: https://github.com/Clinical-Genomics/scout/blob/121e9577aaf837eadd6b0e231e0fc5f3e187b920/scout/load/setup.py#L41


pkgId: 5753b999d7e2d0c6fc32f2c3d013bd40ad58be6a3923dc0094f3256c01b83e45
name: python-scientific-spinbox-help
arch: noarch
version: 1.0.0.dev8
epoch: 0
release: 1
summary: Development documents and examples for scientific-spinbox
url: https://dpizetta.gitlab.io/pqwidget
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scientific-spinbox-1.0.0.dev8-1.src.rpm
location_href: Packages/python-scientific-spinbox-help-1.0.0.dev8-1.noarch.rpm
checksum_type: sha256
description:
  **ScientificSpinbox** is a Qt Widget based on QDoubleSpinBox that
  enables users to insert and manipulate physical quantities naturally.


pkgId: c11e265de8537e4ede4c4e78857d87b9455e763d2b603057a5e4c46380172d7c
name: python-scikit-build-core-conan-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for scikit-build-core-conan
url: https://github.com/wu-vincent/scikit-build-core-conan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scikit-build-core-conan-0.5.3-1.src.rpm
location_href: Packages/python-scikit-build-core-conan-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  A conan plugin for scikit-build-core

  > [!NOTE]
  > This project is under early development. Should you encounter any problems, please feel free to open an issue.



  ```shell
  pip install scikit-build-core-conan
  ```

  To use `scikit-build-core-conan`, add it to your `build-system.requires`, and specify
  the `scikit_build_core_conan.build` builder as your `build-system.build-backend`. You do not need to
  specify `scikit_build_core` as it will be required automatically.



  Here's a simple example on how you can use `scikit-build-core-conan` in your `pyproject.toml`.

  ```toml

  [build-system]
  requires = ["scikit-build-core-conan"]
  build-backend = "scikit_build_core_conan.build"

  [project]
  name = "scikit_build_conan_simplest"
  version = "0.0.1"
  ```



  `scikit-build-core-conan` supports a broad range of configuration options. These options can be placed directly in
  the `pyproject.toml` file. They can also be passed via `-C/--config-setting` in build or `-C/--config-settings`
  in `pip`. Below are the supported configuration options:

  ```toml
  [tool.scikit-build-core-conan]
  path = "."
  build = "missing"
  profile = "default"
  options = []
  settings = []
  config = []
  generator = "Ninja"
  output-folder = "build"
  ```



  Sometimes you may want to consume a local recipe rather than from the conan centre index. You can do this like this:
  ```toml
  [[tool.scikit-build-core-conan.local-recipes]]
  path = "path/to/recipe"
  name = "recipe"   # optional: package name if not specified in conanfile
  version = "0.0.1" # optional: package version if not specified in conanfile
  ```



  `scikit-build-core-conan` uses the same override system as `scikit-build-core`. For more details, check out the
  [documentation](https://scikit-build-core.readthedocs.io/en/latest/configuration.html#overrides) of `scikit-build-core`.

  For example:

  ```toml
  [[tool.scikit-build-core-conan.overrides]]
  if.platform-system = "linux"
  profile = "/path/to/profile"
  ```



  - **[endstone](https://github.com/EndstoneMC/endstone)**: A high-level plugin api for Minecraft: Bedrock Edition Dedicated Servers.


pkgId: 18eae14d18944d50c57c59ef60cb6fcc626645080add2ff22954bb544522faf0
name: python-scikit-hep-testdata-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for scikit-hep-testdata
url: https://github.com/scikit-hep/scikit-hep-testdata
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scikit-hep-testdata-0.5.1-1.src.rpm
location_href: Packages/python-scikit-hep-testdata-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Scikit-HEP][sk-badge]](https://scikit-hep.org/)
  [![PyPI version](https://img.shields.io/pypi/v/scikit-hep-testdata.svg?longCache=true)](https://pypi.org/project/scikit-hep-testdata/)
  [![Conda latest release](https://img.shields.io/conda/vn/conda-forge/scikit-hep-testdata.svg)](https://github.com/conda-forge/scikit-hep-testdata-feedstock)

  [![Github Actions badge](https://github.com/scikit-hep/scikit-hep-testdata/workflows/CI/badge.svg)](https://github.com/scikit-hep/scikit-hep-testdata/actions)
  [![Code Coverage](https://codecov.io/gh/scikit-hep/scikit-hep-testdata/graph/badge.svg?branch=main)](https://codecov.io/gh/scikit-hep/scikit-hep-testdata?branch=main)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/scikit-hep/scikit-hep-testdata/main.svg)](https://results.pre-commit.ci/latest/github/scikit-hep/scikit-hep-testdata/main)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  [sk-badge]: https://scikit-hep.org/assets/images/Scikit--HEP-Project-blue.svg

  A common package to provide example files (*e.g*. ROOT) for testing and developing packages against.
  The sample of files is representative of typical files found "in the wild".

  In addition to including some root files directly, this package adds some simple helper methods to
  get larger files from common open-access data repositories.


  To install:

  ```bash
  python -m pip install scikit-hep-testdata
  ```

  Once installed, absolute file paths can be resolved using the helper methods:

  ``` python
  from skhep_testdata import data_path

  filename = data_path("some_file.root")
  ```

  By default, if an unknown file is requested an exception is raised but this can be skipped by passing the above method `raise_missing=False`:

  ```python
  filename = data_path("unknown_file.root", raise_missing=False)
  ```

  The files are not stored on PyPI, so if installed from SDist/wheel, the "local"
  files will not be present, but will be downloaded from GitHub and cached in the
  `~/.local/skhepdata` directory. If you make an editable install from the Git repo,
  or if you set `SKHEP_DATA=1` when building/installing from the Git repo, you will
  have the data files locally.

  You can see all "local" files with `skhep_testdata.known_files`, and you can
  download all files at once with `skhep_testdata.download_all()`, optionally selecting
  the download cache directory.


  Some files, particularly large ones, for example, are not stored within this
  package and instead live on a remote server; we call these "remote files".  To
  obtain these use the same `data_path` method as above, however this will
  trigger the code to download and configure the remote file.  This might be slow
  the first time round but will subsequently be as fast as for a local file.
  WARNING: the local file caching system has not yet been applied to remote
  files.


  You can also interact with this package from the command-line:

  ```bash

  python -m skhep_testdata cms_hep_2012_tutorial/data.root


  python -m skhep_testdata --list


  python -m skhep_testdata --all --dir local
  ```

  You can also use `pipx run scikit-hep-testdata` to access the above CLI without installing.



  We're on the look out for new, interesting files!

  - *Large files*: If the file is particularly large, for example > 25 MB, it might be worth adding to an external open access data repository and adding a configuration here so that the internal helper methods can pull this down.
  - *Experiment data policies*: Please make sure you have permissions to add the file to this collection, and that any private or sensitive data has been appropriately masked, salted, or scrambled.


  The following lists describe the files known by this package.


  - [Listed here](src/skhep_testdata/data)


  - [CMS HEP public tutorial from 2012](http://opendata.cern.ch/record/50)



  We hereby acknowledge the contributors that made this project possible ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://benkrikler.github.io"><img src="https://avatars.githubusercontent.com/u/4083697?v=4?s=100" width="100px;" alt="benkrikler"/><br /><sub><b>benkrikler</b></sub></a><br /><a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=benkrikler" title="Code">💻</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=benkrikler" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jpivarski"><img src="https://avatars.githubusercontent.com/u/1852447?v=4?s=100" width="100px;" alt="Jim Pivarski"/><br /><sub><b>Jim Pivarski</b></sub></a><br /><a href="#maintenance-jpivarski" title="Maintenance">🚧</a> <a href="#data-jpivarski" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=jpivarski" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://iscinumpy.dev"><img src="https://avatars.githubusercontent.com/u/4616906?v=4?s=100" width="100px;" alt="Henry Schreiner"/><br /><sub><b>Henry Schreiner</b></sub></a><br /><a href="#maintenance-henryiii" title="Maintenance">🚧</a> <a href="#data-henryiii" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=henryiii" title="Code">💻</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=henryiii" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://cern.ch/eduardo.rodrigues"><img src="https://avatars.githubusercontent.com/u/5013581?v=4?s=100" width="100px;" alt="Eduardo Rodrigues"/><br /><sub><b>Eduardo Rodrigues</b></sub></a><br /><a href="#maintenance-eduardo-rodrigues" title="Maintenance">🚧</a> <a href="#data-eduardo-rodrigues" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=eduardo-rodrigues" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.matthewfeickert.com/"><img src="https://avatars.githubusercontent.com/u/5142394?v=4?s=100" width="100px;" alt="Matthew Feickert"/><br /><sub><b>Matthew Feickert</b></sub></a><br /><a href="#data-matthewfeickert" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=matthewfeickert" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://cs.purdue.edu/homes/das160"><img src="https://avatars.githubusercontent.com/u/11775615?v=4?s=100" width="100px;" alt="Pratyush Das"/><br /><sub><b>Pratyush Das</b></sub></a><br /><a href="#data-reikdas" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=reikdas" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://blog.jling.dev"><img src="https://avatars.githubusercontent.com/u/5306213?v=4?s=100" width="100px;" alt="Jerry Ling"/><br /><sub><b>Jerry Ling</b></sub></a><br /><a href="#data-Moelf" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=Moelf" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jonas-eschle"><img src="https://avatars.githubusercontent.com/u/17454848?v=4?s=100" width="100px;" alt="Jonas Eschle"/><br /><sub><b>Jonas Eschle</b></sub></a><br /><a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=jonas-eschle" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://giordonstark.com/"><img src="https://avatars.githubusercontent.com/u/761483?v=4?s=100" width="100px;" alt="Giordon Stark"/><br /><sub><b>Giordon Stark</b></sub></a><br /><a href="#data-kratsg" title="Data">🔣</a> <a href="https://github.com/scikit-hep/scikit-hep-testdata/commits?author=kratsg" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/veprbl"><img src="https://avatars.githubusercontent.com/u/245573?v=4?s=100" width="100px;" alt="Dmitry Kalinkin"/><br /><sub><b>Dmitry Kalinkin</b></sub></a><br /><a href="#data-veprbl" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.df.unito.it/do/docenti.pl/Show?_id=mperesan#tab-profilo"><img src="https://avatars.githubusercontent.com/u/17836610?v=4?s=100" width="100px;" alt="Michele Peresano"/><br /><sub><b>Michele Peresano</b></sub></a><br /><a href="#data-HealthyPear" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lobis"><img src="https://avatars.githubusercontent.com/u/35803280?v=4?s=100" width="100px;" alt="Luis Antonio Obis Aparicio"/><br /><sub><b>Luis Antonio Obis Aparicio</b></sub></a><br /><a href="#data-lobis" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/oshadura"><img src="https://avatars.githubusercontent.com/u/7012420?v=4?s=100" width="100px;" alt="Oksana Shadura"/><br /><sub><b>Oksana Shadura</b></sub></a><br /><a href="#data-oshadura" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nsmith-"><img src="https://avatars.githubusercontent.com/u/6587412?v=4?s=100" width="100px;" alt="Nicholas Smith"/><br /><sub><b>Nicholas Smith</b></sub></a><br /><a href="#data-nsmith-" title="Data">🔣</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/beojan"><img src="https://avatars.githubusercontent.com/u/3727925?v=4?s=100" width="100px;" alt="Beojan Stanislaus"/><br /><sub><b>Beojan Stanislaus</b></sub></a><br /><a href="#data-beojan" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.lukasheinrich.com"><img src="https://avatars.githubusercontent.com/u/2318083?v=4?s=100" width="100px;" alt="Lukas"/><br /><sub><b>Lukas</b></sub></a><br /><a href="#data-lukasheinrich" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/8me"><img src="https://avatars.githubusercontent.com/u/17862090?v=4?s=100" width="100px;" alt="Johannes Schumann"/><br /><sub><b>Johannes Schumann</b></sub></a><br /><a href="#data-8me" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ekauffma"><img src="https://avatars.githubusercontent.com/u/65742271?v=4?s=100" width="100px;" alt="Elliott Kauffman"/><br /><sub><b>Elliott Kauffman</b></sub></a><br /><a href="#data-ekauffma" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tomeichlersmith"><img src="https://avatars.githubusercontent.com/u/31970302?v=4?s=100" width="100px;" alt="Tom Eichlersmith"/><br /><sub><b>Tom Eichlersmith</b></sub></a><br /><a href="#data-tomeichlersmith" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/APN-Pucky"><img src="https://avatars.githubusercontent.com/u/4533248?v=4?s=100" width="100px;" alt="Alexander Puck Neuwirth"/><br /><sub><b>Alexander Puck Neuwirth</b></sub></a><br /><a href="#data-APN-Pucky" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ioanaif"><img src="https://avatars.githubusercontent.com/u/9751871?v=4?s=100" width="100px;" alt="ioanaif"/><br /><sub><b>ioanaif</b></sub></a><br /><a href="#data-ioanaif" title="Data">🔣</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification.


  - Many of the files collected directly within this package were collated originally by Jim Pivarski for [uproot](https://github.com/scikit-hep/uproot)


  This package uses `pytest` to run the unit tests. Install with `pip install scikit-hep-testdata[test]` or `pip install -e .[test]` (dev) to get the testing requirements.
  then run:

  ```bash
  pytest
  ```


pkgId: 64a5b3c15dc2a6ca4b71988ce4d412c31b1d0ce4e45b2348131f05c7d056bfb5
name: python-scikit-lego-help
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: Development documents and examples for scikit-lego
url: https://pypi.org/project/scikit-lego/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scikit-lego-0.9.4-1.src.rpm
location_href: Packages/python-scikit-lego-help-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/scikit-lego/month)](https://www.pepy.tech/projects/scikit-lego)
  [![Version](https://img.shields.io/pypi/v/scikit-lego)](https://pypi.org/project/scikit-lego/)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/scikit-lego.svg)](https://anaconda.org/conda-forge/scikit-lego)
  ![](https://img.shields.io/github/license/koaning/scikit-lego)
  ![](https://img.shields.io/pypi/pyversions/scikit-lego)
  ![](https://img.shields.io/github/contributors/koaning/scikit-lego)
  [![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)
  [![DOI](https://zenodo.org/badge/166836939.svg)](https://zenodo.org/badge/latestdoi/166836939)



  <a href="https://koaning.github.io/scikit-lego/"><img src="images/logo.png" width="35%" height="35%" align="right" /></a>

  We love scikit learn but very often we find ourselves writing
  custom transformers, metrics and models. The goal of this project
  is to attempt to consolidate these into a package that offers
  code quality/testing. This project started as a collaboration between
  multiple companies in the Netherlands but has since received contributions
  from around the globe. It was initiated by [Matthijs Brouns](https://www.mbrouns.com/)
  and [Vincent D. Warmerdam](https://koaning.io) as a tool to teach people how
  to contribute to open source.

  Note that we're not formally affiliated with the scikit-learn project at all,
  but we aim to strictly adhere to their standards.

  The same holds with lego. LEGO® is a trademark of the LEGO Group of companies which does not sponsor, authorize or endorse this project.



  Install `scikit-lego` via pip with

  ```bash
  python -m pip install scikit-lego
  ```

  Via [conda](https://conda.io/projects/conda/en/latest/) with

  ```bash
  conda install -c conda-forge scikit-lego
  ```

  Alternatively, to edit and contribute you can fork/clone and run:

  ```bash
  python -m pip install -e ".[dev]"
  python setup.py develop
  ```



  The documentation can be found [here](https://koaning.github.io/scikit-lego/).



  We offer custom metrics, models and transformers. You can import them just like you would
  in scikit-learn.

  ```python

  from sklearn.preprocessing import StandardScaler
  from sklearn.pipeline import Pipeline


  from sklego.preprocessing import RandomAdder
  from sklego.mixture import GMMClassifier

  ...

  mod = Pipeline([
      ("scale", StandardScaler()),
      ("random_noise", RandomAdder()),
      ("model", GMMClassifier())
  ])

  ...
  ```



  Here's a list of features that this library currently offers:

  - `sklego.datasets.load_abalone` loads in the abalone dataset
  - `sklego.datasets.load_arrests` loads in a dataset with fairness concerns
  - `sklego.datasets.load_chicken` loads in the joyful chickweight dataset
  - `sklego.datasets.load_heroes` loads a heroes of the storm dataset
  - `sklego.datasets.load_hearts` loads a dataset about hearts
  - `sklego.datasets.load_penguins` loads a lovely dataset about penguins
  - `sklego.datasets.fetch_creditcard` fetch a fraud dataset from openml
  - `sklego.datasets.make_simpleseries` make a simulated timeseries
  - `sklego.pandas_utils.add_lags` adds lag values in a pandas dataframe
  - `sklego.pandas_utils.log_step` a useful decorator to log your pipeline steps
  - `sklego.dummy.RandomRegressor` dummy benchmark that predicts random values
  - `sklego.linear_model.DeadZoneRegressor` experimental feature that has a deadzone in the cost function
  - `sklego.linear_model.DemographicParityClassifier` logistic classifier constrained on demographic parity
  - `sklego.linear_model.EqualOpportunityClassifier` logistic classifier constrained on equal opportunity
  - `sklego.linear_model.ProbWeightRegression` linear model that treats coefficients as probabilistic weights
  - `sklego.linear_model.LowessRegression` locally weighted linear regression
  - `sklego.linear_model.LADRegression` least absolute deviation regression
  - `sklego.linear_model.QuantileRegression` linear quantile regression, generalizes LADRegression
  - `sklego.linear_model.ImbalancedLinearRegression` punish over/under-estimation of a model directly
  - `sklego.naive_bayes.GaussianMixtureNB` classifies by training a 1D GMM per column per class
  - `sklego.naive_bayes.BayesianGaussianMixtureNB` classifies by training a bayesian 1D GMM per class
  - `sklego.mixture.BayesianGMMClassifier` classifies by training a bayesian GMM per class
  - `sklego.mixture.BayesianGMMOutlierDetector` detects outliers based on a trained bayesian GMM
  - `sklego.mixture.GMMClassifier` classifies by training a GMM per class
  - `sklego.mixture.GMMOutlierDetector` detects outliers based on a trained GMM
  - `sklego.meta.ConfusionBalancer` experimental feature that allows you to balance the confusion matrix
  - `sklego.meta.DecayEstimator` adds decay to the sample_weight that the model accepts
  - `sklego.meta.EstimatorTransformer` adds a model output as a feature
  - `sklego.meta.OutlierClassifier` turns outlier models into classifiers for gridsearch
  - `sklego.meta.GroupedPredictor` can split the data into runs and run a model on each
  - `sklego.meta.GroupedTransformer` can split the data into runs and run a transformer on each
  - `sklego.meta.SubjectiveClassifier` experimental feature to add a prior to your classifier
  - `sklego.meta.Thresholder` meta model that allows you to gridsearch over the threshold
  - `sklego.meta.RegressionOutlierDetector` meta model that finds outliers by adding a threshold to regression
  - `sklego.meta.ZeroInflatedRegressor` predicts zero or applies a regression based on a classifier
  - `sklego.preprocessing.ColumnCapper` limits extreme values of the model features
  - `sklego.preprocessing.ColumnDropper` drops a column from pandas
  - `sklego.preprocessing.ColumnSelector` selects columns based on column name
  - `sklego.preprocessing.InformationFilter` transformer that can de-correlate features
  - `sklego.preprocessing.IdentityTransformer` returns the same data, allows for concatenating pipelines
  - `sklego.preprocessing.OrthogonalTransformer` makes all features linearly independent
  - `sklego.preprocessing.TypeSelector` selects columns based on type
  - `sklego.preprocessing.RandomAdder` adds randomness in training
  - `sklego.preprocessing.RepeatingBasisFunction` repeating feature engineering, useful for timeseries
  - `sklego.preprocessing.DictMapper` assign numeric values on categorical columns
  - `sklego.preprocessing.OutlierRemover` experimental method to remove outliers during training
  - `sklego.preprocessing.MonotonicSplineTransformer` re-uses `SplineTransformer` in an attempt to make monotonic features
  - `sklego.model_selection.GroupTimeSeriesSplit` timeseries Kfold for groups with different amount of observations per group
  - `sklego.model_selection.KlusterFoldValidation` experimental feature that does K folds based on clustering
  - `sklego.model_selection.TimeGapSplit` timeseries Kfold with a gap between train/test
  - `sklego.pipeline.DebugPipeline` adds debug information to make debugging easier
  - `sklego.pipeline.make_debug_pipeline` shorthand function to create a debugable pipeline
  - `sklego.metrics.correlation_score` calculates correlation between model output and feature
  - `sklego.metrics.equal_opportunity_score` calculates equal opportunity metric
  - `sklego.metrics.p_percent_score` proxy for model fairness with regards to sensitive attribute
  - `sklego.metrics.subset_score` calculate a score on a subset of your data (meant for fairness tracking)



  We want to be rather open here in what we accept but we do demand three
  things before they become added to the project:

  1. any new feature contributes towards a demonstrable real-world usecase
  2. any new feature passes standard unit tests (we use the ones from scikit-learn)
  3. the feature has been discussed in the issue list beforehand

  We automate all of our testing and use pre-commit hooks to keep the code working.

rpm_license:
  MIT License  Copyright (c) 2019 vincent d warmerdam  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: 6eae8c1705d198d51535f66f266f51ffcd32f1cd62d2c190741a78c636f32c6f
name: python-scikit-posthocs-help
arch: noarch
version: 0.11.2
epoch: 0
release: 1
summary: Development documents and examples for scikit-posthocs
url: https://pypi.org/project/scikit-posthocs/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scikit-posthocs-0.11.2-1.src.rpm
location_href: Packages/python-scikit-posthocs-help-0.11.2-1.noarch.rpm
checksum_type: sha256
description:
  **scikit-posthocs** is a Python package that provides post hoc tests for
  pairwise multiple comparisons that are usually performed in statistical
  data analysis to assess the differences between group levels if a
  statistically significant result of ANOVA test has been obtained.
  **scikit-posthocs** is tightly integrated with Pandas DataFrames and NumPy
  arrays to ensure fast computations and convenient data import and storage.
  This package will be useful for statisticians, data analysts, and researchers
  who use Python in their work.

rpm_license:
  Copyright (c) 2024 Maksim Terpilovskii  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: 5517b7ae77e5542c60dd07a38368298b259b75b3a4056982adbb912f380bfa59
name: python-scikits-odes-core-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for scikits-odes-core
url: http://cage.ugent.be/~bm/progs.html
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scikits-odes-core-3.0.0-1.src.rpm
location_href: Packages/python-scikits-odes-core-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/scikits-odes/badge/?version=stable)](https://scikits-odes.readthedocs.org/en/stable/?badge=stable)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5511691.svg)](https://doi.org/10.5281/zenodo.5511691)
  [![Paper DOI](http://joss.theoj.org/papers/10.21105/joss.00165/status.svg)](https://doi.org/10.21105/joss.00165)

  This package contains the core support classes for ODES.
  `pip install scikits-odes` to get all the available solvers.


  ODES is a scikit for Python 3.7+ offering extra ode/dae solvers, as an extension
  to what is available in scipy.
  The documentation is available at [Read The
  Docs](https://scikits-odes.readthedocs.io/), and API docs can be found at
  https://bmcage.github.io/odes.


  ODES provides interfaces to the following solvers:
  * BDF linear multistep method for stiff problems (CVODE and IDA from SUNDIALS)
  * Adams-Moulton linear multistep method for nonstiff problems (CVODE and IDA
    from SUNDIALS)
  * Explicit Runge-Kutta method of order (4)5 with stepsize control (*dopri5*
    from `scipy.integrate`)
  * Explicit Runge-Kutta method of order 8(5,3) with stepsize control (*dop853*
    from `scipy.integrate`)
  * Historical solvers: *lsodi* and *ddaspk* are available for comparison reasons.
    Use IDA instead! Note that *lsodi* fails on architecture *aarch64*.



  A simple example solving the Van der Pol oscillator is as follows:

  ```python
  import matplotlib.pyplot as plt
  import numpy as np
  from scikits.odes import ode

  t0, y0 = 1, np.array([0.5, 0.5])  # initial condition
  def van_der_pol(t, y, ydot):
      """ we create rhs equations for the problem"""
      ydot[0] = y[1]
      ydot[1] = 1000*(1.0-y[0]**2)*y[1]-y[0]

  solution = ode('cvode', van_der_pol, old_api=False).solve(np.linspace(t0,500,200), y0)
  plt.plot(solution.values.t, solution.values.y[:,0], label='Van der Pol oscillator')
  plt.show()
  ```

  For simplicity there is also a convenience function `odeint` wrapping the ode
  solver class. See the [User Guide](https://scikits-odes.readthedocs.io/) for a
  simple example for `odeint`, as well as simple examples for object orientated
  interfaces and further examples using ODES solvers.



  You can learn by example from following code that uses ODES:
  * Centrifuge simulation, a wrapper around the ida solver: see
    [centrifuge-1d](https://github.com/bmcage/centrifuge-1d/blob/master/centrifuge1d/modules/shared/solver.py)

  You have a project using odes? Do a pull request to add your project.


  If you use ODES as part of your research, can you please cite the
  [ODES JOSS paper](https://doi.org/10.21105/joss.00165). Additionally, if you use
  one of the SUNDIALS solvers, we strongly encourage you to cite the
  [SUNDIALS papers](https://computation.llnl.gov/projects/sundials/publications).

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


pkgId: 67b13603c05bc1ad7b015e1caed0c77e5d0ce4d5b1f67bda0a6238124b42dc00
name: python-scikits-odes-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for scikits-odes
url: http://cage.ugent.be/~bm/progs.html
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scikits-odes-3.0.0-1.src.rpm
location_href: Packages/python-scikits-odes-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/scikits-odes/badge/?version=stable)](https://scikits-odes.readthedocs.org/en/stable/?badge=stable)
  [![Version](https://img.shields.io/pypi/v/scikits.odes.svg)](https://pypi.python.org/pypi/scikits.odes/)
  [![License](https://img.shields.io/pypi/l/scikits.odes.svg)](https://pypi.python.org/pypi/scikits.odes/)
  [![Supported versions](https://img.shields.io/pypi/pyversions/scikits.odes.svg)](https://pypi.python.org/pypi/scikits.odes/)
  [![Supported implementations](https://img.shields.io/pypi/implementation/scikits.odes.svg)](https://pypi.python.org/pypi/scikits.odes/)
  [![PyPI](https://img.shields.io/pypi/status/scikits.odes.svg)](https://pypi.python.org/pypi/scikits.odes/)


  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5511691.svg)](https://doi.org/10.5281/zenodo.5511691)


  [![Paper DOI](http://joss.theoj.org/papers/10.21105/joss.00165/status.svg)](https://doi.org/10.21105/joss.00165)


  ODES is a scikit for Python 3.7+ offering extra ode/dae solvers, as an extension to what is available in scipy.
  The documentation is available at [Read The Docs](https://scikits-odes.readthedocs.io/), and API docs can be found at https://bmcage.github.io/odes.


  ODES provides interfaces to the following solvers:
  * BDF linear multistep method for stiff problems (CVODE and IDA from SUNDIALS)
  * Adams-Moulton linear multistep method for nonstiff problems (CVODE and IDA from SUNDIALS)
  * Explicit Runge-Kutta method of order (4)5 with stepsize control ( *dopri5* from `scipy.integrate`)
  * Explicit Runge-Kutta method of order 8(5,3) with stepsize control ( *dop853* from `scipy.integrate`)
  * Historical solvers: *lsodi* and *ddaspk* are available for comparison reasons. Use IDA instead! Note that *lsodi* fails on architecture *aarch64*.



  A simple example solving the Van der Pol oscillator is as follows:

  ```python
  import matplotlib.pyplot as plt
  import numpy as np
  from scikits.odes import ode

  t0, y0 = 1, np.array([0.5, 0.5])  # initial condition
  def van_der_pol(t, y, ydot):
      """ we create rhs equations for the problem"""
      ydot[0] = y[1]
      ydot[1] = 1000*(1.0-y[0]**2)*y[1]-y[0]

  solution = ode('cvode', van_der_pol, old_api=False).solve(np.linspace(t0,500,200), y0)
  plt.plot(solution.values.t, solution.values.y[:,0], label='Van der Pol oscillator')
  plt.show()
  ```

  For simplicity there is also a convenience function `odeint` wrapping the ode solver class. See the [User Guide](https://scikits-odes.readthedocs.io/) for a simple example for `odeint`, as well as simple examples for object orientated interfaces and further examples using ODES solvers.



  You can learn by example from following code that uses ODES:
  * Centrifuge simulation, a wrapper around the ida solver: see [centrifuge-1d](https://github.com/bmcage/centrifuge-1d/blob/master/centrifuge1d/modules/shared/solver.py)

  You have a project using odes? Do a pull request to add your project.


  If you use ODES as part of your research, can you please cite the
  [ODES JOSS paper](https://doi.org/10.21105/joss.00165). Additionally, if you use
  one of the SUNDIALS solvers, we strongly encourage you to cite the
  [SUNDIALS papers](https://computation.llnl.gov/projects/sundials/publications).

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


pkgId: 43928437c4a191c1614015105259d6afe9ec63666f5d8878514835d05a4a12fa
name: python-scilogger-help
arch: noarch
version: 1.2.2
epoch: 0
release: 1
summary: Development documents and examples for scilogger
url: https://github.com/otvam/scilogger
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scilogger-1.2.2-1.src.rpm
location_href: Packages/python-scilogger-help-1.2.2-1.noarch.rpm
checksum_type: sha256
description:
  > * **Repository: [github.com/otvam/scilogger](https://github.com/otvam/scilogger)**
  > * **PyPi: [pypi.org/project/scilogger](https://pypi.org/project/scilogger)**
  > * **Conda: [anaconda.org/conda-forge/scilogger](https://anaconda.org/conda-forge/scilogger)**



  **SciLogger** is a **Python Logging** module:
  * Specially targeted for **scientific applications**.
  * Use a **global timer** to measure the **elapsed time**.
  * Provide a class for **timing code blocks**.
  * Definition of **custom indentation levels**.
  * Definition of **colors** for the logging levels.

  **SciLogger** is using a global **INI configuration** file:
  * First, the **default configuration** is loaded (`scilogger/scilogger.ini`).
  * Afterward, a **custom file** can be loaded with an environment variable (`SCILOGGER`)

  SciLogger is written in Python without any external dependencies.
  SciLogger is respecting **semantic versioning** (starting from version 1.2).



  * This logging module is **based** on the **Python logging module**.
  * The philosophy of this logging module is slightly different.
  * Mixing both modules can create strange/incorrect behaviors.



  An example is located in the `example` folder of the repository:
  * `run_logger.py` contains an example file for the logger
  * `configlogger.ini` contains a custom configuration file

  ```bash

  export SCILOGGER="configlocal.ini"


  python run_logger.py
  ```



  * Repository: https://github.com/otvam/scilogger
  * Releases: https://github.com/otvam/scilogger/releases
  * Tags: https://github.com/otvam/scilogger/tags
  * Issues: https://github.com/otvam/scilogger/issues
  * PyPi: https://pypi.org/project/scilogger
  * Conda: https://anaconda.org/conda-forge/scilogger



  * **Thomas Guillod**
  * Email: guillod@otvam.ch
  * Website: https://otvam.ch



  > (c) 2023 - Thomas Guillod
  >
  >  BSD 2-Clause "Simplified" License


pkgId: b5c928989c3432a215ee738072fc645cb5424f26fb19852d5e51e2bc9340a770
name: python-scimap-help
arch: noarch
version: 2.2.8
epoch: 0
release: 1
summary: Development documents and examples for scimap
url: https://pypi.org/project/scimap/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scimap-2.2.8-1.src.rpm
location_href: Packages/python-scimap-help-2.2.8-1.noarch.rpm
checksum_type: sha256
description:
  <br>

  [![build: Unix-Mac-Win](https://github.com/ajitjohnson/scimap/actions/workflows/build-unix-mac-win.yml/badge.svg)](https://github.com/ajitjohnson/scimap/actions/workflows/build-unix-mac-win.yml)
  [![Docs](https://github.com/ajitjohnson/scimap/actions/workflows/docs.yml/badge.svg)](https://github.com/ajitjohnson/scimap/actions/workflows/docs.yml)
  [![Downloads](https://pepy.tech/badge/scimap)](https://pepy.tech/project/scimap)
  [![PyPI Version](https://img.shields.io/pypi/v/scimap.svg)](https://pypi.org/project/scimap)
  [![PyPI License](https://img.shields.io/pypi/l/scimap.svg)](https://pypi.org/project/scimap)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.06604/status.svg)](https://doi.org/10.21105/joss.06604)

  <br>

  <img src="./docs/assets/scimap_logo.jpg" style="max-width:700px;width:100%" >

  <br>

  *Scimap* is a scalable toolkit for analyzing spatial molecular data. The underlying framework is generalizable to spatial datasets mapped to XY coordinates. The package uses the [anndata](https://anndata.readthedocs.io/en/stable/anndata.AnnData.html) framework making it easy to integrate with other popular single-cell analysis toolkits. It includes preprocessing, phenotyping, visualization, clustering, spatial analysis and differential spatial testing. The Python-based implementation efficiently deals with large datasets of millions of cells.


  Nirmal et al., (2024). SCIMAP: A Python Toolkit for Integrated Spatial Analysis of Multiplexed Imaging Data. *Journal of Open Source Software*, 9(97), 6604, [https://doi.org/10.21105/joss.06604](https://joss.theoj.org/papers/10.21105/joss.06604#)



  We strongly recommend installing `scimap` in a fresh virtual environment.

  ```

  conda create --name scimap python=3.10
  conda activate scimap
  ```

  Install `scimap` directly into an activated virtual environment:

  **Firstly, we suggest installing `scimap` and `napari` together to enable visualization out of the box. Keep in mind, `napari` needs a GUI toolkit, such as PyQt. If you run into any issues because of your computer's operating system, install `scimap` and `napari` separately by following the guidance in `napari's` documentation.**

  Here's how you can install both using pip:

  ```python
  pip install "scimap[napari]"
  ```

  **If you encounter a problem with PyQt6 during the installation, you can install `scimap` alone first. Later on, if you find you need `napari`, you can go ahead and install it by itself.**

  To install just `scimap`:

  ```python
  pip install scimap
  ```

  After installation, the package can be imported as:

  ```python
  $ python
  >>> import scimap as sm
  ```






  *Scimap* development was led by [Ajit Johnson Nirmal](https://ajitjohnson.com/), Harvard Medical School.
  Check out other tools from the [Nirmal Lab](https://nirmallab.com/tools/).



  Interested in contributing to the package? Check out our guidelines at [https://scimap.xyz/contribute/](https://scimap.xyz/contribute/) for detailed instructions.



  This work was supported by the following NIH grant K99-CA256497


pkgId: c932d6541d9fb1f2215823111c58ad18a4771c95f314dbbe306321066c69da67
name: python-scipeds-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for scipeds
url: https://pypi.org/project/scipeds/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scipeds-0.0.2-1.src.rpm
location_href: Packages/python-scipeds-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for working with [IPEDS](https://nces.ed.gov/ipeds/) [data](https://nces.ed.gov/ipeds/datacenter/DataFiles.aspx).

  Read the full documentation [here](https://scipeds.onrender.com/).

  <a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
      <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
  </a>





  ```bash

  pip install ipeds
  ```



  From the shell:

  ```bash
  scipeds download-db
  ```

  or from python / a notebook:

  ```python
  import scipeds

  scipeds.download_db()
  ```



  ```python
  from scipeds.data.completions import CompletionsQueryEngine
  from scipeds.data.queries import (
      FieldTaxonomy,
      QueryFilters,
  )

  engine = CompletionsQueryEngine()
  ```

  Use a pre-baked query:
  ```python
  gender_df = engine.field_totals_by_grouping(
      grouping="gender",
      taxonomy=FieldTaxonomy.ncses_field_group
  )
  ```

  or write your own using [duckdb SQL syntax](https://duckdb.org/docs/sql/introduction.html):

  ```python
  from scipeds.constants import COMPLETIONS_TABLE

  df = engine.get_df_from_query(f"""
      SELECT *
      FROM {COMPLETIONS_TABLE}
      LIMIT 10;
  """)
  ```

  For more detailed usage, see the [Usage page](usage.ipynb) or the [engine API Reference](data.md).





  `scipeds` is a Python package for working with data from IPEDS. Specifically, `scipeds` makes it easier for people to analyze data from IPEDS by pre-processing and standardizing IPEDS data into a database and providing some Python tooling for querying that database.

  `scipeds` is _not_ a tool for working with raw IPEDS data. For that, you should download data directly from [IPEDS](https://nces.ed.gov/ipeds/).

  Full `scipeds` documentation can be found at [this link](https://scipeds.onrender.com/), and the source code is avilable on [GitHub](https://github.com/scienceforamerica/scipeds).



  `scipeds` currently supports the following datasets / survey components:

  - IPEDS Completions by program (6-digit CIP code), award level, race/ethnicity, and gender from 1995-2023
  - IPEDS Institutional Characteristics Directory Information from 2011-2023



  We provide functionality to reproduce our pre-processing of the IPEDS data. To recreate the pre-processed database, you can clone the `scipeds` [repository](https://github.com/scienceforamerica/scipeds), download the raw data, and re-run the pipeline code in `pipeline/`. Decisions about how to convert / crosswalk data across different years and handle other edge cases such as missing data are contained in the pipeline code.



  While IPEDS provides a large volume of data about higher education in the United States, working with IPEDS data can be challenging! Many things have changed in the time that data has been reported to IPEDS, making it non-trivial to join datasets across different time periods to consistently measure changes over time.

  In the process of their own work, the authors found it useful to create tools to make it easier to analyze IPEDS data and hoped that the tools they created would be useful to others as well.



  `scipeds` was created by [Science for America](https://www.scienceforamerica.org/) as part of its mission to address urgent challenges in STEM education.


pkgId: f4c131171a83f297ceac4bdd563f6f3c528e7cc3d2ad46294bc7274fbe455b60
name: python-scipy-doctest-help
arch: noarch
version: 1.6
epoch: 0
release: 1
summary: Development documents and examples for scipy-doctest
url: https://pypi.org/project/scipy-doctest/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scipy-doctest-1.6-1.src.rpm
location_href: Packages/python-scipy-doctest-help-1.6-1.noarch.rpm
checksum_type: sha256
description:
  This project extends the standard library `doctest` module to allow flexibility
  and easy customization of finding, parsing and checking code examples in
  documentation.

  Can be used either as drop-in `doctest` replacement or through the `pytest`
  integration. Uses a floating-point aware doctest checker by default.



  Having examples in the documentation is great. Having wrong examples in the
  documentation is not that great however.

  The standard library `doctest` module is great for making sure that docstring
  examples are correct. However, the `doctest` module is limited in several
  respects. Consider:

  ```
   >>> np.array([1/3, 2/3, 3/3])   # doctest: +SKIP
   array([0.333, 0.669, 1])
  ```

  This looks reasonably clear but does not work, in three different ways.
  _First_, `1/3` is not equal to 0.333 because floating-point arithmetic.
  _Second_, `numpy` adds whitespace to its output, this whitespace confuses the
  `doctest`, which is whitespace-sensitive. Therefore, we added a magic directive,
   `+SKIP` to avoid a doctest error. _Third_, the example is actually
  wrong---notice `0.669` which is not equal to `2/3` to three sig figs. The error
  went unnoticed by the doctester also because of the `+SKIP` directive.

  We believe these `# doctest: +SKIP` directives do not add any value to
  a human reader, and should not be present in the documentation.

  This package defines modified doctesting routines which fix these deficiencies.
  Its main features are

  - *Doctesting is floating-point aware.* In a nutshell, the core check is
    `np.allclose(want, got, atol=..., rtol=...)`, with user-controllable abs
    and relative tolerances. In the example above (_sans_ `# doctest: +SKIP`),
    `want` is the desired output, `array([0.333, 0.669, 1])` and `got` is the
    actual output from numpy: `array([0.33333333, 0.66666667, 1.        ])`.

  - *Human-readable skip markers.* Consider
    ```
    >>> np.random.randint(100)
    42     # may vary
    ```
  Note that the markers (by default, `"# may vary"` and `"# random"`) can be applied
  to either an example's output, or its source.

  Also note a difference with respect to the standard `# doctest: +SKIP`: the latter
  skips the example entirely, while these additional markers only skip checking
  the output. Thus the example source needs to be valid python code still.

  - A user-configurable list of *stopwords*. If an example contains a stopword,
    it is checked to be valid python, but the output is not checked. This can
    be useful e.g. for not littering the documentation with the output of
    `import matplotlib.pyplot as plt; plt.xlim([2.3, 4.5])`.

  - A user-configurable list of *pseudocode* markers. If an example contains one
    of these markers, it is considered pseudocode and is not checked.
    This is useful for `from example import some_functions` and similar stanzas.

  - A `# doctest: +SKIPBLOCK` option flag to skip whole blocks of pseudocode. Here
    a 'block' is a sequence of doctest examples without any intervening text.

  - *Doctest discovery* is somewhat more flexible then the standard library
    `doctest` module. Specifically, one can use `testmod(module, strategy='api')`
    to only examine public objects of a module. This is helpful for complex
    packages, with non-trivial internal file structure. Alternatively, the default
    value of `strategy=None` is equivalent to the standard `doctest` module
    behavior.

  - *User configuration*. Essentially all aspects of the behavior are user
    configurable via a `DTConfig` instance attributes. See the `DTConfig`
    docstring for details.



  ```
  $ pip install scipy-doctest
  $ pytest --pyargs scipy_doctest
  ```



  The API of the package has two layers: the basic layer follows the API of the
  standard library `doctest` module, and we strive to provide drop-in replacements,
  or nearly so.

  The other layer is the `pytest` plugin.



  To run doctests on your package or project, follow these steps:

  1. **Install the plugin**

  ```bash
  pip install scipy-doctest
  ```

  2. **Register or load the plugin**

  Next, you need to register or load the pytest plugin within your test module or `conftest.py` file.

  To do this, add the following line of code:

  ```python


  pytest_plugins = "scipy_doctest"
  ```

  Check out the [pytest documentation](https://docs.pytest.org/en/stable/how-to/writing_plugins.html#requiring-loading-plugins-in-a-test-module-or-conftest-file) for more information on requiring/loading plugins in a test module or `conftest.py` file.

  3. **Run doctests**

  Once the plugin is registered, run the doctests by executing the following command:

  ```bash
  $ python -m pytest --doctest-modules
  ```
  or
  ```bash
  $ pytest --pyargs <your-package> --doctest-modules
  ```

  By default, all doctests are collected. To only collect public objects, `strategy="api"`,
  use the command flag

  ```bash
  $ pytest --pyargs <your-package> --doctest-modules --doctest-collect=api
  ```

  See [More fine-grained control](https://github.com/scipy/scipy_doctest#More-fine-grained-control) section
  for details on how to customize the behavior.




  The use of `pytest` is optional, and you can use the `doctest` layer API.
  For example,

  ```
  >>> from scipy import linalg
  >>> from scipy_doctest import testmod
  >>> res, hist = testmod(linalg, strategy='api')
  >>> res
  TestResults(failed=0, attempted=764)
  ```
  The second return value, `hist` is a dict which maps the names of the objects
  to the numbers of failures and attempts for individual examples.

  For more details, see the `testmod` docstring. Other useful functions are
  `find_doctests`, `run_docstring_examples` and `testfile` (the latter two mimic
  the behavior of the eponymous functions of the `doctest` module).




  There is a basic CLI, which also mimics that of the `doctest` module:
  ```
  $ python -m scipy_doctest foo.py
  ```

  Note that, just like `$ python -m doctest foo.py`, this may
  fail if `foo.py` is a part of a package due to package imports.

  Text files can also be CLI-checked:
  ```
  $ python -m scipy_doctest bar.rst
  ```

  Notice that the command-line usage only uses the default `DTConfig` settings.




  More fine-grained control of the functionality is available via the following
  classes

  |   Class     |  `doctest` analog  |
  |-------------|--------------------|
  | `DTChecker` | `DocTestChecker`   |
  | `DTParser`  | `DocTestParser`    |
  | `DTRunner`  | `DocTestRunner`    |
  | `DTFinder`  | `DocTestFinder`    |
  | `DTContext` |       --           |

  The `DTContext` class is just a bag class which holds various configuration
  settings as attributes.  An instance of this class is passed around, so user
  configuration is simply creating an instance, overriding an attribute and
  passing the instance to `testmod` or constructors of `DT*` objects. Defaults
  are provided, based on a long-term usage in SciPy.

  See the [DTConfig docstring](https://github.com/scipy/scipy_doctest/blob/main/scipy_doctest/impl.py#L24)
  for the full set of attributes that allow you to fine-tune your doctesting experience.

  To set any of these attributes, create an instance of `DTConfig` and assign the attributes
  in a usual way.

  If using the pytest plugin, it is convenient to use the default instance, which
  is predefined in `scipy_doctest/conftest.py`. This instance will be automatically
  passed around via an
  [attribute of pytest's `Config` object](https://github.com/scipy/scipy_doctest/blob/58ff06a837b7bff1dbac6560013fc6fd07952ae2/scipy_doctest/plugin.py#L39).



  ```
  dt_config = DTConfig()
  ```

  or, if using pytest,

  ```python
  from scipy_doctest.conftest import dt_config   # a DTConfig instance with default settings
  ```

  and then

  ```
  dt_config.rndm_markers = {'# unintialized'}

  dt_config.stopwords = {'plt.', 'plt.hist', 'plt.show'}

  dt_config.local_resources = {
      'scipy_doctest.tests.local_file_cases.local_files': ['scipy_doctest/tests/local_file.txt'],
      'scipy_doctest.tests.local_file_cases.sio': ['scipy_doctest/tests/octave_a.mat']
  }

  dt_config.skiplist = {
      'scipy.special.sinc',
      'scipy.misc.who',
      'scipy.optimize.show_options'
  }
  ```

  If you don't set these attributes, the [default settings](https://github.com/scipy/scipy_doctest/blob/58ff06a837b7bff1dbac6560013fc6fd07952ae2/scipy_doctest/impl.py#L94) of the attributes are used.




  By default, we use the floating-point aware `DTChecker`. If you want to use an
  alternative checker, all you need to do is to define the corresponding class,
  and add an attribute to the `DTConfig` instance. For example,


  ```
  class VanillaOutputChecker(doctest.OutputChecker):
      """doctest.OutputChecker to drop in for DTChecker.

      LSP break: OutputChecker does not have __init__,
      here we add it to agree with DTChecker.
      """
      def __init__(self, config):
          pass
  ```

  and

  ```
  dt_config = DTConfig()
  dt_config.CheckerKlass = VanillaOutputChecker
  ```

  See [a pytest example](https://github.com/scipy/scipy_doctest/blob/main/scipy_doctest/tests/test_pytest_configuration.py#L63)
  and [a doctest example](https://github.com/scipy/scipy_doctest/blob/main/scipy_doctest/tests/test_runner.py#L94)
  for more details.





  NumPy wraps `scipy-doctest` with the `spin` command

  ```
  $ spin check-docs
  ```

  SciPy wraps `scipy-doctest` with custom `dev.py` commands:

  ```
  $ python dev.py smoke-docs    # check docstrings
  $ python dev.py smoke-tutorials   # ReST user guide tutorials
  ```





  Here is a (non-exhaustive) list of possible gotchas:

  - *In-place development builds*.

  Some tools (looking at you `meson-python`) simulate in-place builds with a
  `build-install` directory. If this directory is located under the project root,
  `pytest` is getting confused by duplicated items under the root and build-install
  folders.

  The solution is to make pytest only look into the `build-install` directory
  (the specific path to `build-install` may vary):

  ```
  $ pytest build-install/lib/python3.10/site-packages/scipy/ --doctest-modules
  ```

  instead of `$ pytest --pyargs scipy`.

  If push comes to shove, you may try using the magic env variable:
  ` PY_IGNORE_IMPORTMISMATCH=1 pytest ...`,
  however the need usually indicates an issue with the package itself.
  (see [gh-107](https://github.com/scipy/scipy_doctest/pull/107) for an example).

  - *Optional dependencies are not that optional*

  If your package contains optional dependencies, doctests do not know about them
  being optional. So you either guard the imports in doctests (yikes!), or
  the collections fails if dependencies are not available.

  The solution is to explicitly `--ignore` the paths to modules with optionals.
  (or, equivalently, use `DTConfig.pytest_extra_ignore` list):

  ```
  $ pytest --ignore=/build-install/lib/scipy/python3.10/site-packages/scipy/_lib ...
  ```

  Note that installed packages are no different:

  ```
  $ pytest --pyargs scipy --doctest-modules --ignore=/path/to/installed/scipy/_lib
  ```

  - *Doctest collection strategies*

  The default collection strategy follows `doctest` module and `pytest`. This leads
  to duplicates if your package has the split between public and \_private modules,
  where  public modules re-export things from private ones. The solution is to
  use `$ pytest --doctest-collect=api` CLI switch: with this, only public
  objects will be collected.

  The decision on what is public is as follows: an object is public iff

  - it is included into the `__all__` list of a public module;
  - the name of the object does not have a leading underscore;
  - the name of the module from which the object is collected does not have
    a leading underscore.

  Consider an example: `scipy.linalg.det` is defined in `scipy/linalg/_basic.py`,
  so it is collected twice, from `_basic.py` and from `__init__.py`. The rule above
  leads to

  - `scipy.linalg._basic.det`, collected from `scipy/linalg/_basic.py`, is private.
  - `scipy.linalg.det`, collected from `scipy/linalg/__init__.py`, is public.


  - *`pytest`'s assertion rewriting*

  In some rare cases you may need to either explicitly register the `scipy_doctest`
  package with the `pytest` assertion rewriting machinery, or ask it to avoid rewriting
  completely, via `pytest --assert=plain`.
  See [the `pytest documentation`](https://docs.pytest.org/en/7.1.x/how-to/assert.html)
  for more details.

  In general, rewriting assertions is not very useful for doctests, as the
  output on error is fixed by the doctest machinery anyway. Therefore, we believe
  adding `--assert=plain` is reasonable.




  - `pytest` provides some limited floating-point aware `NumericLiteralChecker`.

  - `pytest-doctestplus` plugin from the `AstroPy` project has similar goals.
    The package is well established and widely used. From a user perspective, main
    differences are: (i) `pytest-doctestplus` is more sensitive to formatting,
    including whitespace---thus if numpy tweaks its output formatting, doctests
    may start failing; (ii) there is still a need for `# doctest: +FLOAT_CMP`
    directives.

    This project takes a different approach: in addition to plugging into `pytest`,
    we closely follow the `doctest` API and implementation, which are naturally
    way more stable then `pytest`.

  - `NumPy` and `SciPy` were using modified doctesting in their `refguide-check` utilities.
    These utilities are tightly coupled to their libraries, and have been reported
    to be not easy to reason about, work with, and extend to other projects.

    This project is mainly the core functionality of the modified
    `refguide-check` doctesting, extracted to a separate package.
    We believe having it separate simplifies both addressing the needs of these
    two packages, and potential adoption by other projects.




  This package is work in progress. Contributions are most welcome!
  Please don't hesitate to open an issue in the tracker or send a pull request.

  The current location of the issue tracker is https://github.com/scipy/scipy_doctest.


pkgId: 516f2dabf11f5d220aa79483fbf15210236007b7e3a32559907941eb3d737a53
name: python-scipy-events-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for scipy-events
url: https://pypi.org/project/scipy-events/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scipy-events-0.4.0-1.src.rpm
location_href: Packages/python-scipy-events-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Copier Badge][copier-badge]][copier-url]
  [![Pixi Badge][pixi-badge]][pixi-url]
  ![License][license-badge]
  [![CI Badge][ci-badge]][ci-url]
  [![conda-forge Badge][conda-forge-badge]][conda-forge-url]
  [![PyPI Badge][pypi-badge]][pypi-url]
  [![Python version Badge][pypi-version-badge]][pypi-version-url]

  A library of events for `scipy.integrate.solve_ivp`.

  It provides the following events:

  - `ChangeWhen` to apply a change when a given event happens.
  - `ChangeAt` to apply a change at some given times.



  ```python
  import numpy as np
  from scipy_events import ChangeAt, solve_ivp

  result = solve_ivp(
      lambda t, y: -y,
      t_span=(0, 16),
      y0=[1],
      events=[
          ChangeAt(
              times=[4, 8],
              change=lambda t, y, args: (np.full_like(y, 1), args),
          )
      ],
  )
  ```

  ![](https://raw.githubusercontent.com/maurosilber/scipy-events/refs/heads/main/docs/figures/change-at.png)

  ```python
  import numpy as np
  from scipy_events import ChangeWhen, solve_ivp

  result = solve_ivp(
      lambda t, y: -y,
      t_span=(0, 16),
      y0=[1],
      events=[
          ChangeWhen(
              condition=lambda t, y: y[0] - 1e-2,
              change=lambda t, y, args: (np.full_like(y, 1), args),
          )
      ],
  )
  ```

  ![](https://raw.githubusercontent.com/maurosilber/scipy-events/refs/heads/main/docs/figures/change-when.png)



  Using [pixi][pixi-url],
  install from PyPI with:

  ```sh
  pixi add --pypi scipy-events
  ```

  or install the latest development version from GitHub with:

  ```sh
  pixi add --pypi scipy-events@https://github.com/maurosilber/scipy-events.git
  ```

  Otherwise,
  use `pip` or your `pip`-compatible package manager:

  ```sh
  pip install scipy-events  # from PyPI
  pip install git+https://github.com/maurosilber/scipy-events.git  # from GitHub
  ```



  This project is managed by [pixi][pixi-url].
  You can install it for development using:

  ```sh
  git clone https://github.com/maurosilber/scipy-events
  cd scipy-events
  pixi run pre-commit-install
  ```

  Pre-commit hooks are used to lint and format the project.



  Run tests using:

  ```sh
  pixi run test
  ```



  When a tagged commit is pushed to GitHub,
  the GitHub Action defined in `.github/workflows/ci.yml`
  builds and publishes the package to PyPI.

  Tag a commit and push the tags with:

  ```sh
  git tag <my-tag>
  git push --tags
  ```

  Trusted publishing must be enabled once in [PyPI Publishing](https://pypi.org/manage/account/publishing/).
  Fill the following values in the form:

  ```
  PyPI Project Name: scipy-events
              Owner: maurosilber
    Repository name: scipy-events
      Workflow name: ci.yml
   Environment name: pypi
  ```

  [ci-badge]: https://img.shields.io/github/actions/workflow/status/maurosilber/scipy-events/ci.yml
  [ci-url]: https://github.com/maurosilber/scipy-events/actions/workflows/ci.yml
  [conda-forge-badge]: https://img.shields.io/conda/vn/conda-forge/scipy-events?logoColor=white&logo=conda-forge
  [conda-forge-url]: https://prefix.dev/channels/conda-forge/packages/scipy-events
  [copier-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-black.json
  [copier-url]: https://github.com/copier-org/copier
  [license-badge]: https://img.shields.io/badge/license-MIT-blue
  [pixi-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json
  [pixi-url]: https://pixi.sh
  [pypi-badge]: https://img.shields.io/pypi/v/scipy-events.svg?logo=pypi&logoColor=white
  [pypi-url]: https://pypi.org/project/scipy-events
  [pypi-version-badge]: https://img.shields.io/pypi/pyversions/scipy-events?logoColor=white&logo=python
  [pypi-version-url]: https://pypi.org/project/scipy-events


pkgId: e557a2884099f863c003279978ebd5025a128927236a2bfa6568859bd73d7794
name: python-scipy-stubs-help
arch: noarch
version: 1.14.1.6
epoch: 0
release: 1
summary: Development documents and examples for scipy-stubs
url: https://pypi.org/project/scipy-stubs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scipy-stubs-1.14.1.6-1.src.rpm
location_href: Packages/python-scipy-stubs-help-1.14.1.6-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">scipy-stubs</h1>

  <p align="center">
      Precise type hints for <i>all</i> of <a href="https://github.com/scipy/scipy">SciPy</a>.
  </p>

  <p align="center">
      <a href="https://pypi.org/project/scipy-stubs/">
          <img
              alt="scipy-stubs - PyPI"
              src="https://img.shields.io/pypi/v/scipy-stubs?style=flat&color=olive"
          />
      </a>
      <a href="https://anaconda.org/conda-forge/scipy-stubs">
          <img
              alt="scipy-stubs - conda-forge"
              src="https://anaconda.org/conda-forge/scipy-stubs/badges/version.svg"
          />
      </a>
      <a href="https://github.com/jorenham/scipy-stubs">
          <img
              alt="scipy-stubs - Python Versions"
              src="https://img.shields.io/pypi/pyversions/scipy-stubs?style=flat"
          />
      </a>
      <a href="https://github.com/jorenham/scipy-stubs">
          <img
              alt="scipy-stubs - license"
              src="https://img.shields.io/github/license/jorenham/scipy-stubs?style=flat"
          />
      </a>
  </p>
  <p align="center">
      <a href="https://github.com/jorenham/scipy-stubs/actions?query=workflow%3ACI">
          <img
              alt="scipy-stubs - CI"
              src="https://github.com/jorenham/scipy-stubs/workflows/CI/badge.svg"
          />
      </a>
      <a href="https://github.com/pre-commit/pre-commit">
          <img
              alt="scipy-stubs - pre-commit"
              src="https://img.shields.io/badge/pre--commit-enabled-teal?logo=pre-commit"
          />
      </a>
      <a href="https://github.com/KotlinIsland/basedmypy">
          <img
              alt="scipy-stubs - basedmypy"
              src="https://img.shields.io/badge/basedmypy-checked-fd9002"
          />
      </a>
      <a href="https://detachhead.github.io/basedpyright">
          <img
              alt="scipy-stubs - basedpyright"
              src="https://img.shields.io/badge/basedpyright-checked-42b983"
          />
      </a>
      <a href="https://github.com/astral-sh/ruff">
          <img
              alt="scipy-stubs - ruff"
              src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json"
          />
      </a>
  </p>

  ______________________________________________________________________



  - Works out-of-the-box
    - all that's needed is to [install `scipy-stubs`](#installation)
    - does not require a `mypy` plugin or other configuration
    - available on [PyPI](https://pypi.org/project/scipy-stubs/) and [conda-forge](https://anaconda.org/conda-forge/scipy-stubs)
  - Improves IDE suggestions and autocompletion
    - ... even if you don't use static typing in your code
    - no additional plugins required
  - 0% runtime overhead
    - not even a single import is required
  - 100% coverage of the [public SciPy API](https://docs.scipy.org/doc/scipy-1.14.1/reference/index.html)
    - also covers most of the private API
  - Precise type-hinting of dtypes and [shape-types](https://github.com/numpy/numpy/issues/16544)
    - works with all "array-likes" and "dtype-likes"
    - many of the functions that return an array are *shape-typed*
    - shape-typing is optional: all functions still accept arrays with unknown shape-type
  - Type-checker agnostic
    - works with at least [`mypy`](https://github.com/KotlinIsland/basedmypy),
      [`pyright`](https://github.com/DetachHead/basedpyright)/pylance and [`ruff`](https://github.com/astral-sh/ruff)
    - ... even in the strict mode
    - compatible with the [Python Typing Spec](https://typing.readthedocs.io/en/latest/spec/index.html)
  - [SPEC 0](https://scientific-python.org/specs/spec-0000/) compliant
    - Supports Python ≥ 3.10
    - Supports NumPy ≥ 1.23.5

  <!-- NOTE: SciPy permalinks to the following `#installation` anchor; don't modify it! -->



  The source code is currently hosted on GitHub at [github.com/jorenham/scipy-stubs](https://github.com/jorenham/scipy-stubs/).

  Binary distributions are available at the [Python Package Index (PyPI)](https://pypi.org/project/scipy-stubs/) and on
  [conda-forge](https://anaconda.org/conda-forge/scipy-stubs).



  To install from the [PyPI](https://pypi.org/project/scipy-stubs/), run:

  ```bash
  pip install scipy-stubs
  ```

  In case you haven't installed `scipy` yet, both can be installed with:

  ```bash
  pip install scipy-stubs[scipy]
  ```



  To install using Conda from the [conda-forge channel](https://anaconda.org/conda-forge/scipy-stubs), run:

  ```bash
  conda install conda-forge::scipy-stubs
  ```



  1. [`basedpyright`](https://github.com/DetachHead/basedpyright) (recommended)
  1. [`basedmypy`](https://github.com/KotlinIsland/basedmypy)
  1. [`pyright`](https://pyright.readthedocs.io/en/latest/index.html)
  1. [`mypy`](https://mypy.readthedocs.io/en/stable/index.html) (not recommended, see [erictraut/mypy_issues](https://github.com/erictraut/mypy_issues))

  For validation and testing, `scipy-stubs` primarily uses [`basedmypy`](https://github.com/KotlinIsland/basedmypy) (a `mypy` fork)
  and [`basedpyright`](https://github.com/DetachHead/basedpyright) (a `pyright` fork).
  They are in generally stricter than `mypy` and `pyright`, so you can assume compatibility with `mypy` and `pyright` as well.
  But if you find that this isn't the case, then don't hesitate to open an issue or submit a pull request.



  The versioning scheme of `scipy-stubs` includes the compatible `scipy` version as `{scipy_version}.{stubs_version}`.
  Even though `scipy-stubs` doesn't enforce an upper bound on the `scipy` version, later `scipy` versions aren't guaranteed to be
  fully compatible.

  The supported range of `numpy` versions are specified in [`SPEC 0`](https://scientific-python.org/specs/spec-0000/), which
  `scipy-stubs` aims to follow as close as feasible.

  Currently, `scipy-stubs` has one required dependency: [`optype`](https://github.com/jorenham/optype).
  This is essential for `scipy-stubs` to work properly, as it relies heavily on it for annotating (shaped) array-likes,
  scalar-likes, shape-typing in general, and much more.
  At the moment, `scipy-stubs` requires the latest version `optype`.

  The exact version requirements are specified in the [`pyproject.toml`](pyproject.toml).



  The entire public API of `scipy` is **fully annotated** and **verifiably valid**.
  For the most part, this can also be said about `scipy`'s private API and other internal machinery.

  However, a small portion uses `Untyped` (an alias of `Any`) as "placeholder annotations".
  In those cases static type-checkers won't do any type-checking, and won't bother you with errors or warnings.

  The following table shows the (subjective) proportion of `scipy-stubs` that is(n't) annotated with `Untyped`, ranging
  from 🌑 (100% `Untyped`) to 🌕 (0% `Untyped`).

  | `scipy._`     | `ruff` & `flake8-pyi` | `stubtest` | `basedmypy` | `basedpyright` | phase |
  | :------------ | :-------------------: | :--------: | :---------: | :------------: | :---: |
  | `cluster`     |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `constants`   |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌝   |
  | `datasets`    |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌝   |
  | `fft`         |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `fftpack`     |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `integrate`   |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `interpolate` |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `io`          |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `linalg`      |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | ~`misc`~      |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `ndimage`     |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `odr`         |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `optimize`    |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `signal`      |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌔   |
  | `sparse`      |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `spatial`     |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `special`     |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | `stats`       |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |
  | *`_lib`*      |          ✔️           |     ✔️     |     ✔️      |       ✔️       |  🌕   |

  Currently, only `scipy.signal` contains `Untyped` annotations; all other submodules have complete typing coverage.



  <https://github.com/user-attachments/assets/adbec640-2329-488b-bda2-d9687c6b1f7b>



  - [scipy/scipy#21614](https://github.com/scipy/scipy/issues/21614): On why `scipy-stubs` is a separate package, and not part of
    `scipy` (yet).
  - [microsoft/python-type-stubs#321](https://github.com/microsoft/python-type-stubs/pull/321): The removal of Microsoft's
    `scipy-stubs` — that used to be bundled with Pylance — in favor of `scipy-stubs`.
  - [`optype`](https://github.com/jorenham/optype): The fundamental typing package that made `scipy-stubs` possible.
  - [`basedpyright`](https://github.com/detachhead/basedpyright): The recommended type-checker to use with `scipy-stubs`.
  - [`basedmypy`](https://github.com/KotlinIsland/basedmypy): A [less-broken](https://github.com/erictraut/mypy_issues) `mypy` fork,
    with a bunch of cool extra features.


pkgId: b6998342c743fa197f97beaf64d5c77bf8b31e7578a45fb7801cb4865a566a99
name: python-scisave-help
arch: noarch
version: 1.4.3
epoch: 0
release: 1
summary: Development documents and examples for scisave
url: https://github.com/otvam/scisave
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scisave-1.4.3-1.src.rpm
location_href: Packages/python-scisave-help-1.4.3-1.noarch.rpm
checksum_type: sha256
description:
  > * **Repository: [github.com/otvam/scisave](https://github.com/otvam/scisave)**
  > * **PyPi: [pypi.org/project/scisave](https://pypi.org/project/scisave)**
  > * **Conda: [anaconda.org/conda-forge/scisave](https://anaconda.org/conda-forge/scisave)**



  **SciSave** is a **Python serialization/deserialization** module:
  * Specially targeted for **scientific applications**.
  * Load **JSON/YAML configuration files**.
  * Load and write **JSON/Pickle data files**.

  For **YAML** files, the following **custom extensions** are used:
  * `!path` - parse relative paths (with respect to the YAML file).
  * `!include` - include other YAML files (recursion possible).
  * `!eval` - evaluate a Python literal (using literal_eval).
  * `!env` - substitute YAML strings with values from environment variables.
  * `!sub` - substitute YAML strings with values from a provided dictionary.
  * `!merge_dict` - merge a list of dicts.
  * `!merge_list` - merge a list of lists.

  For **JSON** files, the following **custom extensions** are used:
  * Allows the serialization/deserialization of complex numbers (`__complex__`).
  * Allows the serialization/deserialization of NumPy arrays (`__numpy__`).
  * Allows the serialization/deserialization as/from text and gzip files

  The following file extensions are used:
  * `.yaml, .yml` - for YAML files
  * `.json, .js` - for JSON text files
  * `.gz, .gzip` - for JSON gzip files
  * `.pck, .pkl, .pickle` - for Pickle files

  The JSON/YAML files with the custom extensions are still valid JSON/YAML files.
  Pickle is significantly faster than JSON for very large data files.

  SciSave is written in Python (NumPy and PyYAML are the only dependencies).
  SciSave is respecting **semantic versioning** (starting from version 1.4).



  * Pickling data is not secure.
  * Only load pickle files that you trust.



  An example is located in the `example` folder of the repository:
  * `run_data.py` contains an example file for the loader/dumper
  * `config_main.yaml` YAML configuration file with custom extensions
  * `config_include.yaml` YAML configuration file for include extension
  * `dump.json` JSON plain text file for testing data dumping/loading
  * `dump.gz` JSON plain gzip file for testing data dumping/loading
  * `dump.pickle` Pickle file for testing data dumping/loading



  * Repository: https://github.com/otvam/scisave
  * Releases: https://github.com/otvam/scisave/releases
  * Tags: https://github.com/otvam/scisave/tags
  * Issues: https://github.com/otvam/scisave/issues
  * PyPi: https://pypi.org/project/scisave
  * Conda: https://anaconda.org/conda-forge/scisave



  * **Thomas Guillod**
  * Email: guillod@otvam.ch
  * Website: https://otvam.ch



  > (c) 2023 - Thomas Guillod
  >
  >  BSD 2-Clause "Simplified" License


pkgId: 03b9dacc207910ee96b5c760c55ee2bdfef5ba488d3dc89015fa7e136fd4870a
name: python-scitacean-help
arch: noarch
version: 24.12.0
epoch: 0
release: 1
summary: Development documents and examples for scitacean
url: https://pypi.org/project/scitacean/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scitacean-24.12.0-1.src.rpm
location_href: Packages/python-scitacean-help-24.12.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI badge](https://img.shields.io/pypi/v/scitacean.svg?style=flat-square&color=green)](https://pypi.python.org/pypi/scitacean)
  [![Anaconda-Server Badge](https://img.shields.io/conda/vn/conda-forge/scitacean?style=flat-square&color=green)](https://anaconda.org/conda-forge/scitacean)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7520487.svg)](https://doi.org/10.5281/zenodo.7520487)
  [![License: BSD 3-Clause](https://img.shields.io/github/license/SciCatProject/scitacean?style=flat-square&color=yellowgreen)](LICENSE)

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/SciCatProject/scitacean/blob/main/docs/_static/logo-dark.svg">
    <source media="(prefers-color-scheme: light)" srcset="https://github.com/SciCatProject/scitacean/blob/main/docs/_static/logo.svg">
    <img alt="Scitacean" src="https://github.com/SciCatProject/scitacean/blob/main/docs/_static/logo.svg" width="25%">
  </picture>

  Scitacean is a high level Python package for downloading and uploading datasets from and to [SciCat](https://scicatproject.github.io/).

  See the [documentation](https://scicatproject.github.io/scitacean/) for installation and usage instructions.

  If you need help, have a look at our GitHub [discussions](https://github.com/SciCatProject/scitacean/discussions).
  For questions, please start a [Q&A discussion](https://github.com/SciCatProject/scitacean/discussions/categories/q-a) if you can't find an answer.

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


pkgId: 9746185862fa6baafdb93a792da18f29428db578779002641c61cae84915926f
name: python-scitrera-app-framework-help
arch: noarch
version: 0.0.45
epoch: 0
release: 1
summary: Development documents and examples for scitrera-app-framework
url: https://github.com/scitrera/python-app-framework
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scitrera-app-framework-0.0.45-1.src.rpm
location_href: Packages/python-scitrera-app-framework-help-0.0.45-1.noarch.rpm
checksum_type: sha256
description:
  Common code and utilities for Scitrera applications and container images.

  Working hard to move closed-source code to open-source, so more coming soon....


pkgId: 75966954be25ec0f3f3bc747a2b55dc02d62aeb4f697b650d7573ae5fabd6937
name: python-scm-config-clone-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for scm-config-clone
url: https://pypi.org/project/scm-config-clone/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scm-config-clone-0.2.1-1.src.rpm
location_href: Packages/python-scm-config-clone-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Banner Image](https://raw.githubusercontent.com/cdot65/scm-config-clone/refs/heads/main/docs/images/logo.svg)

  [![Build Status](https://github.com/cdot65/scm-config-clone/actions/workflows/ci.yml/badge.svg)](https://github.com/cdot65/scm-config-clone/actions/workflows/ci.yml)
  [![PyPI version](https://badge.fury.io/py/scm-config-clone.svg)](https://badge.fury.io/py/scm-config-clone)
  [![Python versions](https://img.shields.io/pypi/pyversions/scm-config-clone.svg)](https://pypi.org/project/scm-config-clone/)
  [![License](https://img.shields.io/github/license/cdot65/scm-config-clone.svg)](https://github.com/cdot65/scm-config-clone/blob/main/LICENSE)

  `scm-config-clone` is a command-line tool designed to seamlessly clone configuration objects between Palo Alto Networks
  Strata Cloud Manager (SCM) tenants. From addresses and tags to application groups and security rules, this tool
  streamlines migration tasks and reduces manual errors.



  - [Features](#features)
  - [Installation](#installation)
  - [Basic Usage](#basic-usage)
  - [Creating the Settings File](#creating-the-settings-file)
  - [Cloning Objects](#cloning-objects)
  - [Further Reading](#further-reading)
  - [Contributing](#contributing)
  - [License](#license)



  - **Simple Setup**: Store credentials and defaults in a `settings.yaml` file for reuse.
  - **Robust Cloning**: Supports multiple object types (addresses, tags, services, security rules, and more).
  - **Extensive Filters**: Exclude specific folders, snippets, or devices to narrow down cloned objects.
  - **Flexible Controls**: Run in `dry-run` mode, auto-approve changes, suppress console output, and create reports.
  - **Commit & Push**: Automatically commit changes after objects are cloned.



  **Requirements**:

  - Python 3.10 or higher

  Install directly from PyPI:

  ```bash
  pip install scm-config-clone
  ```



  Once installed, the primary command is `scm-clone`. Running `--help` displays global options and available sub-commands:

  ```bash
  scm-clone --help
  ```

  You’ll see a list of commands like `addresses`, `tags`, `services`, `security-rules`, and `settings`.



  Before cloning, create a `settings.yaml` file to store SCM credentials and defaults:

  ```bash
  scm-clone settings
  ```

  You’ll be prompted for source/destination credentials, logging level, and defaults for `auto_approve`, `create_report`,
  `dry_run`, and `quiet`. Once done, `settings.yaml` will be created in the current directory. Subsequent commands read
  from it, eliminating the need to re-enter credentials or defaults.



  With `settings.yaml` ready, cloning objects typically involves specifying a folder and object type. For example, to
  clone address objects:

  ```bash
  scm-clone addresses --folder "Network-Folder"
  ```

  If `auto_approve` is disabled by default in `settings.yaml`, you’ll be prompted before actual creation. If you wish to
  override this at runtime:

  ```bash
  scm-clone addresses --folder "Network-Folder" -A
  ```

  This command auto-approves without prompting. Similarly, to run in dry-run mode or commit after creation:

  ```bash
  scm-clone addresses --folder "Network-Folder" -D --commit-and-push
  ```

  This simulates the creation without applying changes (`-D`) and would commit changes if actually applied. Remove `-D` to
  run it for real.



  - [Commands Reference](https://cdot65.github.io/scm-config-clone/user-guide/python/commands/): Detailed command flags,
    workflows, and parameters.
  - [Examples](https://cdot65.github.io/scm-config-clone/user-guide/python/examples/): Practical, real-world usage
    patterns and integrations.
  - [Getting Started](https://cdot65.github.io/scm-config-clone/user-guide/python/getting-started/): Step-by-step guide to
    initial setup and cloning workflows.



  Contributions are welcome! Please see the [CONTRIBUTING](CONTRIBUTING.md) file for guidelines.



  `scm-config-clone` is licensed under the Apache 2.0 License. See the [LICENSE](./LICENSE) file for more details.


pkgId: b69f53387ab90682f151e29de6a861f3fb0466ca6f6fd3e12217c399841efd37
name: python-scm-config-clone-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for scm-config-clone
url: https://pypi.org/project/scm-config-clone/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scm-config-clone-0.2.5-1.src.rpm
location_href: Packages/python-scm-config-clone-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  ![Banner Image](https://raw.githubusercontent.com/cdot65/scm-config-clone/refs/heads/main/docs/images/logo.svg)

  [![Build Status](https://github.com/cdot65/scm-config-clone/actions/workflows/ci.yml/badge.svg)](https://github.com/cdot65/scm-config-clone/actions/workflows/ci.yml)
  [![PyPI version](https://badge.fury.io/py/scm-config-clone.svg)](https://badge.fury.io/py/scm-config-clone)
  [![Python versions](https://img.shields.io/pypi/pyversions/scm-config-clone.svg)](https://pypi.org/project/scm-config-clone/)
  [![License](https://img.shields.io/github/license/cdot65/scm-config-clone.svg)](https://github.com/cdot65/scm-config-clone/blob/main/LICENSE)

  `scm-config-clone` is a command-line tool designed to seamlessly clone configuration objects between Palo Alto Networks
  Strata Cloud Manager (SCM) tenants. From addresses and tags to application groups and security rules, this tool
  streamlines migration tasks and reduces manual errors.



  - [Features](#features)
  - [Installation](#installation)
  - [Basic Usage](#basic-usage)
  - [Creating the Settings File](#creating-the-settings-file)
  - [Cloning Objects](#cloning-objects)
  - [Further Reading](#further-reading)
  - [Contributing](#contributing)
  - [License](#license)



  - **Simple Setup**: Store credentials and defaults in a `settings.yaml` file for reuse.
  - **Robust Cloning**: Supports multiple object types (addresses, tags, services, security rules, and more).
  - **Extensive Filters**: Exclude specific folders, snippets, or devices to narrow down cloned objects.
  - **Flexible Controls**: Run in `dry-run` mode, auto-approve changes, suppress console output, and create reports.
  - **Commit & Push**: Automatically commit changes after objects are cloned.



  **Requirements**:

  - Python 3.10 or higher

  Install directly from PyPI:

  ```bash
  pip install scm-config-clone
  ```



  Once installed, the primary command is `scm-clone`. Running `--help` displays global options and available sub-commands:

  ```bash
  scm-clone --help
  ```

  You’ll see a list of commands like `addresses`, `tags`, `services`, `security-rules`, and `settings`.



  Before cloning, create a `settings.yaml` file to store SCM credentials and defaults:

  ```bash
  scm-clone settings
  ```

  You’ll be prompted for source/destination credentials, logging level, and defaults for `auto_approve`, `create_report`,
  `dry_run`, and `quiet`. Once done, `settings.yaml` will be created in the current directory. Subsequent commands read
  from it, eliminating the need to re-enter credentials or defaults.



  With `settings.yaml` ready, cloning objects typically involves specifying a folder and object type. For example, to
  clone address objects:

  ```bash
  scm-clone addresses --source-folder "Texas"
  ```

  If `auto_approve` is disabled by default in `settings.yaml`, you’ll be prompted before actual creation. If you wish to
  override this at runtime:

  ```bash
  scm-clone addresses --source-folder "Texas" -A
  ```

  This command auto-approves without prompting. Similarly, to run in dry-run mode or commit after creation:

  ```bash
  scm-clone addresses --source-folder "Texas" -D --commit-and-push
  ```

  This simulates the creation without applying changes (`-D`) and would commit changes if actually applied. Remove `-D` to
  run it for real.



  - [Commands Reference](https://cdot65.github.io/scm-config-clone/user-guide/python/commands/): Detailed command flags,
    workflows, and parameters.
  - [Examples](https://cdot65.github.io/scm-config-clone/user-guide/python/examples/): Practical, real-world usage
    patterns and integrations.
  - [Getting Started](https://cdot65.github.io/scm-config-clone/user-guide/python/getting-started/): Step-by-step guide to
    initial setup and cloning workflows.



  Contributions are welcome! Please see the [CONTRIBUTING](CONTRIBUTING.md) file for guidelines.



  `scm-config-clone` is licensed under the Apache 2.0 License. See the [LICENSE](./LICENSE) file for more details.


pkgId: c8d63905e14b1a1767405e32dca138fcecabcc7ca23f26029c3c5e57c77825b4
name: python-scoda-help
arch: noarch
version: 2.1b19
epoch: 0
release: 1
summary: Development documents and examples for scoda
url: https://github.com/FelixSchoen/S-Coda
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scoda-2.1b19-1.src.rpm
location_href: Packages/python-scoda-help-2.1b19-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Release](https://img.shields.io/github/v/release/FelixSchoen/S-Coda?include_prereleases&label=Latest%20Release)](https://github.com/FelixSchoen/S-Coda/releases)
  [![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/FelixSchoen/S-Coda/scoda_test.yml?label=Build)](https://github.com/FelixSchoen/S-Coda/actions/workflows/scoda_test.yml)
  [![Python Version](https://img.shields.io/badge/Python%20Version-3.11-blue)](https://www.python.org/downloads/release/python-3119/)

  [![DOI](https://img.shields.io/badge/DOI-10.34726%2Fhss.2023.103585-blue)](https://doi.org/10.34726/hss.2023.103585)
  [![DOI](https://img.shields.io/badge/DOI-10.1007%2F978--3--031--47546--7_19-blue)](https://doi.org/10.1007/978-3-031-47546-7_19)



  S-Coda is a Python library for handling MIDI files.
  S-Coda supports a plethora of different MIDI manipulation operations, such as:

  - quantisation of notes
  - quantisation of note lengths
  - splitting sequences into bars
  - transposing of sequences
  - creating piano-roll visualisations of pieces
  - judging the difficulty of pieces

  S-Coda was used in our project [PAUL-2](https://github.com/FelixSchoen/PAUL-2) to process MIDI files.
  For information about how to use S-Coda we refer to chapter 5 of the [thesis](https://doi.org/10.34726/hss.2023.103585) in which S-Coda was introduced.



  We recommend installing S-Coda from [PyPI](https://pypi.org/project/scoda/) using pip:

  ```pip install scoda```



  See [`CHANGELOG.md`](https://github.com/FelixSchoen/S-Coda/blob/main/CHANGELOG.md) for a detailed changelog.



  We refer to the aforementioned thesis for a more in-depth guide on how to use S-Coda.
  We provide a short listing on how to use basic S-Coda functions:

  ```python
      
      sequence = Sequence.sequences_load(file_path=RESOURCE_BEETHOVEN)[1]

      
      sequence.quantise_and_normalise()

      
      bars = Sequence.sequences_split_bars([sequence], meta_track_index=0)[0]

      
      tokeniser = StandardNotelikeTokeniser(running_value=True, running_pitch=True, running_time_sig=True)
      tokens = []
      difficulties = []

      
      for bar in bars:
          tokens.extend(tokeniser.tokenise(bar.sequence))
          difficulties.append(bar.sequence.difficulty())

      
      tokens = tokens

      
      detokenised_sequence = tokeniser.detokenise(tokens)

      
      detokenised_sequence.save("out/generated_sequence.mid")
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Felix Schön  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: 18464c11e84b99aab3f8cb8a171b1871c74b54fddf4be8367657cda15f67cf47
name: python-scope-client-help
arch: noarch
version: 1.4.10
epoch: 0
release: 1
summary: Development documents and examples for scope-client
url: https://pypi.org/project/scope-client/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scope-client-1.4.10-1.src.rpm
location_href: Packages/python-scope-client-help-1.4.10-1.noarch.rpm
checksum_type: sha256
description:
  [//]: # (user-facing readme)


  [Arthur](https://www.arthur.ai/) is the platform for centralized monitoring of production models.
  We help data scientists, product owners, and business leaders accelerate model operations to optimize
  for accuracy, explainability, and fairness. As a model- and infrastructure-agnostic platform, Arthur
  adds a layer of intelligence to your AI stack and scales with your deployments.

  Our API Client makes it easy to integrate your models with the Arthur platform. For help getting started or
  using the SDK, check out [our documentation](https://docs.arthur.ai/).


pkgId: a172a39392ee3985b80a19e9492fa310f6383005ac5139728b48008c3dc65754
name: python-scotthsieh-projen-statemachine-help
arch: noarch
version: 2.0.590
epoch: 0
release: 1
summary: Development documents and examples for scotthsieh-projen-statemachine
url: https://github.com/HsiehShuJeng/projen-simple.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scotthsieh-projen-statemachine-2.0.590-1.src.rpm
location_href: Packages/python-scotthsieh-projen-statemachine-help-2.0.590-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-green)](https://opensource.org/licenses/Apache-2.0) ![Release](https://github.com/HsiehShuJeng/projen-simple/workflows/Release/badge.svg) [![npm downloads](https://img.shields.io/npm/dt/projen-statemachine-example?label=npm%20downloads&style=plastic)](https://img.shields.io/npm/dt/projen-statemachine-example?label=npm%20downloads&style=plastic) [![pypi downloads](https://img.shields.io/pypi/dm/scotthsieh-projen-statemachine?label=pypi%20downloads&style=plastic)](https://img.shields.io/pypi/dm/scotthsieh-projen-statemachine?label=pypi%20downloads&style=plastic) [![NuGet downloads](https://img.shields.io/nuget/dt/Projen.Statemachine?label=NuGet%20downloads&style=plastic)](https://img.shields.io/nuget/dt/Projen.Statemachine?label=NuGet%20downloads&style=plastic) [![repo languages](https://img.shields.io/github/languages/count/HsiehShuJeng/projen-simple?label=repo%20languages&style=plastic)](https://img.shields.io/github/languages/count/HsiehShuJeng/projen-simple?label=repo%20languages&style=plastic)

  | npm (JS/TS) | PyPI (Python) | Maven (Java) | Go | NuGet |
  | --- | --- | --- | --- | --- |
  | [Link](https://www.npmjs.com/package/projen-simple) | [Link](https://pypi.org/project/scotthsieh_projen_statemachine/) | [Link](https://search.maven.org/artifact/io.github.hsiehshujeng/projen-statemachine) | [Link](https://github.com/HsiehShuJeng/projen-statemachine-go) | [Link](https://www.nuget.org/packages/Projen.Statemachine/) |

  Build a custom construct based on an example in an AWS Blog post and use [projen](https://github.com/projen/projen) to publish to 5 language repositories, i.e., npm, PyPI, Central Maven, NuGet, and Go.



  This library constrcution is referred to the first example in this AWS blog, [*Introducing Amazon API Gateway service integration for AWS Step Functions*](https://aws.amazon.com/tw/blogs/compute/introducing-amazon-api-gateway-service-integration-for-aws-step-functions/) written by Benjanmin Smith. After you deploy the stack with whatever programming language you like, i.e., Typescript, Python, Java, or C sharp, you'll get a view similar to the following diagram:
  ![image](https://raw.githubusercontent.com/HsiehShuJeng/projen-simple/main/images/designer_view.png)





  ```bash
  $ cdk --init language typescript
  $ yarn add projen-statemachine-example
  ```

  ```python
  import { StateMachineApiGatewayExample } from 'projen-statemachine-example';

   export class TypescriptStack extends cdk.Stack {
   constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
       super(scope, id, props);

       const stageName = 'default';
       const partPath = 'pets';
       const exampleConstruct = new StateMachineApiGatewayExample(this, 'KerKer', {
           stageName: stageName, partPath: partPath});

       new cdk.CfnOutput(this, 'OStateMachine', {
           value: exampleConstruct.stateMachine.stateMachineArn});
       new cdk.CfnOutput(this, 'OExecutionOutput', {
           value: exampleConstruct.executionInput, description: 'Sample input to StartExecution.'});
   }
  ```



  ```bash
  $ cdk init --language python
  $ cat <<EOL > requirements.txt
  aws-cdk.core
  scotthsieh_projen_statemachine
  EOL
  $ python -m pip install -r requirements.txt
  ```

  ```python
  from aws_cdk import core as cdk
  from scotthsieh_projen_statemachine import StateMachineApiGatewayExample

  class PythonStack(cdk.Stack):
      def __init__(self, scope: cdk.Construct, construct_id: str, **kwargs) -> None:
           super().__init__(scope, construct_id, **kwargs)

           stage_name = 'default'
           part_path = 'pets'
           example_construct = StateMachineApiGatewayExample(
               self, 'PythonStatemachne', stage_name=stage_name, part_path=part_path,
           )

           cdk.CfnOutput(self, "OStateMachine",
               value=example_construct.state_machine.state_machine_arn
           )
           cdk.CfnOutput(self, "OExecutionOutput", value=example_construct.execution_input, description="Sample input to StartExecution.")
  ```



  ```bash
  $ cdk init --language java
  $ mvn package
  ```

  ```xml
  .
  .
  <properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <custom.construct.version>2.0.474</custom.construct.version>
       <cdk.version>2.149.0</cdk.version>
       <junit.version>5.7.1</junit.version>
   </properties>
   .
   .
   <dependencies>
       <!-- AWS Cloud Development Kit -->
       .
       .
       .
       <dependency>
           <groupId>io.github.hsiehshujeng</groupId>
           <artifactId>projen-statemachine</artifactId>
           <version>${custom.construct.version}</version>
       </dependency>
       .
       .
       .
   </dependencies>
  ```

  ```java
  package com.myorg;

  import software.amazon.awscdk.core.Construct;
  import software.amazon.awscdk.core.CfnOutput;
  import software.amazon.awscdk.core.CfnOutputProps;
  import software.amazon.awscdk.core.Stack;
  import software.amazon.awscdk.core.StackProps;
  import io.github.hsiehshujeng.projen.statemachine.*;

  public class JavaStack extends Stack {
      public JavaStack(final Construct scope, final String id) {
          this(scope, id, null);
       }

       public JavaStack(final Construct scope, final String id, final StackProps props) {
           super(scope, id, props);

           String stageName = "default";
           String partPath = "pets";
           StateMachineApiGatewayExample exampleConstruct = new StateMachineApiGatewayExample(this, "KerKer",
               StateMachineApiGatewayExampleProps.builder()
                   .stageName(stageName)
                   .partPath(partPath)
                   .build());

           new CfnOutput(this, "OStateMachine",
               CfnOutputProps.builder()
                   .value(exampleConstruct.getStateMachine().getStateMachineArn())
                   .build());
           new CfnOutput(this, "OExecutionOutput", CfnOutputProps.builder()
               .value(exampleConstruct.getExecutionInput())
               .description("Sample input to StartExecution.")
               .build());
       }
   }
  ```



  ```bash
  $ cdk init --language csharp
  $ dotnet add src/Csharp package Projen.Statemachine --version 2.0.474
  ```

  ```cs
  using Amazon.CDK;
  using ScottHsieh.Examples;

  namespace Csharp
  {
      public class CsharpStack : Stack
      {
          internal CsharpStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
          {
              string stageName = "default";
              string partPath = "pets";

              var exampleConstruct = new StateMachineApiGatewayExample(this, "KerKer", new StateMachineApiGatewayExampleProps
              {
                  StageName = stageName,
                  PartPath = partPath
              });

              new CfnOutput(this, "OStateMachine", new CfnOutputProps
              {
                  Value = exampleConstruct.StateMachine.StateMachineArn
              });
              new CfnOutput(this, "OExecutionOutput", new CfnOutputProps
              {
                  Value = exampleConstruct.ExecutionInput,
                  Description = "Sample input to StartExecution."
              });
          }
      }
   }
  ```



  * [jsii reference](https://github.com/cdklabs/jsii-release)
  * [aws-cdk-go](https://github.com/aws/aws-cdk-go)
  * [jsii](https://github.com/aws/jsii)


pkgId: ee45cef2af1ffbf3cd5c03a00d390bf6a9e7196ac610dcff16c9eaed39df58d4
name: python-scout-browser-help
arch: noarch
version: 4.94
epoch: 0
release: 1
summary: Development documents and examples for scout-browser
url: https://pypi.org/project/scout-browser/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scout-browser-4.94-1.src.rpm
location_href: Packages/python-scout-browser-help-4.94-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  	<a href="https://Clinical-Genomics.github.io/scout/">
  		<img height="165" width="637" src="artwork/logo-display.png">
  	</a>
  	<h3 align="center">Analyze VCFs and collaborate on solving rare diseases quicker</h3>
  </p>

  ![Build Status - GitHub][actions-build-status]
  [![PyPI Version][pypi-img]][pypi-url]
  ![GitHub Release Date][github-release-date]
  [![GitHub commits latest](https://img.shields.io/github/commits-since/Clinical-Genomics/scout/latest)](https://GitHub.com/Clinical-Genomics/scout/commit/)
  [![GitHub commit rate](https://img.shields.io/github/commit-activity/w/Clinical-Genomics/scout)](https://GitHub.com/Clinical-Genomics/scout/pulse/)
  [![GitHub commits](https://img.shields.io/github/commits-since/Clinical-Genomics/scout/v4.0.0.svg)](https://GitHub.com/Clinical-Genomics/scout/commit/)
  [![GitHub issues-closed][closed-issues-img]][closed-issues-url]
  [![Average time to resolve an issue][ismaintained-resolve-img]][ismaintained-resolve-url]
  [![Percentage of issues still open][ismaintained-open-rate-img]][ismaintained-open-rate-url]
  [![Coverage Status][codecov-img]][codecov-url]
  [![CodeFactor](https://www.codefactor.io/repository/github/clinical-genomics/scout/badge)](https://www.codefactor.io/repository/github/clinical-genomics/scout)
  [![Code style: black][black-image]][black-url]
  [![Woke][woke-image]][woke-url]




  - **Simple** - Analyze variants in a simple to use web interface.
  - **Aggregation** - Combine results from multiple analyses and VCFs into a centralized database.
  - **Collaboration** - Write comments and share cases between users and institutes.



  This README only gives a brief overview of Scout, for a more complete reference, please check out our docs: https://clinical-genomics.github.io/scout .



  A simple demo instance of Scout requires the installation of Docker and can be launched either by using the command:
  `docker-compose up -d` or `make up`.

  The repository includes a Makefile with common shortcuts to simplify setting up and working with Scout. To see a full list and description of these shortcuts run: `make help`.

  This demo is consisting of 3 containers:
  - a MongoDB instance, on the default port 27017 in the container, mapped to host port 27013
  - scout-cli --> the Scout command line, connected to the database. Populates the database with demo data
  - scout-web --> the Scout web app, that serves the app on localhost, port 8000.

  Once the server has started you and open the app in the web browser at the following address: http://localhost:8000/

  The command to stop the demo are either `docker-compose down` or `make down`.

  Instructions on how to run a Scout image connected to your local database or a custom database are present [on this page](docs/admin-guide/containers/container-deploy.md).



  <!-- You can install the latest release of Scout using `pip`:

  ```bash
  pip install scout-browser


  pip install scout-browser[coverage]
  ```

  If you would like to install Scout for local development: -->

  ```bash
  git clone https://github.com/Clinical-Genomics/scout
  cd scout
  pip install --editable .
  ```

  Scout is configured to use `uv` if you like; either run, install, install as a tool or
  ```
  uv sync --frozen
  uv run scout
  ```


  Scout PDF reports are created using [Flask-WeasyPrint](https://pythonhosted.org/Flask-WeasyPrint/). This library requires external dependencies which need be installed separately (namely Cairo and Pango). See platform-specific instructions for Linux, macOS and Windows available on the WeasyPrint installation [pages](https://doc.courtbouillon.org/weasyprint/stable/first_steps.html#installation).

  <b>NB</b>: in order to convert HTML reports into PDF reports, we have recently switched from the WeasyPrint lib to [python-pdfkit](https://github.com/JazzCore/python-pdfkit). For this reason, when upgrading to a Scout version >4.47, you need to install an additional [wkhtmltopdf system library](https://wkhtmltopdf.org/).

  You also need to have an instance of MongoDB running. I've found that it's easiest to do using the official Docker image:

  ```bash
  docker run --name mongo -p 27017:27017 mongo
  ```





  Once installed, you can setup Scout by running a few commands using the included command line interface. Given you have a MongoDB server listening on the default port (27017), this is how you would setup a fully working Scout demo:

  ```bash
  scout setup demo
  ```

  This will setup an instance of scout with a database called `scout-demo`. Now run

  ```bash
  scout --demo serve
  ```
  And play around with the interface. A user has been created with email clark.kent@mail.com so use that address to get access



  To initialize a working instance with all genes, diseases etc run

  ```bash
  scout setup database
  ```

  for more info, run `scout --help`

  The previous command initializes the database with a curated collection of gene definitions with links to OMIM along with HPO phenotype terms. Now we will load some example data. Scout expects the analysis to be accomplished using various gene panels so let's load one and then our first analysis case:

  ```bash
  scout load panel scout/demo/panel_1.txt
  scout load case scout/demo/643594.config.yaml
  ```



  Scout may be configured to visualize coverage reports produced by [Chanjo][chanjo] or [chanjo2][chanjo2]. Instructions on
  how to enable this feature can be found in the document [chanjo_coverage_integration][chanjo-scout].



  Scout may be configured to visualize local variant frequencies monitored by [Loqusdb][loqusdb].
  Instructions on how to enable this feature can be found in the document
  [loqusdb integration][loqusdb-scout].



  Scout may be configured to link to a local [Gens][gens] installation.
  Instructions on how to enable this feature can be found in the document
  [Gens integration][gens-scout].



  Scout needs a server config to know which databases to connect to etc. Depending on which
  information you provide you activate different parts of the interface automatically,
  including user authentication, coverage, and local observations.

  This is an example of the config file:

  ```python



  ADMINS = ['paul.anderson@magnolia.com']

  MONGO_HOST = 'localhost'
  MONGO_PORT = 27017
  MONGO_DBNAME = 'scout'
  MONGO_USERNAME = 'testUser'
  MONGO_PASSWORD = 'testPass'


  GOOGLE = dict(
     client_id="client_id_string.apps.googleusercontent.com",
     client_secret="client_secret_string",
     discovery_url="https://accounts.google.com/.well-known/openid-configuration"
  )


  PHENOMIZER_USERNAME = '???'
  PHENOMIZER_PASSWORD = '???'


  SQLALCHEMY_DATABASE_URI = '???'
  REPORT_LANGUAGE = 'en'  # or 'sv'


  SQLALCHEMY_TRACK_MODIFICATIONS = False  # this is essential in production
  TEMPLATES_AUTO_RELOAD = False  			# consider turning off in production
  SECRET_KEY = 'secret key'               # override in production!
  ```

  Most of the config settings are optional. A minimal config would consist of SECRET_KEY and MONGO_DBNAME.

  Starting the server in now really easy, for the demo and local development we will use the CLI:

  ```bash
  scout --flask-config config.py serve
  ```

  ![Scout Interface demo](artwork/scout-variant-demo.png)



  When running the server in production you will likely want to use a proper Python server solution
  such as Gunicorn.
  This is also how we can multiprocess the server and use encrypted HTTPS connections.

  ```bash
  SCOUT_CONFIG=./config.py gunicorn --workers 4 --bind 0.0.0.0:8080 scout.server.auto:app
  ```

  For added security and flexibility, we recommend a reverse proxy solution like NGINX.


  Scout currently supports 3 mutually exclusive types of login:
  - Google authentication via OpenID Connect (OAuth 2.0)
  - LDAP authentication
  - Simple authentication using userid and password

  The first 2 solutions are both suitable for a production server. A description on how to set up an advanced login system is available in the [admin guide](docs/admin-guide/login-system.md)




  Starting from release 4.4, Scout offers integration for patient data sharing via Matchmaker
  Exchange.
  General info about Matchmaker and patient matching could be found in [this paper][matchmaker-pub].
  For a technical guideline of our implementation of Matchmaker Exchange at Clinical Genomics and its
  integration with Scout check scouts [matchmaker docs][matchmaker-scout].
  A user-oriented guide describing how to share case and variant data to Matchmaker using Scout can
  be found [here][matchmaker-scout-sharing].




  To keep the code base consistent, formatting with [Black](https://github.com/psf/black) is always applied as part of the PR submission process via GitHub Actions. While not strictly required, to avoid confusion, it is suggested that developers apply Black locally.
  Black defaults to 88 characters per line, we use 100.

  To format all the files in the project run:

  ```bash
  black --line-length 100 .
  ```

  We recommend using Black with [pre-commit](https://github.com/pre-commit/pre-commit).
  In `.pre-commit-config.yaml` you can find the pre-commit configuration.
  To enable this configuration run:

  ```bash
  pre-commit install
  ```



  To run unit tests:

  ```bash
  pytest
  ```




  If you want to contribute and make Scout better, you help is very appreciated! Bug reports or
  feature requests are really helpful and can be submitted via github issues.
  Feel free to open a pull request to add a new functionality or fixing a bug, we welcome any help,
  regardless of the amount of code provided or your skills as a programmer.
  More info on how to contribute to the project and a description of the Scout branching workflow can
  be found in [CONTRIBUTING](CONTRIBUTING.md).



  [chanjo]: https://github.com/Clinical-Genomics/chanjo
  [chanjo2]: https://github.com/Clinical-Genomics/chanjo2
  [chanjo-scout]: docs/admin-guide/chanjo_coverage_integration.md
  [loqusdb]: https://github.com/moonso/loqusdb
  [loqusdb-scout]: docs/admin-guide/loqusdb_integration.md
  [gens]: https://github.com/Clinical-Genomics-Lund/gens
  [gens-scout]: docs/admin-guide/gens_integration.md
  [github-release-date]: https://img.shields.io/github/release-date/Clinical-Genomics/scout
  [matchmaker-pub]: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6016856/
  [matchmaker-scout]: docs/admin-guide/matchmaker_exchange_integration.md
  [matchmaker-scout-sharing]: docs/user-guide/cases.md#matchmaker-exchange-integration
  [travis-img]: https://img.shields.io/travis/Clinical-Genomics/scout/develop.svg?style=flat-square
  [travis-url]: https://travis-ci.org/Clinical-Genomics/scout
  [pypi-img]: https://img.shields.io/pypi/v/scout-browser.svg?style=flat-square
  [pypi-url]: https://pypi.python.org/pypi/scout-browser/
  [ismaintained-resolve-img]: http://isitmaintained.com/badge/resolution/Clinical-Genomics/scout.svg
  [ismaintained-resolve-url]: http://isitmaintained.com/project/Clinical-Genomics/scout
  [ismaintained-open-rate-img]: http://isitmaintained.com/badge/open/Clinical-Genomics/scout.svg
  [ismaintained-open-rate-url]: http://isitmaintained.com/project/Clinical-Genomics/scout
  [closed-issues-img]: https://img.shields.io/github/issues-closed/Clinical-Genomics/scout.svg
  [closed-issues-url]: https://GitHub.com/Clinical-Genomics/scout/issues?q=is%3Aissue+is%3Aclosed
  [codecov-img]: https://codecov.io/gh/Clinical-Genomics/scout/branch/main/graph/badge.svg?token=BOhMTZ4T3c
  [codecov-url]: https://codecov.io/gh/Clinical-Genomics/scout
  [actions-build-status]: https://github.com/Clinical-Genomics/scout/actions/workflows/build_and_publish.yml/badge.svg
  [black-image]: https://img.shields.io/badge/code%20style-black-000000.svg
  [black-url]: https://github.com/psf/black
  [woke-image]: https://github.com/Clinical-Genomics/scout/actions/workflows/woke.yml/badge.svg
  [woke-url]: https://github.com/Clinical-Genomics/scout/actions/workflows/woke.yml


pkgId: 8014abd137c8c4174234bc7cdcac980d60efc9e81406f2c0c2d627af2d5e83bd
name: python-scparadise-help
arch: noarch
version: 0.2.0b0
epoch: 0
release: 1
summary: Development documents and examples for scparadise
url: https://pypi.org/project/scparadise/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scparadise-0.2.0b0-1.src.rpm
location_href: Packages/python-scparadise-help-0.2.0b0-1.noarch.rpm
checksum_type: sha256
description:
  Tunable highly accurate multi-class cell type annotation and surface protein abundance prediction in single cell RNA-seq data.


pkgId: d4a241f3d1dbb9a247b945c15634d1568f1e78c1b8a313bd9ae9042bb3b585ea
name: python-scpi-pkg-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for scpi-pkg
url: https://nppackages.github.io/scpi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scpi-pkg-2.3.0-1.src.rpm
location_href: Packages/python-scpi-pkg-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  The `scpi_pkg` package provides Python implementations of estimation and inference procedures for Synthetic Control methods.



  Matias D. Cattaneo (<cattaneo@princeton.edu>)

  Yingjie Feng (<fengyj@sem.tsinghua.edu.cn>)

  Filippo Palomba (<fpalomba@princeton.edu>)

  Rocio Titiunik (<titiunik@princeton.edu>)



  https://nppackages.github.io/scpi/



  To install/update use pip

  ```
  pip install scpi_pkg
  ```



  ```
  from from scpi_pkg.scdata import scdata
  from from scpi_pkg.scdataMulti import scdataMulti
  from scpi_pkg.scest import scest
  from scpi_pkg.scpi import scpi
  from scpi_pkg.scplot import scplot
  from scpi_pkg.scplotMulti import scplotMulti
  ```

  - Replication: [Germany reunification example](https://github.com/nppackages/scpi/blob/main/Python/scpi_illustration.py).



  - cvxpy          (>= 1.1.18)
  - dask            (>= 2021.04.0)
  - ecos            (>= 2.0.7)
  - luddite         (>= 1.0.2)
  - numpy         (>= 1.20.1)
  - pandas        (>= 1.5.0)
  - plotnine       (>= 0.8.0)
  - scikit-learn  (>= 0.24.1)
  - scipy            (>= 1.7.1)
  - statsmodels (>= 0.12.2)



  For overviews and introductions, see [nppackages website](https://nppackages.github.io/).



  - Cattaneo, Feng, Palomba, and Titiunik (2024+) [scpi: Uncertainty Quantification for Synthetic Control Estimators](https://arxiv.org/abs/2202.05984). forthcoming at *Journal of Statistical Software.*



  - Cattaneo, Feng, and Titiunik (2021): [Prediction Intervals for Synthetic Control Methods](https://cattaneo.princeton.edu/papers/Cattaneo-Feng-Titiunik_2021_JASA.pdf).
    _Journal of the American Statistical Association_.
  - Cattaneo, Feng, Palomba, and Titiunik (2023): [Uncertainty Quantification in Synthetic Controls with Staggered Treatment Adoption](https://arxiv.org/abs/2210.05026), working paper.


pkgId: 0c2d2434f848dcc7418c835a95728469cb78b1856d54b4f816a702f24d0bcd2c
name: python-scrachy-help
arch: noarch
version: 0.12.0
epoch: 0
release: 1
summary: Development documents and examples for scrachy
url: https://bitbucket.org/reidswanson/scrachy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scrachy-0.12.0-1.src.rpm
location_href: Packages/python-scrachy-help-0.12.0-1.noarch.rpm
checksum_type: sha256
description:
  Scrachy was primarily developed to provide a flexible cache storage backend for [Scrapy](https://scrapy.org/) that stores its data in a relational database using [SQLAlchemy](https://www.sqlalchemy.org/).
  However, it now has several other additional features including middleware for using Selenium to download requests.
  It also comes with a downloader middleware that will optionally ignore requests that are already in the cache.


  You can install the latest version from git:

  ```
  >pip install git+https://bitbucket.org/reidswanson/scrachy.git
  ```

  or from PyPI:

  ```
  >pip install scrachy
  ```


  A brief guide to minimally using the cache storage engine and the Selenium backend are given below.
  For other configuration options and features please see the full documentation on [Read the Docs](https://scrachy.readthedocs.io/en/latest).


  To (minimally) use the storage backend you simply need to enable caching by adding the following to your `settings.py` file:
  ```python

  HTTPCACHE_ENABLED = True


  HTTPCACHE_STORAGE = 'scrachy.middleware.httpcache.AlchemyCacheStorage'


  SCRACHY_DB_DIALECT = '<database-dialect>'


  SCRACHY_DB_DRIVER = '<database-driver>'


  SCRACHY_DB_HOST = '<database-hostname>'
  SCRACHY_DB_PORT = '<database-port>'
  SCRACHY_DB_SCHEMA = <database-schema>
  SCRACHY_DB_DATABASE = '<database-name>'
  SCRACHY_DB_USERNAME = '<username>'



  SCRACHY_DB_PASSWORD = '<password>'


  SCRACHY_DB_CONNECT_ARGS = {}



  DOWNLOADER_MIDDLEWARES = {
     ...
     'scrapy.downloadermiddlewares.http.compression.HttpCompressionMiddleware': None,
  }
  ```


  There are two Selenium middleware classes provided by Scrachy.
  To use them, first add one of them to the `DOWNLOADER_MIDDLEWARES`

  ```python
  DOWNLOADER_MIDDLEWARES = {
      ...
      'scrachy.middleware.selenium.SeleniumMiddleware': 800,  # or AsyncSeleniumMiddleware
      ...
  }
  ```

  Then in your spider parsing code use a `SeleniumRequest` instead of a `scrapy.http.Request`.



  Scrachy is released using the GNU Lesser General Public License.
  See the [LICENSE](LICENSE.md) file for more details.
  Files that are adapted or use code from other sources are indicated either at the top of the file or at the location of the code snippet.
  Some of these files were adapted from code released under a 3-clause BSD license.
  Those files should indicate the original copyright in a comment at the top of the file.
  See the [BSD_LICENSE](BSD_LICENSE.md) file for details of this license.

rpm_license:
  # GNU LESSER GENERAL PUBLIC LICENSE  Version 3, 29 June 2007  Copyright © 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.  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:  1. 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 2. 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:  1. 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. 2. 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:  1. 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. 2. Accompany the Combined Work with a copy of the GNU GPL and this license document. 3. 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. 4. Do one of the following: 1. 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. 2. 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. 5. 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 4.4.1., the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4.4.2., 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:  1. 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. 2. 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: fe1c47e6064a57d21fd1ffea95c7d4183e54f610a8446b43e918e756c4732059
name: python-scrapeless-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for scrapeless
url: https://github.com/scrapeless-ai/scrapeless-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scrapeless-0.0.2-1.src.rpm
location_href: Packages/python-scrapeless-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  ```shell
  pip install scrapeless
  ```



  Start using the API with your [API KEY](https://app.scrapeless.com/dashboard/account?tab=apiKey)

  For more examples, please refer to the `examples` directory

  For more information, please refer to our [documentation](https://docs.scrapeless.com/)


  ```python
  from scrapeless import ScrapelessClient

  scrapeless = ScrapelessClient(api_key='your-api-key')

  actor = "scraper.shopee"
  input_data = {
    "type": "shopee.product",
    "url": "https://shopee.tw/2312312.10228173.24803858474"
  }

  result = scrapeless.scraper(actor, input=input_data)
  ```


  ```python
  from scrapeless import ScrapelessClient

  scrapeless = ScrapelessClient(api_key='your-api-key')

  actor = 'unlocker.webunlocker'
  input_data = {
    "url": "https://www.scrapeless.com",
    "proxy_country": "ANY",
    "method": "GET",
    "redirect": false,
  }

  result = scrapeless.unlocker(actor, input=input_data)
  ```


  ```python
  from scrapeless import ScrapelessClient

  scrapeless = ScrapelessClient(api_key='your-api-key')

  actor = 'captcha.recaptcha'
  input_data = {
    "version": "v2",
    "pageURL": "https://www.google.com",
    "siteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "pageAction": ""
  }

  result = scrapeless.captcha(actor, input=input_data)
  ```


pkgId: e0fd0da588556e91325b7aa575671c8d1803be24c72edaa5abd028143689df41
name: python-scrapingpros-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for scrapingpros
url: https://gitlab.com/7Puentes/batua2/sprosdata-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scrapingpros-0.1.3-1.src.rpm
location_href: Packages/python-scrapingpros-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  The **ScrapingPros' API Client for Python** is the official library to access the ScrapingPros' API from your Python applications. It provides useful features like jobs running retries and convenience functions to improve your experience with the ScrapingPros' API.



  Requires **Python 3.6+**
  You can install the package from its [PyPI listing](https://test.pypi.org/project/scrapingpros/). Just by running `pip install scrapingpros` in your terminal. You may need to install requests package too. `pip install requests`


  For usage instructions, check the [documentation on ScrapingPros' Docs](https://console.sprosdata.com/docs).


  ```python
  from scraping_pros import Batch, Project, Job


  PROJECT_ID = 64 #

  API_KEY = "your-api-key"
   
  project = Project(api_key=API_KEY, project_id=PROJECT_ID, verbose=True)
  first_batch = project.create_batch("first_batch")



  url_to_scrape = ["url"]
  first_batch.append_jobs(url_to_scrape, ScrapMode.PUPPETEER)


  first_batch.run()


  data = first_batch.get_data()
  ```

  The package provides tools to manage every aspect of running jobs and retrieving data. It includes functions to easily execute and access data for `Batches` and `Jobs`.


  The package automatically retries any operation—such as `run()` or `get_data()`—to handle intermittent issues and improve reliability.


pkgId: c451ecea397a0d2350d6f0d49397bb4f05a41b193ed86491f217e59b4989a3ce
name: python-scrapling-help
arch: noarch
version: 0.2.9
epoch: 0
release: 1
summary: Development documents and examples for scrapling
url: https://github.com/D4Vinci/Scrapling
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scrapling-0.2.9-1.src.rpm
location_href: Packages/python-scrapling-help-0.2.9-1.noarch.rpm
checksum_type: sha256
description:
    * [Key Features](#key-features)
      * [Fetch websites as you prefer](#fetch-websites-as-you-prefer-with-async-support)
      * [Adaptive Scraping](#adaptive-scraping)
      * [Performance](#performance)
      * [Developing Experience](#developing-experience)
    * [Getting Started](#getting-started)
    * [Parsing Performance](#parsing-performance)
      * [Text Extraction Speed Test (5000 nested elements).](#text-extraction-speed-test-5000-nested-elements)
      * [Extraction By Text Speed Test](#extraction-by-text-speed-test)
    * [Installation](#installation)
    * [Fetching Websites](#fetching-websites)
      * [Features](#features)
      * [Fetcher class](#fetcher)
      * [StealthyFetcher class](#stealthyfetcher)
      * [PlayWrightFetcher class](#playwrightfetcher)
    * [Advanced Parsing Features](#advanced-parsing-features)
      * [Smart Navigation](#smart-navigation)
      * [Content-based Selection & Finding Similar Elements](#content-based-selection--finding-similar-elements)
      * [Handling Structural Changes](#handling-structural-changes)
        * [Real World Scenario](#real-world-scenario)
      * [Find elements by filters](#find-elements-by-filters)
      * [Is That All?](#is-that-all)
    * [More Advanced Usage](#more-advanced-usage)
    * [⚡ Enlightening Questions and FAQs](#-enlightening-questions-and-faqs)
      * [How does auto-matching work?](#how-does-auto-matching-work)
      * [How does the auto-matching work if I didn't pass a URL while initializing the Adaptor object?](#how-does-the-auto-matching-work-if-i-didnt-pass-a-url-while-initializing-the-adaptor-object)
      * [If all things about an element can change or get removed, what are the unique properties to be saved?](#if-all-things-about-an-element-can-change-or-get-removed-what-are-the-unique-properties-to-be-saved)
      * [I have enabled the `auto_save`/`auto_match` parameter while selecting and it got completely ignored with a warning message](#i-have-enabled-the-auto_saveauto_match-parameter-while-selecting-and-it-got-completely-ignored-with-a-warning-message)
      * [I have done everything as the docs but the auto-matching didn't return anything, what's wrong?](#i-have-done-everything-as-the-docs-but-the-auto-matching-didnt-return-anything-whats-wrong)
      * [Can Scrapling replace code built on top of BeautifulSoup4?](#can-scrapling-replace-code-built-on-top-of-beautifulsoup4)
      * [Can Scrapling replace code built on top of AutoScraper?](#can-scrapling-replace-code-built-on-top-of-autoscraper)
      * [Is Scrapling thread-safe?](#is-scrapling-thread-safe)
    * [More Sponsors!](#more-sponsors)
    * [Contributing](#contributing)
    * [Disclaimer for Scrapling Project](#disclaimer-for-scrapling-project)
    * [License](#license)
    * [Acknowledgments](#acknowledgments)
    * [Thanks and References](#thanks-and-references)
    * [Known Issues](#known-issues)


  - **HTTP requests**: Stealthy and fast HTTP requests with `Fetcher`
  - **Stealthy fetcher**: Annoying anti-bot protection? No problem! Scrapling can bypass almost all of them with `StealthyFetcher` with default configuration!
  - **Your preferred browser**: Use your real browser with CDP, [NSTbrowser](https://app.nstbrowser.io/r/1vO5e5)'s browserless, PlayWright with stealth mode, or even vanilla PlayWright -  All is possible with `PlayWrightFetcher`!

  - 🔄 **Smart Element Tracking**: Locate previously identified elements after website structure changes, using an intelligent similarity system and integrated storage.
  - 🎯 **Flexible Querying**: Use CSS selectors, XPath, Elements filters, text search, or regex - chain them however you want!
  - 🔍 **Find Similar Elements**: Automatically locate elements similar to the element you want on the page (Ex: other products like the product you found on the page).
  - 🧠 **Smart Content Scraping**: Extract data from multiple websites without specific selectors using Scrapling powerful features.

  - 🚀 **Lightning Fast**: Built from the ground up with performance in mind, outperforming most popular Python scraping libraries (outperforming BeautifulSoup in parsing by up to 620x in our tests).
  - 🔋 **Memory Efficient**: Optimized data structures for minimal memory footprint.
  - ⚡ **Fast JSON serialization**: 10x faster JSON serialization than the standard json library with more options.

  - 🛠️ **Powerful Navigation API**: Traverse the DOM tree easily in all directions and get the info you want (parent, ancestors, sibling, children, next/previous element, and more).
  - 🧬 **Rich Text Processing**: All strings have built-in methods for regex matching, cleaning, and more. All elements' attributes are read-only dictionaries that are faster than standard dictionaries with added methods.
  - 📝 **Automatic Selector Generation**: Create robust CSS/XPath selectors for any element.
  - 🔌 **API Similar to Scrapy/BeautifulSoup**: Familiar methods and similar pseudo-elements for Scrapy and BeautifulSoup users.
  - 📘 **Type hints and test coverage**: Complete type coverage and almost full test coverage for better IDE support and fewer bugs, respectively.

  ```python
  from scrapling import Fetcher
  fetcher = Fetcher(auto_match=False)

  page = fetcher.get('https://quotes.toscrape.com/', stealthy_headers=True)

  page.get_all_text(ignore_tags=('script', 'style'))

  quotes = page.css('.quote .text::text')  # CSS selector
  quotes = page.xpath('//span[@class="text"]/text()')  # XPath
  quotes = page.css('.quote').css('.text::text')  # Chained selectors
  quotes = [element.text for element in page.css('.quote .text')]  # Slower than bulk query above

  quote = page.css_first('.quote')  # / page.css('.quote').first / page.css('.quote')[0]

  quotes = page.find_all('div', {'class': 'quote'})

  quotes = page.find_all('div', class_='quote')
  quotes = page.find_all(['div'], class_='quote')
  quotes = page.find_all(class_='quote')  # and so on...

  quote.html_content  # Inner HTML
  quote.prettify()  # Prettified version of Inner HTML
  quote.attrib  # Element attributes
  quote.path  # DOM path to element (List)
  ```
  To keep it simple, all methods can be chained on top of each other!

  Scrapling isn't just powerful - it's also blazing fast. Scrapling implements many best practices, design patterns, and numerous optimizations to save fractions of seconds. All of that while focusing exclusively on parsing HTML documents.
  Here are benchmarks comparing Scrapling to popular Python libraries in two tests.

  | # |      Library      | Time (ms) | vs Scrapling |
  |---|:-----------------:|:---------:|:------------:|
  | 1 |     Scrapling     |   5.44    |     1.0x     |
  | 2 |   Parsel/Scrapy   |   5.53    |    1.017x    |
  | 3 |     Raw Lxml      |   6.76    |    1.243x    |
  | 4 |      PyQuery      |   21.96   |    4.037x    |
  | 5 |    Selectolax     |   67.12   |   12.338x    |
  | 6 |   BS4 with Lxml   |  1307.03  |   240.263x   |
  | 7 |  MechanicalSoup   |  1322.64  |   243.132x   |
  | 8 | BS4 with html5lib |  3373.75  |   620.175x   |
  As you see, Scrapling is on par with Scrapy and slightly faster than Lxml which both libraries are built on top of. These are the closest results to Scrapling. PyQuery is also built on top of Lxml but still, Scrapling is 4 times faster.

  |   Library   | Time (ms) | vs Scrapling |
  |:-----------:|:---------:|:------------:|
  |  Scrapling  |   2.51    |     1.0x     |
  | AutoScraper |   11.41   |    4.546x    |
  Scrapling can find elements with more methods and it returns full element `Adaptor` objects not only the text like AutoScraper. So, to make this test fair, both libraries will extract an element with text, find similar elements, and then extract the text content for all of them. As you see, Scrapling is still 4.5 times faster at the same task.
  > All benchmarks' results are an average of 100 runs. See our [benchmarks.py](https://github.com/D4Vinci/Scrapling/blob/main/benchmarks.py) for methodology and to run your comparisons.

  Scrapling is a breeze to get started with - Starting from version 0.2.9, we require at least Python 3.9 to work.
  ```bash
  pip3 install scrapling
  ```
  - For using the `StealthyFetcher`, go to the command line and download the browser with
  <details><summary>Windows OS</summary>
  ```bash
  camoufox fetch --browserforge
  ```
  </details>
  <details><summary>MacOS</summary>
  ```bash
  python3 -m camoufox fetch --browserforge
  ```
  </details>
  <details><summary>Linux</summary>
  ```bash
  python -m camoufox fetch --browserforge
  ```
  On a fresh installation of Linux, you may also need the following Firefox dependencies:
  - Debian-based distros
      ```bash
      sudo apt install -y libgtk-3-0 libx11-xcb1 libasound2
      ```
  - Arch-based distros
      ```bash
      sudo pacman -S gtk3 libx11 libxcb cairo libasound alsa-lib
      ```
  </details>
  <small> See the official <a href="https://camoufox.com/python/installation/#download-the-browser">Camoufox documentation</a> for more info on installation</small>
  - If you are going to use the `PlayWrightFetcher` options, then install Playwright's Chromium browser with:
  ```commandline
  playwright install chromium
  ```
  - If you are going to use normal requests only with the `Fetcher` class then update the fingerprints files with:
  ```commandline
  python -m browserforge update
  ```

  Fetchers are basically interfaces that do requests or fetch pages for you in a single request fashion and then return an `Adaptor` object for you. This feature was introduced because the only option we had before was to fetch the page as you wanted it, then pass it manually to the `Adaptor` class to create an `Adaptor` instance and start playing around with the page.

  You might be slightly confused by now so let me clear things up. All fetcher-type classes are imported in the same way
  ```python
  from scrapling import Fetcher, StealthyFetcher, PlayWrightFetcher
  ```
  All of them can take these initialization arguments: `auto_match`, `huge_tree`, `keep_comments`, `keep_cdata`, `storage`, and `storage_args`, which are the same ones you give to the `Adaptor` class.
  If you don't want to pass arguments to the generated `Adaptor` object and want to use the default values, you can use this import instead for cleaner code:
  ```python
  from scrapling.defaults import Fetcher, AsyncFetcher, StealthyFetcher, PlayWrightFetcher
  ```
  then use it right away without initializing like:
  ```python
  page = StealthyFetcher.fetch('https://example.com')
  ```
  Also, the `Response` object returned from all fetchers is the same as the `Adaptor` object except it has these added attributes: `status`, `reason`, `cookies`, `headers`, and `request_headers`. All `cookies`, `headers`, and `request_headers` are always of type `dictionary`.
  > [!NOTE]
  > The `auto_match` argument is enabled by default which is the one you should care about the most as you will see later.

  This class is built on top of [httpx](https://www.python-httpx.org/) with additional configuration options, here you can do `GET`, `POST`, `PUT`, and `DELETE` requests.
  For all methods, you have `stealthy_headers` which makes `Fetcher` create and use real browser's headers then create a referer header as if this request came from Google's search of this URL's domain. It's enabled by default. You can also set the number of retries with the argument `retries` for all methods and this will make httpx retry requests if it failed for any reason. The default number of retries for all `Fetcher` methods is 3.
  You can route all traffic (HTTP and HTTPS) to a proxy for any of these methods in this format `http://username:password@localhost:8030`
  ```python
  >> page = Fetcher().get('https://httpbin.org/get', stealthy_headers=True, follow_redirects=True)
  >> page = Fetcher().post('https://httpbin.org/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
  >> page = Fetcher().put('https://httpbin.org/put', data={'key': 'value'})
  >> page = Fetcher().delete('https://httpbin.org/delete')
  ```
  For Async requests, you will just replace the import like below:
  ```python
  >> from scrapling import AsyncFetcher
  >> page = await AsyncFetcher().get('https://httpbin.org/get', stealthy_headers=True, follow_redirects=True)
  >> page = await AsyncFetcher().post('https://httpbin.org/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030')
  >> page = await AsyncFetcher().put('https://httpbin.org/put', data={'key': 'value'})
  >> page = await AsyncFetcher().delete('https://httpbin.org/delete')
  ```

  This class is built on top of [Camoufox](https://github.com/daijro/camoufox), bypassing most anti-bot protections by default. Scrapling adds extra layers of flavors and configurations to increase performance and undetectability even further.
  ```python
  >> page = StealthyFetcher().fetch('https://www.browserscan.net/bot-detection')  # Running headless by default
  >> page.status == 200
  True
  >> page = await StealthyFetcher().async_fetch('https://www.browserscan.net/bot-detection')  # the async version of fetch
  >> page.status == 200
  True
  ```
  > Note: all requests done by this fetcher are waiting by default for all JS to be fully loaded and executed so you don't have to :)
  <details><summary><strong>For the sake of simplicity, expand this for the complete list of arguments</strong></summary>
  |      Argument       | Description                                                                                                                                                                                                                                                                                                                                                                                                     | Optional |
  |:-------------------:|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------:|
  |         url         | Target url                                                                                                                                                                                                                                                                                                                                                                                                      |    ❌     |
  |      headless       | Pass `True` to run the browser in headless/hidden (**default**), `virtual` to run it in virtual screen mode, or `False` for headful/visible mode. The `virtual` mode requires having `xvfb` installed.                                                                                                                                                                                                          |    ✔️    |
  |    block_images     | Prevent the loading of images through Firefox preferences. _This can help save your proxy usage but be careful with this option as it makes some websites never finish loading._                                                                                                                                                                                                                                |    ✔️    |
  |  disable_resources  | Drop requests of unnecessary resources for a speed boost. It depends but it made requests ~25% faster in my tests for some websites.<br/>Requests dropped are of type `font`, `image`, `media`, `beacon`, `object`, `imageset`, `texttrack`, `websocket`, `csp_report`, and `stylesheet`. _This can help save your proxy usage but be careful with this option as it makes some websites never finish loading._ |    ✔️    |
  |    google_search    | Enabled by default, Scrapling will set the referer header to be as if this request came from a Google search for this website's domain name.                                                                                                                                                                                                                                                                    |    ✔️    |
  |    extra_headers    | A dictionary of extra headers to add to the request. _The referer set by the `google_search` argument takes priority over the referer set here if used together._                                                                                                                                                                                                                                               |    ✔️    |
  |    block_webrtc     | Blocks WebRTC entirely.                                                                                                                                                                                                                                                                                                                                                                                         |    ✔️    |
  |     page_action     | Added for automation. A function that takes the `page` object, does the automation you need, then returns `page` again.                                                                                                                                                                                                                                                                                         |    ✔️    |
  |       addons        | List of Firefox addons to use. **Must be paths to extracted addons.**                                                                                                                                                                                                                                                                                                                                           |    ✔️    |
  |      humanize       | Humanize the cursor movement. Takes either True or the MAX duration in seconds of the cursor movement. The cursor typically takes up to 1.5 seconds to move across the window.                                                                                                                                                                                                                                  |    ✔️    |
  |     allow_webgl     | Enabled by default. Disabling it WebGL not recommended as many WAFs now checks if WebGL is enabled.                                                                                                                                                                                                                                                                                                             |    ✔️    |
  |        geoip        | Recommended to use with proxies; Automatically use IP's longitude, latitude, timezone, country, locale, & spoof the WebRTC IP address. It will also calculate and spoof the browser's language based on the distribution of language speakers in the target region.                                                                                                                                             |    ✔️    |
  |     disable_ads     | Enabled by default, this installs `uBlock Origin` addon on the browser if enabled.                                                                                                                                                                                                                                                                                                                              |    ✔️    |
  |    network_idle     | Wait for the page until there are no network connections for at least 500 ms.                                                                                                                                                                                                                                                                                                                                   |    ✔️    |
  |       timeout       | The timeout in milliseconds that is used in all operations and waits through the page. The default is 30000.                                                                                                                                                                                                                                                                                                    |    ✔️    |
  |    wait_selector    | Wait for a specific css selector to be in a specific state.                                                                                                                                                                                                                                                                                                                                                     |    ✔️    |
  |        proxy        | The proxy to be used with requests, it can be a string or a dictionary with the keys 'server', 'username', and 'password' only.                                                                                                                                                                                                                                                                                 |    ✔️    |
  |    os_randomize     | If enabled, Scrapling will randomize the OS fingerprints used. The default is Scrapling matching the fingerprints with the current OS.                                                                                                                                                                                                                                                                          |    ✔️    |
  | wait_selector_state | The state to wait for the selector given with `wait_selector`. _Default state is `attached`._                                                                                                                                                                                                                                                                                                                   |    ✔️    |
  </details>
  This list isn't final so expect a lot more additions and flexibility to be added in the next versions!

  This class is built on top of [Playwright](https://playwright.dev/python/) which currently provides 4 main run options but they can be mixed as you want.
  ```python
  >> page = PlayWrightFetcher().fetch('https://www.google.com/search?q=%22Scrapling%22', disable_resources=True)  # Vanilla Playwright option
  >> page.css_first("#search a::attr(href)")
  'https://github.com/D4Vinci/Scrapling'
  >> page = await PlayWrightFetcher().async_fetch('https://www.google.com/search?q=%22Scrapling%22', disable_resources=True)  # the async version of fetch
  >> page.css_first("#search a::attr(href)")
  'https://github.com/D4Vinci/Scrapling'
  ```
  > Note: all requests done by this fetcher are waiting by default for all JS to be fully loaded and executed so you don't have to :)
  Using this Fetcher class, you can make requests with:
    1) Vanilla Playwright without any modifications other than the ones you chose.
    2) Stealthy Playwright with the stealth mode I wrote for it. It's still a WIP but it bypasses many online tests like [Sannysoft's](https://bot.sannysoft.com/).</br> Some of the things this fetcher's stealth mode does include:
       * Patching the CDP runtime fingerprint.
       * Mimics some of the real browsers' properties by injecting several JS files and using custom options.
       * Using custom flags on launch to hide Playwright even more and make it faster.
       * Generates real browser's headers of the same type and same user OS then append it to the request's headers.
    3) Real browsers by passing the `real_chrome` argument or the CDP URL of your browser to be controlled by the Fetcher and most of the options can be enabled on it.
    4) [NSTBrowser](https://app.nstbrowser.io/r/1vO5e5)'s [docker browserless](https://hub.docker.com/r/nstbrowser/browserless) option by passing the CDP URL and enabling `nstbrowser_mode` option.
  > Hence using the `real_chrome` argument requires that you have Chrome browser installed on your device
  Add that to a lot of controlling/hiding options as you will see in the arguments list below.
  <details><summary><strong>Expand this for the complete list of arguments</strong></summary>
  |      Argument       | Description                                                                                                                                                                                                                                                                                                                                                                                                     | Optional |
  |:-------------------:|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------:|
  |         url         | Target url                                                                                                                                                                                                                                                                                                                                                                                                      |    ❌     |
  |      headless       | Pass `True` to run the browser in headless/hidden (**default**), or `False` for headful/visible mode.                                                                                                                                                                                                                                                                                                           |    ✔️    |
  |  disable_resources  | Drop requests of unnecessary resources for a speed boost. It depends but it made requests ~25% faster in my tests for some websites.<br/>Requests dropped are of type `font`, `image`, `media`, `beacon`, `object`, `imageset`, `texttrack`, `websocket`, `csp_report`, and `stylesheet`. _This can help save your proxy usage but be careful with this option as it makes some websites never finish loading._ |    ✔️    |
  |      useragent      | Pass a useragent string to be used. **Otherwise the fetcher will generate a real Useragent of the same browser and use it.**                                                                                                                                                                                                                                                                                    |    ✔️    |
  |    network_idle     | Wait for the page until there are no network connections for at least 500 ms.                                                                                                                                                                                                                                                                                                                                   |    ✔️    |
  |       timeout       | The timeout in milliseconds that is used in all operations and waits through the page. The default is 30000.                                                                                                                                                                                                                                                                                                    |    ✔️    |
  |     page_action     | Added for automation. A function that takes the `page` object, does the automation you need, then returns `page` again.                                                                                                                                                                                                                                                                                         |    ✔️    |
  |    wait_selector    | Wait for a specific css selector to be in a specific state.                                                                                                                                                                                                                                                                                                                                                     |    ✔️    |
  | wait_selector_state | The state to wait for the selector given with `wait_selector`. _Default state is `attached`._                                                                                                                                                                                                                                                                                                                   |    ✔️    |
  |    google_search    | Enabled by default, Scrapling will set the referer header to be as if this request came from a Google search for this website's domain name.                                                                                                                                                                                                                                                                    |    ✔️    |
  |    extra_headers    | A dictionary of extra headers to add to the request. The referer set by the `google_search` argument takes priority over the referer set here if used together.                                                                                                                                                                                                                                                 |    ✔️    |
  |        proxy        | The proxy to be used with requests, it can be a string or a dictionary with the keys 'server', 'username', and 'password' only.                                                                                                                                                                                                                                                                                 |    ✔️    |
  |     hide_canvas     | Add random noise to canvas operations to prevent fingerprinting.                                                                                                                                                                                                                                                                                                                                                |    ✔️    |
  |    disable_webgl    | Disables WebGL and WebGL 2.0 support entirely.                                                                                                                                                                                                                                                                                                                                                                  |    ✔️    |
  |       stealth       | Enables stealth mode, always check the documentation to see what stealth mode does currently.                                                                                                                                                                                                                                                                                                                   |    ✔️    |
  |     real_chrome     | If you have Chrome browser installed on your device, enable this and the Fetcher will launch an instance of your browser and use it.                                                                                                                                                                                                                                                                            |    ✔️    |
  |       locale        | Set the locale for the browser if wanted. The default value is `en-US`.                                                                                                                                                                                                                                                                                                                                         |    ✔️    |
  |       cdp_url       | Instead of launching a new browser instance, connect to this CDP URL to control real browsers/NSTBrowser through CDP.                                                                                                                                                                                                                                                                                           |    ✔️    |
  |   nstbrowser_mode   | Enables NSTBrowser mode, **it have to be used with `cdp_url` argument or it will get completely ignored.**                                                                                                                                                                                                                                                                                                      |    ✔️    |
  |  nstbrowser_config  | The config you want to send with requests to the NSTBrowser. _If left empty, Scrapling defaults to an optimized NSTBrowser's docker browserless config._                                                                                                                                                                                                                                                        |    ✔️    |
  </details>
  This list isn't final so expect a lot more additions and flexibility to be added in the next versions!


  ```python
  >>> quote.tag
  'div'
  >>> quote.parent
  <data='<div class="col-md-8"> <div class="quote...' parent='<div class="row"> <div class="col-md-8">...'>
  >>> quote.parent.tag
  'div'
  >>> quote.children
  [<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>,
   <data='<span>by <small class="author" itemprop=...' parent='<div class="quote" itemscope itemtype="h...'>,
   <data='<div class="tags"> Tags: <meta class="ke...' parent='<div class="quote" itemscope itemtype="h...'>]
  >>> quote.siblings
  [<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
   <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
  >>> quote.next  # gets the next element, the same logic applies to `quote.previous`
  <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>
  >>> quote.children.css_first(".author::text")
  'Albert Einstein'
  >>> quote.has_class('quote')
  True

  >>> quote.generate_css_selector
  'body > div > div:nth-of-type(2) > div > div'

  >>> quote.generate_xpath_selector
  '//body/div/div[2]/div/div'
  ```
  If your case needs more than the element's parent, you can iterate over the whole ancestors' tree of any element like below
  ```python
  for ancestor in quote.iterancestors():
      
  ```
  You can search for a specific ancestor of an element that satisfies a function, all you need to do is to pass a function that takes an `Adaptor` object as an argument and return `True` if the condition satisfies or `False` otherwise like below:
  ```python
  >>> quote.find_ancestor(lambda ancestor: ancestor.has_class('row'))
  <data='<div class="row"> <div class="col-md-8">...' parent='<div class="container"> <div class="row...'>
  ```

  You can select elements by their text content in multiple ways, here's a full example on another website:
  ```python
  >>> page = Fetcher().get('https://books.toscrape.com/index.html')
  >>> page.find_by_text('Tipping the Velvet')  # Find the first element whose text fully matches this text
  <data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>
  >>> page.urljoin(page.find_by_text('Tipping the Velvet').attrib['href'])  # We use `page.urljoin` to return the full URL from the relative `href`
  'https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html'
  >>> page.find_by_text('Tipping the Velvet', first_match=False)  # Get all matches if there are more
  [<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]
  >>> page.find_by_regex(r'£[\d\.]+')  # Get the first element that its text content matches my price regex
  <data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>
  >>> page.find_by_regex(r'£[\d\.]+', first_match=False)  # Get all elements that matches my price regex
  [<data='<p class="price_color">£51.77</p>' parent='<div class="product_price"> <p class="pr...'>,
   <data='<p class="price_color">£53.74</p>' parent='<div class="product_price"> <p class="pr...'>,
   <data='<p class="price_color">£50.10</p>' parent='<div class="product_price"> <p class="pr...'>,
   <data='<p class="price_color">£47.82</p>' parent='<div class="product_price"> <p class="pr...'>,
  ```
  Find all elements that are similar to the current element in location and attributes
  ```python

  >>> page.find_by_text('Tipping the Velvet').find_similar(ignore_attributes=['title'])
  [<data='<a href="catalogue/a-light-in-the-attic_...' parent='<h3><a href="catalogue/a-light-in-the-at...'>,
   <data='<a href="catalogue/soumission_998/index....' parent='<h3><a href="catalogue/soumission_998/in...'>,
   <data='<a href="catalogue/sharp-objects_997/ind...' parent='<h3><a href="catalogue/sharp-objects_997...'>,

  >>> len(page.find_by_text('Tipping the Velvet').find_similar(ignore_attributes=['title']))
  19

  >>> [element.attrib['href'] for element in page.find_by_text('Tipping the Velvet').find_similar(ignore_attributes=['title'])]
  ['catalogue/a-light-in-the-attic_1000/index.html',
   'catalogue/soumission_998/index.html',
   'catalogue/sharp-objects_997/index.html',
  ```
  To increase the complexity a little bit, let's say we want to get all books' data using that element as a starting point for some reason
  ```python
  >>> for product in page.find_by_text('Tipping the Velvet').parent.parent.find_similar():
          print({
              "name": product.css_first('h3 a::text'),
              "price": product.css_first('.price_color').re_first(r'[\d\.]+'),
              "stock": product.css('.availability::text')[-1].clean()
          })
  {'name': 'A Light in the ...', 'price': '51.77', 'stock': 'In stock'}
  {'name': 'Soumission', 'price': '50.10', 'stock': 'In stock'}
  {'name': 'Sharp Objects', 'price': '47.82', 'stock': 'In stock'}
  ```
  The [documentation](https://github.com/D4Vinci/Scrapling/tree/main/docs/Examples) will provide more advanced examples.

  Let's say you are scraping a page with a structure like this:
  ```html
  <div class="container">
      <section class="products">
          <article class="product" id="p1">
              <h3>Product 1</h3>
              <p class="description">Description 1</p>
          </article>
          <article class="product" id="p2">
              <h3>Product 2</h3>
              <p class="description">Description 2</p>
          </article>
      </section>
  </div>
  ```
  And you want to scrape the first product, the one with the `p1` ID. You will probably write a selector like this
  ```python
  page.css('#p1')
  ```
  When website owners implement structural changes like
  ```html
  <div class="new-container">
      <div class="product-wrapper">
          <section class="products">
              <article class="product new-class" data-id="p1">
                  <div class="product-info">
                      <h3>Product 1</h3>
                      <p class="new-description">Description 1</p>
                  </div>
              </article>
              <article class="product new-class" data-id="p2">
                  <div class="product-info">
                      <h3>Product 2</h3>
                      <p class="new-description">Description 2</p>
                  </div>
              </article>
          </section>
      </div>
  </div>
  ```
  The selector will no longer function and your code needs maintenance. That's where Scrapling's auto-matching feature comes into play.
  ```python
  from scrapling import Adaptor

  page = Adaptor(page_source, url='example.com')
  element = page.css('#p1' auto_save=True)
  if not element:  # One day website changes?
      element = page.css('#p1', auto_match=True)  # Scrapling still finds it!

  ```
  > How does the auto-matching work? Check the [FAQs](#-enlightening-questions-and-faqs) section for that and other possible issues while auto-matching.

  Let's use a real website as an example and use one of the fetchers to fetch its source. To do this we need to find a website that will change its design/structure soon, take a copy of its source then wait for the website to make the change. Of course, that's nearly impossible to know unless I know the website's owner but that will make it a staged test haha.
  To solve this issue, I will use [The Web Archive](https://archive.org/)'s [Wayback Machine](https://web.archive.org/). Here is a copy of [StackOverFlow's website in 2010](https://web.archive.org/web/20100102003420/http://stackoverflow.com/), pretty old huh?</br>Let's test if the automatch feature can extract the same button in the old design from 2010 and the current design using the same selector :)
  If I want to extract the Questions button from the old design I can use a selector like this `#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a` This selector is too specific because it was generated by Google Chrome.
  Now let's test the same selector in both versions
  ```python
  >> from scrapling import Fetcher
  >> selector = '#hmenus > div:nth-child(1) > ul > li:nth-child(1) > a'
  >> old_url = "https://web.archive.org/web/20100102003420/http://stackoverflow.com/"
  >> new_url = "https://stackoverflow.com/"
  >>
  >> page = Fetcher(automatch_domain='stackoverflow.com').get(old_url, timeout=30)
  >> element1 = page.css_first(selector, auto_save=True)
  >>
  >> # Same selector but used in the updated website
  >> page = Fetcher(automatch_domain="stackoverflow.com").get(new_url)
  >> element2 = page.css_first(selector, auto_match=True)
  >>
  >> if element1.text == element2.text:
  'Scrapling found the same element in the old design and the new design!'
  ```
  Note that I used a new argument called `automatch_domain`, this is because for Scrapling these are two different URLs, not the website so it isolates their data. To tell Scrapling they are the same website, we then pass the domain we want to use for saving auto-match data for them both so Scrapling doesn't isolate them.
  In a real-world scenario, the code will be the same except it will use the same URL for both requests so you won't need to use the `automatch_domain` argument. This is the closest example I can give to real-world cases so I hope it didn't confuse you :)
  **Notes:**
  1. For the two examples above I used one time the `Adaptor` class and the second time the `Fetcher` class just to show you that you can create the `Adaptor` object by yourself if you have the source or fetch the source using any `Fetcher` class then it will create the `Adaptor` object for you.
  2. Passing the `auto_save` argument with the `auto_match` argument set to `False` while initializing the Adaptor/Fetcher object will only result in ignoring the `auto_save` argument value and the following warning message
      ```text
      Argument `auto_save` will be ignored because `auto_match` wasn't enabled on initialization. Check docs for more info.
      ```
      This behavior is purely for performance reasons so the database gets created/connected only when you are planning to use the auto-matching features. Same case with the `auto_match` argument.
  3. The `auto_match` parameter works only for `Adaptor` instances not `Adaptors` so if you do something like this you will get an error
      ```python
      page.css('body').css('#p1', auto_match=True)
      ```
      because you can't auto-match a whole list, you have to be specific and do something like
      ```python
      page.css_first('body').css('#p1', auto_match=True)
      ```

  Inspired by BeautifulSoup's `find_all` function you can find elements by using `find_all`/`find` methods. Both methods can take multiple types of filters and return all elements in the pages that all these filters apply to.
  * To be more specific:
    * Any string passed is considered a tag name
    * Any iterable passed like List/Tuple/Set is considered an iterable of tag names.
    * Any dictionary is considered a mapping of HTML element(s) attribute names and attribute values.
    * Any regex patterns passed are used as filters
    * Any functions passed are used as filters
    * Any keyword argument passed is considered as an HTML element attribute with its value.
  So the way it works is after collecting all passed arguments and keywords, each filter passes its results to the following filter in a waterfall-like filtering system.
  <br/>It filters all elements in the current page/element in the following order:
  1. All elements with the passed tag name(s).
  2. All elements that match all passed attribute(s).
  3. All elements that match all passed regex patterns.
  4. All elements that fulfill all passed function(s).
  Note: The filtering process always starts from the first filter it finds in the filtering order above so if no tag name(s) are passed but attributes are passed, the process starts from that layer and so on. **But the order in which you pass the arguments doesn't matter.**
  Examples to clear any confusion :)
  ```python
  >> from scrapling import Fetcher
  >> page = Fetcher().get('https://quotes.toscrape.com/')

  >> page.find_all('div')
  [<data='<div class="container"> <div class="row...' parent='<body> <div class="container"> <div clas...'>,
   <data='<div class="row header-box"> <div class=...' parent='<div class="container"> <div class="row...'>,

  >> page.find_all('div', class_='quote')
  [<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
   <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,

  >> page.find_all('div', {'class': 'quote'})
  [<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
   <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,

  >> page.find_all({'class': 'quote'})
  [<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
   <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,

  >> page.find_all('div', {'class': 'quote'}, lambda e: "world" in e.css_first('.text::text'))
  [<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>]

  >> page.find_all(lambda element: len(element.children) > 0)
  [<data='<html lang="en"><head><meta charset="UTF...'>,
   <data='<head><meta charset="UTF-8"><title>Quote...' parent='<html lang="en"><head><meta charset="UTF...'>,
   <data='<body> <div class="container"> <div clas...' parent='<html lang="en"><head><meta charset="UTF...'>,

  >> page.find_all(lambda element: "world" in element.text)
  [<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>,
   <data='<a class="tag" href="/tag/world/page/1/"...' parent='<div class="tags"> Tags: <meta class="ke...'>]

  >> page.find_all('span', re.compile(r'world'))
  [<data='<span class="text" itemprop="text">“The...' parent='<div class="quote" itemscope itemtype="h...'>]

  >> page.find_all(['div', 'span'], {'class': 'quote'})
  [<data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,
   <data='<div class="quote" itemscope itemtype="h...' parent='<div class="col-md-8"> <div class="quote...'>,

  >> page.find_all({'itemtype':"http://schema.org/CreativeWork"}, 'div').css('.author::text')
  ['Albert Einstein',
   'J.K. Rowling',
  ```

  Here's what else you can do with Scrapling:
  - Accessing the `lxml.etree` object itself of any element directly
      ```python
      >>> quote._root
      <Element div at 0x107f98870>
      ```
  - Saving and retrieving elements manually to auto-match them outside the `css` and the `xpath` methods but you have to set the identifier by yourself.
    - To save an element to the database:
      ```python
      >>> element = page.find_by_text('Tipping the Velvet', first_match=True)
      >>> page.save(element, 'my_special_element')
      ```
    - Now later when you want to retrieve it and relocate it inside the page with auto-matching, it would be like this
      ```python
      >>> element_dict = page.retrieve('my_special_element')
      >>> page.relocate(element_dict, adaptor_type=True)
      [<data='<a href="catalogue/tipping-the-velvet_99...' parent='<h3><a href="catalogue/tipping-the-velve...'>]
      >>> page.relocate(element_dict, adaptor_type=True).css('::text')
      ['Tipping the Velvet']
      ```
    - if you want to keep it as `lxml.etree` object, leave the `adaptor_type` argument
      ```python
      >>> page.relocate(element_dict)
      [<Element a at 0x105a2a7b0>]
      ```
  - Filtering results based on a function
  ```python

  expensive_products = page.css('.product_pod').filter(
      lambda p: float(p.css('.price_color').re_first(r'[\d\.]+')) > 50
  )
  ```
  - Searching results for the first one that matches a function
  ```python

  page.css('.product_pod').search(
      lambda p: float(p.css('.price_color').re_first(r'[\d\.]+')) == 54.23
  )
  ```
  - Doing operations on element content is the same as scrapy
      ```python
      quote.re(r'regex_pattern')  # Get all strings (TextHandlers) that match the regex pattern
      quote.re_first(r'regex_pattern')  # Get the first string (TextHandler) only
      quote.json()  # If the content text is jsonable, then convert it to json using `orjson` which is 10x faster than the standard json library and provides more options
      ```
      except that you can do more with them like
      ```python
      quote.re(
          r'regex_pattern',
          replace_entities=True,  # Character entity references are replaced by their corresponding character
          clean_match=True,       # This will ignore all whitespaces and consecutive spaces while matching
          case_sensitive= False,  # Set the regex to ignore letters case while compiling it
      )
      ```
      Hence all of these methods are methods from the `TextHandler` within that contains the text content so the same can be done directly if you call the `.text` property or equivalent selector function.
  - Doing operations on the text content itself includes
    - Cleaning the text from any white spaces and replacing consecutive spaces with single space
      ```python
      quote.clean()
      ```
    - You already know about the regex matching and the fast json parsing but did you know that all strings returned from the regex search are actually `TextHandler` objects too? so in cases where you have for example a JS object assigned to a JS variable inside JS code and want to extract it with regex and then convert it to json object, in other libraries, these would be more than 1 line of code but here you can do it in 1 line like this
      ```python
      page.xpath('//script/text()').re_first(r'var dataLayer = (.+);').json()
      ```
    - Sort all characters in the string as if it were a list and return the new string
      ```python
      quote.sort(reverse=False)
      ```
    > To be clear, `TextHandler` is a sub-class of Python's `str` so all normal operations/methods that work with Python strings will work with it.
  - Any element's attributes are not exactly a dictionary but a sub-class of [mapping](https://docs.python.org/3/glossary.html#term-mapping) called `AttributesHandler` that's read-only so it's faster and string values returned are actually `TextHandler` objects so all operations above can be done on them, standard dictionary operations that don't modify the data, and more :)
    - Unlike standard dictionaries, here you can search by values too and can do partial searches. It might be handy in some cases (returns a generator of matches)
      ```python
      >>> for item in element.attrib.search_values('catalogue', partial=True):
              print(item)
      {'href': 'catalogue/tipping-the-velvet_999/index.html'}
      ```
    - Serialize the current attributes to JSON bytes:
      ```python
      >>> element.attrib.json_string
      b'{"href":"catalogue/tipping-the-velvet_999/index.html","title":"Tipping the Velvet"}'
      ```
    - Converting it to a normal dictionary
      ```python
      >>> dict(element.attrib)
      {'href': 'catalogue/tipping-the-velvet_999/index.html',
      'title': 'Tipping the Velvet'}
      ```
  Scrapling is under active development so expect many more features coming soon :)

  There are a lot of deep details skipped here to make this as short as possible so to take a deep dive, head to the [docs](https://github.com/D4Vinci/Scrapling/tree/main/docs) section. I will try to keep it updated as possible and add complex examples. There I will explain points like how to write your storage system, write spiders that don't depend on selectors at all, and more...
  Note that implementing your storage system can be complex as there are some strict rules such as inheriting from the same abstract class, following the singleton design pattern used in other classes, and more. So make sure to read the docs first.
  > [!IMPORTANT]
  > A website is needed to provide detailed library documentation.<br/>
  > I'm trying to rush creating the website, researching new ideas, and adding more features/tests/benchmarks but time is tight with too many spinning plates between work, personal life, and working on Scrapling. I have been working on Scrapling for months for free after all.<br/><br/>
  > If you like `Scrapling` and want it to keep improving then this is a friendly reminder that you can help by supporting me through the [sponsor button](https://github.com/sponsors/D4Vinci).

  This section addresses common questions about Scrapling, please read this section before opening an issue.

    1. You need to get a working selector and run it at least once with methods `css` or `xpath` with the `auto_save` parameter set to `True` before structural changes happen.
    2. Before returning results for you, Scrapling uses its configured database and saves unique properties about that element.
    3. Now because everything about the element can be changed or removed, nothing from the element can be used as a unique identifier for the database. To solve this issue, I made the storage system rely on two things:
       1. The domain of the URL you gave while initializing the first Adaptor object
       2. The `identifier` parameter you passed to the method while selecting. If you didn't pass one, then the selector string itself will be used as an identifier but remember you will have to use it as an identifier value later when the structure changes and you want to pass the new selector.
       Together both are used to retrieve the element's unique properties from the database later.
    4. Now later when you enable the `auto_match` parameter for both the Adaptor instance and the method call. The element properties are retrieved and Scrapling loops over all elements in the page and compares each one's unique properties to the unique properties we already have for this element and a score is calculated for each one.
    5. Comparing elements is not exact but more about finding how similar these values are, so everything is taken into consideration, even the values' order, like the order in which the element class names were written before and the order in which the same element class names are written now.
    6. The score for each element is stored in the table, and the element(s) with the highest combined similarity scores are returned.

  Not a big problem as it depends on your usage. The word `default` will be used in place of the URL field while saving the element's unique properties. So this will only be an issue if you used the same identifier later for a different website that you didn't pass the URL parameter while initializing it as well. The save process will overwrite the previous data and auto-matching uses the latest saved properties only.

  For each element, Scrapling will extract:
  - Element tag name, text, attributes (names and values), siblings (tag names only), and path (tag names only).
  - Element's parent tag name, attributes (names and values), and text.

  That's because passing the `auto_save`/`auto_match` argument without setting `auto_match` to `True` while initializing the Adaptor object will only result in ignoring the `auto_save`/`auto_match` argument value. This behavior is purely for performance reasons so the database gets created only when you are planning to use the auto-matching features.

  It could be one of these reasons:
  1. No data were saved/stored for this element before.
  2. The selector passed is not the one used while storing element data. The solution is simple
     - Pass the old selector again as an identifier to the method called.
     - Retrieve the element with the retrieve method using the old selector as identifier then save it again with the save method and the new selector as identifier.
     - Start using the identifier argument more often if you are planning to use every new selector from now on.
  3. The website had some extreme structural changes like a new full design. If this happens a lot with this website, the solution would be to make your code as selector-free as possible using Scrapling features.

  Pretty much yeah, almost all features you get from BeautifulSoup can be found or achieved in Scrapling one way or another. In fact, if you see there's a feature in bs4 that is missing in Scrapling, please make a feature request from the issues tab to let me know.

  Of course, you can find elements by text/regex, find similar elements in a more reliable way than AutoScraper, and finally save/retrieve elements manually to use later as the model feature in AutoScraper. I have pulled all top articles about AutoScraper from Google and tested Scrapling against examples in them. In all examples, Scrapling got the same results as AutoScraper in much less time.

  Yes, Scrapling instances are thread-safe. Each Adaptor instance maintains its state.

  <a href="https://serpapi.com/?utm_source=scrapling"><img src="https://raw.githubusercontent.com/D4Vinci/Scrapling/main/images/SerpApi.png" height="500" alt="SerpApi Banner" ></a>

  Everybody is invited and welcome to contribute to Scrapling. There is a lot to do!
  Please read the [contributing file](https://github.com/D4Vinci/Scrapling/blob/main/CONTRIBUTING.md) before doing anything.

  > [!CAUTION]
  > This library is provided for educational and research purposes only. By using this library, you agree to comply with local and international laws regarding data scraping and privacy. The authors and contributors are not responsible for any misuse of this software. This library should not be used to violate the rights of others, for unethical purposes, or to use data in an unauthorized or illegal manner. Do not use it on any website unless you have permission from the website owner or within their allowed rules like the `robots.txt` file, for example.

  This work is licensed under BSD-3

  This project includes code adapted from:
  - Parsel (BSD License) - Used for [translator](https://github.com/D4Vinci/Scrapling/blob/main/scrapling/translator.py) submodule

  - [Daijro](https://github.com/daijro)'s brilliant work on both [BrowserForge](https://github.com/daijro/browserforge) and [Camoufox](https://github.com/daijro/camoufox)
  - [Vinyzu](https://github.com/Vinyzu)'s work on Playwright's mock on [Botright](https://github.com/Vinyzu/Botright)
  - [brotector](https://github.com/kaliiiiiiiiii/brotector)
  - [fakebrowser](https://github.com/kkoooqq/fakebrowser)
  - [rebrowser-patches](https://github.com/rebrowser/rebrowser-patches)


pkgId: 59128a0a4aa0698db5ecefbc2ea4b8719397a314bc25d46d3d18a71ae88b991d
name: python-scrapy-nodriver-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for scrapy-nodriver
url: https://github.com/Ehsan-U/scrapy-nodriver
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scrapy-nodriver-0.0.7-1.src.rpm
location_href: Packages/python-scrapy-nodriver-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  [![version](https://img.shields.io/pypi/v/scrapy-nodriver.svg)](https://pypi.python.org/pypi/scrapy-nodriver)
  [![pyversions](https://img.shields.io/pypi/pyversions/scrapy-nodriver.svg)](https://pypi.python.org/pypi/scrapy-nodriver)


  A [Scrapy](https://github.com/scrapy/scrapy) Download Handler which performs requests using
  [Nodriver](https://github.com/ultrafunkamsterdam/nodriver).
  It can be used to handle pages that require JavaScript (among other things),
  while adhering to the regular Scrapy workflow (i.e. without interfering
  with request scheduling, item processing, etc).


  What makes this package different from package like [Scrapy-Playwright](https://github.com/scrapy-plugins/scrapy-playwright), is the optimization to stay undetected for most anti-bot solutions.
  [CDP](https://chromedevtools.github.io/devtools-protocol/) communication provides even better resistance against web applicatinon firewalls (WAF’s), while performance gets a massive boost.





  After the release of [version 2.0](https://docs.scrapy.org/en/latest/news.html#scrapy-2-0-0-2020-03-03),
  which includes [coroutine syntax support](https://docs.scrapy.org/en/2.0/topics/coroutines.html)
  and [asyncio support](https://docs.scrapy.org/en/2.0/topics/asyncio.html), Scrapy allows
  to integrate `asyncio`-based projects such as `Nodriver`.<br>
  Note: Chrome must be installed on the system.



  * Python >= 3.8
  * Scrapy >= 2.0 (!= 2.4.0)




  `scrapy-nodriver` is available on PyPI and can be installed with `pip`:

  ```
  pip install scrapy-nodriver
  ```

  `nodriver` is defined as a dependency so it gets installed automatically,







  Replace the default `http` and/or `https` Download Handlers through
  [`DOWNLOAD_HANDLERS`](https://docs.scrapy.org/en/latest/topics/settings.html):

  ```python

  DOWNLOAD_HANDLERS = {
      "http": "scrapy_nodriver.handler.ScrapyNodriverDownloadHandler",
      "https": "scrapy_nodriver.handler.ScrapyNodriverDownloadHandler",
  }
  ```

  Note that the `ScrapyNodriverDownloadHandler` class inherits from the default
  `http/https` handler. Unless explicitly marked (see [Basic usage](#basic-usage)),
  requests will be processed by the regular Scrapy download handler.




  [Install the `asyncio`-based Twisted reactor](https://docs.scrapy.org/en/latest/topics/asyncio.html#installing-the-asyncio-reactor):

  ```python

  TWISTED_REACTOR = "twisted.internet.asyncioreactor.AsyncioSelectorReactor"
  ```

  This is the default in new projects since [Scrapy 2.7](https://github.com/scrapy/scrapy/releases/tag/2.7.0).




  Set the [`nodriver`](#nodriver) [Request.meta](https://docs.scrapy.org/en/latest/topics/request-response.html#scrapy.http.Request.meta)
  key to download a request using Nodriver:

  ```python
  import scrapy

  class AwesomeSpider(scrapy.Spider):
      name = "awesome"

      def start_requests(self):
          
          yield scrapy.Request("https://httpbin.org/get", meta={"nodriver": True})

      def parse(self, response, **kwargs):
          
          return {"url": response.url}
  ```



  Type `Optional[int]`, defaults to the value of Scrapy's `CONCURRENT_REQUESTS` setting

  Maximum amount of allowed concurrent Nodriver pages.

  ```python
  NODRIVER_MAX_CONCURRENT_PAGES = 8
  ```


  Type `Optional[List]`, default `None`

  Block resources on the page.

  ```python
  NODRIVER_BLOCKED_URLS = [
      "*/*.jpg",
      "*/*.png",
      "*/*.gif",
      "*/*.webp",
      "*/*.svg",
      "*/*.ico"
  ]
  ```


  Type `Optional[bool]`, default `True`

  ```python
  NODRIVER_HEADLESS = True
  ```






  Type `bool`, default `False`

  If set to a value that evaluates to `True` the request will be processed by Nodriver.

  ```python
  return scrapy.Request("https://example.org", meta={"nodriver": True})
  ```


  Type `bool`, default `False`

  If `True`, the [Nodriver page]
  that was used to download the request will be available in the callback at
  `response.meta['nodriver_page']`. If `False` (or unset) the page will be
  closed immediately after processing the request.

  **Important!**

  This meta key is entirely optional, it's NOT necessary for the page to load or for any
  asynchronous operation to be performed (specifically, it's NOT necessary for `PageMethod`
  objects to be applied). Use it only if you need access to the Page object in the callback
  that handles the response.

  For more information and important notes see
  [Receiving Page objects in callbacks](#receiving-page-objects-in-callbacks).

  ```python
  return scrapy.Request(
      url="https://example.org",
      meta={"nodriver": True, "nodriver_include_page": True},
  )
  ```


  Type `Iterable[PageMethod]`, default `()`

  An iterable of [`scrapy_nodriver.page.PageMethod`](#pagemethod-class)
  objects to indicate actions to be performed on the page before returning the
  final response. See [Executing actions on pages](#executing-actions-on-pages).


  Type `Optional[nodriver.Tab]`, default `None`

  A [Nodriver page]() to be used to
  download the request. If unspecified, a new page is created for each request.
  This key could be used in conjunction with `nodriver_include_page` to make a chain of
  requests using the same page. For instance:

  ```python
  from nodriver import Tab

  def start_requests(self):
      yield scrapy.Request(
          url="https://httpbin.org/get",
          meta={"nodriver": True, "nodriver_include_page": True},
      )

  def parse(self, response, **kwargs):
      page: Tab = response.meta["nodriver_page"]
      yield scrapy.Request(
          url="https://httpbin.org/headers",
          callback=self.parse_headers,
          meta={"nodriver": True, "nodriver_page": page},
      )
  ```

  ```python
  from nodriver import Tab
  import scrapy

  class AwesomeSpiderWithPage(scrapy.Spider):
      name = "page_spider"

      def start_requests(self):
          yield scrapy.Request(
              url="https://example.org",
              callback=self.parse_first,
              meta={"nodriver": True, "nodriver_include_page": True},
              errback=self.errback_close_page,
          )

      def parse_first(self, response):
          page: Tab = response.meta["nodriver_page"]
          return scrapy.Request(
              url="https://example.com",
              callback=self.parse_second,
              meta={"nodriver": True, "nodriver_include_page": True, "nodriver_page": page},
              errback=self.errback_close_page,
          )

      async def parse_second(self, response):
          page: Tab = response.meta["nodriver_page"]
          title = await page.title()  # "Example Domain"
          await page.close()
          return {"title": title}

      async def errback_close_page(self, failure):
          page: Tab = failure.request.meta["nodriver_page"]
          await page.close()
  ```

  **Notes:**

  * When passing `nodriver_include_page=True`, make sure pages are always closed
    when they are no longer used. It's recommended to set a Request errback to make
    sure pages are closed even if a request fails (if `nodriver_include_page=False`
    pages are automatically closed upon encountering an exception).
    This is important, as open pages count towards the limit set by
    `NODRIVER_MAX_CONCURRENT_PAGES` and crawls could freeze if the limit is reached
    and pages remain open indefinitely.
  * Defining callbacks as `async def` is only necessary if you need to `await` things,
    it's NOT necessary if you just need to pass over the Page object from one callback
    to another (see the example above).
  * Any network operations resulting from awaiting a coroutine on a Page object
    (`get`, etc) will be executed directly by Nodriver, bypassing the
    Scrapy request workflow (Scheduler, Middlewares, etc).





  A sorted iterable (e.g. `list`, `tuple`) of `PageMethod` objects
  could be passed in the `nodriver_page_methods`
  [Request.meta](https://docs.scrapy.org/en/latest/topics/request-response.html#scrapy.http.Request.meta)
  key to request methods to be invoked on the `Page` object before returning the final
  `Response` to the callback.

  This is useful when you need to perform certain actions on a page (like scrolling
  down or clicking links) and you want to handle only the final result in your callback.





  Represents a method to be called (and awaited if necessary) on a
  `nodriver.Tab` object (e.g. "select", "save_screenshot", "evaluate", etc).
  `method` is the name of the method, `*args` and `**kwargs`
  are passed when calling such method. The return value
  will be stored in the `PageMethod.result` attribute.

  For instance:
  ```python
  def start_requests(self):
      yield Request(
          url="https://example.org",
          meta={
              "nodriver": True,
              "nodriver_page_methods": [
                  PageMethod("save_screenshot", filename="example.jpeg", full_page=True),
              ],
          },
      )

  def parse(self, response, **kwargs):
      screenshot = response.meta["nodriver_page_methods"][0]
      
  ```

  produces the same effect as:
  ```python
  def start_requests(self):
      yield Request(
          url="https://example.org",
          meta={"nodriver": True, "nodriver_include_page": True},
      )

  async def parse(self, response, **kwargs):
      page = response.meta["nodriver_page"]
      filepath = await page.save_screenshot(filename="example.jpeg", full_page=True)
      await page.close()
  ```




  Refer to the [upstream docs for the `Tab` class](https://github.com/ultrafunkamsterdam/nodriver)
  to see available methods.


  **Scroll down on an infinite scroll page, take a screenshot of the full page**

  ```python
  class ScrollSpider(scrapy.Spider):
      name = "scroll"

      def start_requests(self):
          yield scrapy.Request(
              url="http://quotes.toscrape.com/scroll",
              meta=dict(
                  nodriver=True,
                  nodriver_include_page=True,
                  nodriver_page_methods=[
                      PageMethod("wait_for", "div.quote"),
                      PageMethod("evaluate", "window.scrollBy(0, document.body.scrollHeight)"),
                      PageMethod("wait_for", "div.quote:nth-child(11)"),  # 10 per page
                  ],
              ),
          )

      async def parse(self, response, **kwargs):
          page = response.meta["nodriver_page"]
          await page.save_screenshot(filename="quotes.jpeg", full_page=True)
          await page.close()
          return {"quote_count": len(response.css("div.quote"))}  # quotes from several pages
  ```






  Specifying a proxy via the `proxy` Request meta key is not supported.



  Before opening an issue please make sure the unexpected behavior can only be
  observed by using this package and not with standalone Nodriver. To do this,
  translate your spider code to a reasonably close Nodriver script: if the
  issue also occurs this way, you should instead report it
  [upstream](https://github.com/ultrafunkamsterdam/nodriver).
  For instance:

  ```python
  import scrapy

  class ExampleSpider(scrapy.Spider):
      name = "example"

      def start_requests(self):
          yield scrapy.Request(
              url="https://example.org",
              meta=dict(
                  nodriver=True,
                  nodriver_page_methods=[
                      PageMethod("save_screenshot", filename="example.jpeg", full_page=True),
                  ],
              ),
          )
  ```

  translates roughly to:

  ```python
  import asyncio
  import nodriver as uc

  async def main():
      browser = await uc.start()
      page = await browser.get("https://example.org")
      await page.save_screenshot(filename="example.jpeg", full_page=True)
      await page.close()

  if __name__ == '__main__':
      uc.loop().run_until_complete(main())
  ```


pkgId: fa633fe1227def27a088532bbbc19cf903e070542496e76c56d747d5ef6edf4c
name: python-scrapyloganalyzer-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for scrapyloganalyzer
url: https://github.com/open-contracting/scrapy-log-analyzer
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-scrapyloganalyzer-0.0.1-1.src.rpm
location_href: Packages/python-scrapyloganalyzer-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  |PyPI Version| |Build Status| |Coverage Status| |Python Version|

  Provides methods to analyze the quality of a Scrapy crawl.

  (If you are viewing this on GitHub, open the `full documentation <https://scrapy-log-analyzer.readthedocs.io/>`__ for additional details.)

  .. |PyPI Version| image:: https://img.shields.io/pypi/v/scrapyloganalyzer.svg
     :target: https://pypi.org/project/scrapyloganalyzer/
  .. |Build Status| image:: https://github.com/open-contracting/scrapy-log-analyzer/actions/workflows/ci.yml/badge.svg
     :target: https://github.com/open-contracting/scrapy-log-analyzer/actions/workflows/ci.yml
  .. |Coverage Status| image:: https://coveralls.io/repos/github/open-contracting/scrapy-log-analyzer/badge.svg?branch=main
     :target: https://coveralls.io/github/open-contracting/scrapy-log-analyzer?branch=main
  .. |Python Version| image:: https://img.shields.io/pypi/pyversions/scrapyloganalyzer.svg
     :target: https://pypi.org/project/scrapyloganalyzer/


pkgId: 1590b0853daea40e14225afcbfd1e03715df12b1665030267b0b35dac9681b26
name: python-screenrecord-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for screenrecord
url: https://github.com/sukhbinder/screenrecord
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-screenrecord-1.1.0-1.src.rpm
location_href: Packages/python-screenrecord-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/screenrecord.svg)](https://pypi.org/project/screenrecord/)
  [![Changelog](https://img.shields.io/github/v/release/sukhbinder/screenrecord?include_prereleases&label=changelog)](https://github.com/sukhbinder/screenrecord/releases)
  [![Tests](https://github.com/sukhbinder/screenrecord/actions/workflows/test.yml/badge.svg)](https://github.com/sukhbinder/screenrecord/actions/workflows/test.yml)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/sukhbinder/screenrecord/blob/master/LICENSE)

  Record screen with python



  Install this tool using `pip`:
  ```bash
  pip install screenrecord
  ```


  For help, run:
  ```bash
  record --help
  ```
  You can also use:
  ```bash
  python -m record --help
  ```

  Shows

  ```bash
  usage: record [-h] [-i INITDELAY] [-d DELAY] [-dur DURATION]
                [--bbox BBOX [BBOX ...]] [-f] [-aw]
                filename

  Screen Recording with python

  positional arguments:
    filename              filename can be mp4 or gif or mov

  optional arguments:
    -h, --help            show this help message and exit
    -i INITDELAY, --initdelay INITDELAY
                          Initial delay in seconds, default 5 s
    -d DELAY, --delay DELAY
                          Delay between frames in seconds, default 0.5 s
    -dur DURATION, --duration DURATION
                          Duration of capture, default 20 s
    --bbox BBOX [BBOX ...]
                          Bounding box, default (0, 0, 50, 50)
    -f, --fullscreen
    -aw, --activewindow

  ```

  ![demo usage of screenrecord](https://raw.githubusercontent.com/sukhbinder/screenrecord/main/usage.gif)



  To contribute to this tool, first checkout the code. Then create a new virtual environment:
  ```bash
  cd screenrecord
  python -m venv venv
  source venv/bin/activate
  ```
  Now install the dependencies and test dependencies:
  ```bash
  pip install -e '.[test]'
  ```
  To run the tests:
  ```bash
  python -m pytest
  ```


pkgId: 1b269fc11b53571cfa90e2f70f27c60095964c4ac67d5e02b4395d82f40bd018
name: python-sdcflows-help
arch: noarch
version: 2.11.0
epoch: 0
release: 1
summary: Development documents and examples for sdcflows
url: https://pypi.org/project/sdcflows/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sdcflows-2.11.0-1.src.rpm
location_href: Packages/python-sdcflows-help-2.11.0-1.noarch.rpm
checksum_type: sha256
description:
  SDCFlows (*Susceptibility Distortion Correction workFlows*) is a Python library of
  *NiPype*-based workflows to preprocess *B0* mapping data, estimate the corresponding
  fieldmap and finally correct for susceptibility distortions.
  Susceptibility-derived distortions are typically displayed by images acquired with EPI
  (echo-planar imaging) MR schemes.
  The library is designed to provide an easily accessible, state-of-the-art interface that is
  robust to differences in scan acquisition protocols and that requires minimal user input.
  This open-source neuroimaging data processing tool is being developed as a part of
  the MRI image analysis and reproducibility platform offered by
  `NiPreps <https://www.nipreps.org>`__.


pkgId: 40834340d6268b08afc504213d101d662ff2f74f83b050fbbe7889ecbfd331f1
name: python-sdk_entrepot_gpf-help
arch: noarch
version: 0.1.32
epoch: 0
release: 1
summary: Development documents and examples for sdk_entrepot_gpf
url: https://pypi.org/project/sdk_entrepot_gpf/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sdk_entrepot_gpf-0.1.32-1.src.rpm
location_href: Packages/python-sdk_entrepot_gpf-help-0.1.32-1.noarch.rpm
checksum_type: sha256
description:
  Installez le module via pip :

  ```sh
  pip install sdk_entrepot_gpf
  ```

  Vous pouvez ensuite l'[utiliser comme exécutable](https://geoplateforme.github.io/sdk-entrepot/comme-executable/) ou l'[importer dans vos scripts Python](https://geoplateforme.github.io/sdk-entrepot/comme-module/).



  Si vous souhaitez participer au développement du projet, consultez le [document détaillant comment procéder](https://geoplateforme.github.io/sdk-entrepot/development/).


pkgId: c295d235039a8c9673bab09ce0831f34b777a69d55207d68bfe51b324e1439ba
name: python-sdmx1-help
arch: noarch
version: 2.20.0
epoch: 0
release: 1
summary: Development documents and examples for sdmx1
url: https://github.com/khaeru/sdmx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sdmx1-2.20.0-1.src.rpm
location_href: Packages/python-sdmx1-help-2.20.0-1.noarch.rpm
checksum_type: sha256
description:
  See https://sdmx1.readthedocs.io/en/latest/ for the latest docs per the ``main`` branch, or https://sdmx1.readthedocs.io/en/stable/ for the most recent release.


pkgId: b4b0cd4f6ea13264042792affe0f82603d1201072aea89cf0fd24e2508561e2b
name: python-sdr-help
arch: noarch
version: 0.0.25
epoch: 0
release: 1
summary: Development documents and examples for sdr
url: https://github.com/mhostetter/sdr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sdr-0.0.25-1.src.rpm
location_href: Packages/python-sdr-help-0.0.25-1.noarch.rpm
checksum_type: sha256
description:
  <div align=center>
    <a href="https://pypi.org/project/sdr"><img src="https://img.shields.io/pypi/v/sdr"></a>
    <a href="https://pypi.org/project/sdr"><img src="https://img.shields.io/pypi/pyversions/sdr"></a>
    <a href="https://pypi.org/project/sdr"><img src="https://img.shields.io/pypi/wheel/sdr"></a>
    <a href="https://pypistats.org/packages/sdr"><img src="https://img.shields.io/pypi/dm/sdr"></a>
    <a href="https://pypi.org/project/sdr"><img src="https://img.shields.io/pypi/l/sdr"></a>
  </div>
  <div align=center>
    <a href="https://github.com/mhostetter/sdr/actions/workflows/lint.yaml"><img src="https://github.com/mhostetter/sdr/actions/workflows/lint.yaml/badge.svg?branch=main"></a>
    <a href="https://github.com/mhostetter/sdr/actions/workflows/build.yaml"><img src="https://github.com/mhostetter/sdr/actions/workflows/build.yaml/badge.svg?branch=main"></a>
    <a href="https://github.com/mhostetter/sdr/actions/workflows/test.yaml"><img src="https://github.com/mhostetter/sdr/actions/workflows/test.yaml/badge.svg?branch=main"></a>
    <a href="https://codecov.io/gh/mhostetter/sdr"><img src="https://codecov.io/gh/mhostetter/sdr/branch/main/graph/badge.svg?token=3FJML79ZUK"></a>
    <a href="https://twitter.com/sdr_py"><img src="https://img.shields.io/static/v1?label=follow&message=@sdr_py&color=blue&logo=twitter"></a>
  </div>

  The `sdr` library is a Python 3 package for software-defined radio (SDR).

  The goal of `sdr` is to provide tools to design, analyze, build, and test digital communication systems
  in Python. The library relies on and is designed to be interoperable with NumPy, SciPy, and Matplotlib.
  Performance is also very important. So, where possible, Numba is used to accelerate computationally intensive
  functions.

  Additionally, the library aims to replicate relevant functionality from MATLAB's Communications and
  DSP Toolboxes.

  We are progressively adding functionality to the library. If there is something you'd like to see included
  in `sdr`, please open an issue on GitHub.

  > Enjoying the library? Give us a :star: on [GitHub](https://github.com/mhostetter/sdr)!



  The documentation for `sdr` is located at <https://mhostetter.github.io/sdr/latest/>.



  The latest version of `sdr` can be installed from [PyPI](https://pypi.org/project/sdr/) using `pip`.

  ```console
  python3 -m pip install sdr
  ```



  View all available classes and functions in the [API Reference](https://mhostetter.github.io/sdr/latest/api/dsp/).

  - **Digital signal processing**: Finite impulse response (FIR) filters, FIR filter design,
    infinite impulse response (IIR) filters, polyphase interpolators, polyphase decimators, polyphase resamplers,
    polyphase channelizers, Farrow arbitrary resamplers, fractional delay FIR filters, FIR moving averagers,
    FIR differentiators, IIR integrators, IIR leaky integrators, complex mixing, real/complex conversion.
  - **Sequences**: Binary, Gray, Barker, Hadamard, Walsh, Gold, Kasami, Zadoff-Chu, $m$-sequences, preferred pairs,
    Fibonacci LFSRs, Galois LFSRs, LFSR synthesis.
  - **Coding**: Block interleavers, additive scramblers.
  - **Modulation**: Phase-shift keying (PSK), $\pi/M$ PSK, offset QPSK, continuous-phase modulation (CPM),
    minimum-shift keying (MSK), rectangular pulse shapes, half-sine pulse shapes, Gaussian pulse shapes,
    raised cosine pulse shapes, root raised cosine pulse shapes, differential encoding.
  - **Estimation**: TOA, TDOA, FOA, FDOA Cramér-Rao lower bounds.
  - **Detection**: Detector probability density functions (PDFs). Theoretical probability of detection, probability of
    false alarm, and thresholds. Detection performance approximations. Coherent gain, coherent gain loss (CGL),
    and non-coherent gain. Maximum-allowable integration time and frequency offset.
  - **Synchronization**: Numerically controlled oscillators (NCO), loop filters, closed-loop phase-locked loop (PLL)
    analysis, phase error detectors (PEDs), automatic gain control (AGC).
  - **Measurement**: Energy, power, voltage, Euclidean distance, Hamming distance, bit/symbol error rate,
    error vector magnitude (EVM), RMS integration time, and RMS bandwidth.
  - **Conversions**: Between linear units and decibels. Between $E_b/N_0$, $E_s/N_0$, and $S/N$.
  - **Simulation**: Binary symmetric channels (BSC), binary erasure channels (BEC), discrete memoryless channels (DMC).
    Apply additive white Gaussian noise (AWGN), frequency offset, sample rate offset, IQ imbalance.
  - **Link budgets**: BSC, BEC, AWGN, and BI-AWGN channel capacity, Shannon's limit on $E_b/N_0$ and $S/N$,
    free-space path loss, antenna gain.
  - **Miscellaneous**: Numerical calculation of PDF of sum and product of random variables. Packing and unpacking binary
    data, hexdump of binary data.
  - **Plotting**: Time-domain, raster, correlation, stem, discrete Fourier transform (DFT), discrete-time Fourier
    transform (DTFT), periodogram, spectrogram, constellation, symbol map, eye diagram, phase tree,
    bit error rate (BER), symbol error rate (SER), probability of detection, receiver operating characteristic (ROC),
    detection PDFs, impulse response, step response, zeros/poles, magnitude response, phase response,
    phase delay, and group delay.



  There are detailed examples published at <https://mhostetter.github.io/sdr/latest/examples/fir-filters/>.
  The Jupyter notebooks behind the examples are available for experimentation in `docs/examples/`.



  If this library was useful to you in your research, please cite us. Following the
  [GitHub citation standards](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/about-citation-files),
  here is the recommended citation.



  ```bibtex
  @software{Hostetter_SDR_2023,
      title = {{sdr: A software-defined radio package for Python}},
      author = {Hostetter, Matt},
      month = {7},
      year = {2023},
      url = {https://github.com/mhostetter/sdr},
  }
  ```



  ```
  Hostetter, M. (2023). sdr: A software-defined radio package for Python [Computer software]. https://github.com/mhostetter/sdr
  ```


